opencode-goal-plugin 0.4.7 → 0.5.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.5.0 — 2026-07-08
+
+- Replace the single-line "Compatibility snapshot" in the README with an OpenCode version compatibility table, manually verified via `tmux` + the OpenCode TUI against the persisted state file for each provider/model combination.
+- Add `docs/providers.md`, a provider/model compatibility guide covering evidence-gated marker-compliance behavior for `opencode-go/qwen3.7-plus`, `opencode-go/glm-5.2`, and `deepseek/deepseek-chat` (manually verified via the OpenCode TUI against real provider credentials on OpenCode 1.17.15), plus a step-by-step guide for testing new models.
+- Add a reproducible `demo/` directory: a minimal Node project with a deliberately buggy `add()` function, a test that catches it, and an `opencode.json` wired to the local plugin source. Verified end-to-end via the OpenCode TUI.
+- Scope `npm test`/`npm run test:coverage` to `test/*.test.js` explicitly, since Node's test runner otherwise recursively discovers `demo/test/*.test.js` too, which would fail the root suite whenever the demo's deliberate bug is (correctly) unfixed.
+- **Fix project-local state persistence to actually use the active session's directory.** `GoalPlugin` previously ignored the `directory` field OpenCode passes in its `PluginInput`, so the default `.opencode/goals/state.json` path resolved against the Node process's own `process.cwd()` instead. This works fine for a one-shot CLI invocation, but silently breaks when OpenCode runs as a persistent server/daemon serving multiple projects: `process.cwd()` stays wherever the server booted, not the active session's project. Confirmed live via the OpenCode TUI — a goal set in a project directory never persisted to disk at all. `GoalPlugin` now reads `directory` from its `PluginInput` and uses it as the default `cwd` for state-path resolution (an explicit `cwd` plugin option, mainly for tests, still takes precedence).
+- Add Node 24 to the CI matrix, a weekly scheduled CI run (Mondays 08:00 UTC) to catch upstream drift, a `test:coverage` step, and npm/CI/tests/license badges to the README.
+- Add GitHub issue templates for bug reports (OpenCode version, provider/model, Node version, relevant plugin options, repro steps) and feature requests (problem solved, scope fit against the current multi-goal/audit feature set).
+- Add an Examples section to the README with copy-pasteable `/goal` commands: common workflows, success criteria/constraints/budget shorthand, and an ordered (sisyphus) sequence.
+- Add a Comparison section to the README benchmarking `/goal` support, auto-continue, per-goal overrides, no-progress/no-tool-call detection, safety limits, history, persistence, multi-goal/sisyphus sequences, evidence-gated completion, the optional completion auditor, budget wrap-up, and license against Claude Code and Codex.
+- Add `npm run verify` / `npx opencode-goal-plugin` installation verification command (`scripts/verify.mjs`). Checks Node >= 18, the plugin module shape, that all 4 hooks (`command.execute.before`, `event`, `experimental.chat.system.transform`, `experimental.compaction.autocontinue`) register, and that `/goal status`/`/goal set` work — entirely via mock clients, with zero model calls.
+- Add TypeScript declarations (`index.d.ts`) covering the full current `GoalPluginOptions` surface — budgets, persistence/ledger paths, `commandName`/`registerCommand`/`registerTools`, and the completion-audit options (`completionAudit`, `auditor`, `auditorOptions`, `auditMessages`, `auditMessenger`) — plus the plugin's hook map and default export. `package.json`'s `types` field points at it.
+- Warn when `/goal <condition>` replaces the focused goal instead of silently discarding it. The response now leads with `⚠️ Replacing active goal: "<old condition>"` and points at `/goal add <condition>` as the non-destructive alternative that backgrounds the current goal instead.
+
 ## 0.4.7 — 2026-06-29
 
 ### Bug fixes (low-severity cleanups)

package/README.md

@@ -1,20 +1,57 @@
 # opencode-goal-plugin
 
+[![npm version](https://img.shields.io/npm/v/opencode-goal-plugin)](https://www.npmjs.com/package/opencode-goal-plugin)
+[![npm downloads](https://img.shields.io/npm/dm/opencode-goal-plugin)](https://www.npmjs.com/package/opencode-goal-plugin)
+[![CI](https://github.com/willytop8/OpenCode-goal-plugin/actions/workflows/ci.yml/badge.svg)](https://github.com/willytop8/OpenCode-goal-plugin/actions/workflows/ci.yml)
+[![Tests](https://img.shields.io/badge/tests-185%20passing-brightgreen)](test/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
 An experimental session-scoped `/goal` command for [OpenCode](https://opencode.ai/).
 
 Set a goal and the plugin keeps it in context, auto-continues the session whenever the assistant goes idle, and stops when the goal is marked complete, a blocker is reported, or a safety limit is reached.
 
 Compatibility: this plugin relies on experimental OpenCode hooks. Re-test against the exact OpenCode build and provider/backend stack you plan to use for unattended work.
 
+## Comparison
+
+| Feature | Claude Code | Codex | opencode-goal-plugin |
+|---|---|---|---|
+| `/goal` command | ✅ Native | ✅ Native | ✅ Plugin |
+| Auto-continue | ✅ | ✅ | ✅ |
+| Per-goal flag overrides | ❌ | ❌ | ✅ |
+| No-progress / no-tool-call detection | ❌ | ❌ | ✅ Both |
+| Configurable safety limits | Limited | Limited | ✅ All tunable |
+| Goal history | ✅ | ❌ | ✅ `/goal history` |
+| Goal persistence | ❌ | ❌ | ✅ Survives restart, ledger-backed |
+| Multiple concurrent goals | ❌ | ❌ | ✅ `/goal add` / `/goal focus` |
+| Ordered goal sequences | ❌ | ❌ | ✅ `/goal sisyphus` |
+| Evidence-gated completion | ❌ | ❌ | ✅ `[goal:evidence]` required |
+| Independent completion audit | ✅ | ❌ | ✅ Optional child-session auditor |
+| Budget wrap-up prompts | ❌ | ❌ | ✅ 80% threshold |
+| Open source | ❌ | ❌ | ✅ MIT |
+
 ## Compatibility snapshot
 
 | Surface | Status |
 |---|---|
-| Node.js | Declared support: `>=18`; CI covers Node 18, 20, and 22 |
+| Node.js | Declared support: `>=18`; CI covers Node 18, 20, 22, and 24 |
 | Package entrypoint | `npm run smoke` verifies the package export path plus `/goal` command-hook behavior from a local install without invoking a model |
-| OpenCode host | Manually smoke-tested against OpenCode 1.15.10 using the `opencode-go` provider (`qwen3.7-plus`) on this repo's local hardening branch; re-test your own version/provider stack before relying on unattended runs |
 | Provider/backend quirks | Strict-template backends require the goal block to merge into the primary `system` message; covered by regression tests |
 
+### OpenCode version compatibility
+
+Manually tested via the OpenCode TUI (`tmux` + real provider credentials, no mocks), verified against the plugin's own persisted state rather than terminal display alone:
+
+| OpenCode Version | Provider Tested | `/goal status` | Auto-continue | Evidence-gated completion | Hook Output Display |
+|---|---|---|---|---|---|
+| 1.17.15 | opencode-go (`qwen3.7-plus`) | ✅ | ✅ | ✅ Self-corrected after one rejection (bare `[goal:complete]` with no evidence), then completed cleanly | ⚠️ Not displayed |
+| 1.17.15 | opencode-go (`glm-5.2`) | ✅ | ✅ | ✅ Clean `[goal:evidence]` + `[goal:complete]` on the first attempt | ⚠️ Not displayed |
+| 1.17.15 | deepseek (`deepseek-chat`) | ✅ | ✅ | ✅ Clean `[goal:evidence]` + `[goal:complete]` on the first attempt; also verified end-to-end via the [demo](demo/) — autonomously fixed a real bug and reported evidence-backed completion | ⚠️ Not displayed |
+
+`/goal status` and auto-continue are graded on **state correctness** (verified directly against the plugin's persisted state file: correct limits parsed, correct turn/stop accounting, correct completion detection) — not on what's rendered in the terminal, since that's tracked separately as Hook Output Display.
+
+**Note:** Hook output display depends on OpenCode version — on 1.17.15, `command.execute.before`'s `output.parts` text is not rendered in the TUI for any provider tested; the raw command argument is instead routed to the model as a normal chat turn (see [Limitations](#limitations)). State mutations always work regardless of display: goal creation, flag parsing, auto-continue, limit enforcement, and evidence-gated completion detection were all verified correct via the persisted state file in every combination above. Re-test against your own OpenCode build before relying on unattended runs, and see [`docs/providers.md`](docs/providers.md) for the full per-model marker-compliance notes.
+
 ## Install
 
 ```sh
@@ -122,6 +159,29 @@ A session can hold more than one goal. `/goal <condition>` replaces the focused
 
 The first goal is focused and the rest are queued. `/goal list` marks the session as ordered. Auto-promotion stops when the sequence is exhausted; `/goal clear` ends the sequence.
 
+## Examples
+
+Copy-pasteable goals for common workflows:
+
+```
+/goal "fix the failing tests" --max-turns 10
+/goal "refactor auth to use new API" --max-minutes 30
+/goal "audit for security issues" --max-turns 3
+/goal "migrate class components to functional" --max-minutes 60 --max-tokens 400000
+```
+
+With success criteria, constraints, and a token budget shorthand:
+
+```
+/goal "ship the release" --success "tests pass and changelog updated" --constraints "do not touch the public API" --budget 150k
+```
+
+An ordered sequence, run as a strict pipeline:
+
+```
+/goal sisyphus build the parser; write the tests; ship the release
+```
+
 ## How it works
 
 1. When you set a goal, the plugin stores it in session memory and injects it into the system prompt so the assistant keeps it in view on every turn.

package/index.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Type declarations for opencode-goal-plugin.
+ *
+ * These describe the plugin-level configuration object accepted in
+ * `opencode.json` under `plugin: [["opencode-goal-plugin", { ... }]]`,
+ * and the shape of the module's exports.
+ */
+
+/**
+ * Verdict returned by a completion auditor (built-in or custom). See
+ * {@link GoalPluginOptions.auditor} and {@link GoalPluginOptions.completionAudit}.
+ */
+export interface CompletionAuditVerdict {
+  /** `true` to archive the goal as achieved; `false` to reject the completion. */
+  approved: boolean
+  /** Human-readable reason, surfaced in the goal's status when rejected. */
+  reason?: string
+}
+
+/** Arguments passed to a custom {@link GoalPluginOptions.auditor} function. */
+export interface CompletionAuditContext {
+  /** The goal being audited (objective, budget usage, checkpoints, etc.). */
+  goal: unknown
+  /** The OpenCode session ID the goal belongs to. */
+  sessionID: string
+  /** The assistant's latest response text, containing the `[goal:evidence]`/`[goal:complete]` claim. */
+  latestText: string
+}
+
+/** Options for the built-in child-session completion auditor (`completionAudit: true`). */
+export interface CompletionAuditorOptions {
+  /**
+   * How long, in milliseconds, the built-in auditor waits for a verdict from
+   * its child OpenCode session before failing open (auto-approving).
+   * @default 120000
+   */
+  timeoutMs?: number
+}
+
+/**
+ * Configuration options for opencode-goal-plugin. All fields are optional;
+ * unset fields fall back to the plugin's built-in defaults. These act as
+ * the default limits for every goal set in a session, and most of the
+ * budget/behavior fields can be overridden per-goal via `/goal` command
+ * flags (e.g. `--max-turns`, `--success`, `--mode`).
+ */
+export interface GoalPluginOptions {
+  /**
+   * Maximum number of auto-continue turns sent toward a goal before it is
+   * stopped for exceeding limits. Overridable per-goal with `--max-turns`.
+   * @default 10
+   */
+  maxTurns?: number
+
+  /**
+   * Maximum wall-clock duration, in milliseconds, a goal may run before it
+   * is stopped for exceeding limits. Overridable per-goal with
+   * `--max-duration-ms` or `--max-minutes`.
+   * @default 900000
+   */
+  maxDurationMs?: number
+
+  /**
+   * Maximum context token budget a goal may consume before it is stopped
+   * for exceeding limits. Overridable per-goal with `--max-tokens` or the
+   * `--budget` shorthand (accepts a `k`/`m` suffix, e.g. `100k`, `1.5m`).
+   * @default 200000
+   */
+  maxTokens?: number
+
+  /**
+   * Minimum delay, in milliseconds, enforced between consecutive
+   * auto-continue prompts. Overridable per-goal with `--cooldown-ms`.
+   * @default 1500
+   */
+  minDelayMs?: number
+
+  /**
+   * How many recent session messages to scan when looking for the latest
+   * assistant turn before auto-continuing. Higher values make long,
+   * tool-heavy sessions less likely to lose the most recent assistant
+   * response.
+   * @default 50
+   */
+  maxRecentMessages?: number
+
+  /**
+   * Output token floor below which a turn is considered "low-output" for
+   * no-progress detection. Overridable per-goal with
+   * `--no-progress-threshold`.
+   * @default 50
+   */
+  noProgressTokenThreshold?: number
+
+  /**
+   * Grace window for low-output stalls: the goal is paused only after this
+   * many consecutive stalled low-output turns, rather than on the first
+   * one. Overridable per-goal with `--no-progress-turns`.
+   * @default 2
+   */
+  noProgressTurnsBeforePause?: number
+
+  /**
+   * Grace window for tool-free continuation turns (a "talk only" turn that
+   * calls no tool). Complements the no-progress check by catching
+   * self-chat loops that still produce output. Overridable per-goal with
+   * `--no-tool-turns`.
+   * @default 2
+   */
+  noToolCallTurnsBeforePause?: number
+
+  /**
+   * Fraction (between 0 and 1, exclusive) of any budget (turns, duration,
+   * or tokens) at which the plugin sends a one-time "wrap up" prompt
+   * nudging the model to finish before the hard limit is hit.
+   * @default 0.8
+   */
+  budgetWrapupRatio?: number
+
+  /**
+   * Number of remaining auto-continue turns at which a limit-approaching
+   * warning is included in status output.
+   * @default 3
+   */
+  warnTurnsRemaining?: number
+
+  /**
+   * Remaining duration, in milliseconds, at which a limit-approaching
+   * warning is included in status output.
+   * @default 60000
+   */
+  warnDurationMsRemaining?: number
+
+  /**
+   * Remaining context tokens at which a limit-approaching warning is
+   * included in status output.
+   * @default 25000
+   */
+  warnTokensRemaining?: number
+
+  /**
+   * Maximum number of consecutive prompt failures (e.g. transport errors
+   * sending the auto-continue prompt, or repeated missing-evidence /
+   * missing-blocker format violations) tolerated before the goal is
+   * stopped.
+   * @default 3
+   */
+  maxPromptFailures?: number
+
+  /**
+   * Whether to persist active/backgrounded goals and recent goal results
+   * to disk so they survive a restart. Recovered active goals are loaded
+   * in a paused state. Set to `false` for purely in-memory behavior (this
+   * also disables the lifecycle ledger).
+   * @default true
+   */
+  persistState?: boolean
+
+  /**
+   * Filesystem path where persisted goal state is written when
+   * `persistState` is enabled. Overrides both the project-local default
+   * and the `OPENCODE_GOAL_STATE_PATH` environment variable.
+   * @default "<cwd>/.opencode/goals/state.json"
+   */
+  stateFilePath?: string
+
+  /**
+   * Filesystem path for the append-only lifecycle ledger
+   * (`<event> per line`, used to reconstruct active goals if the main
+   * state file is missing or corrupted).
+   * @default "<stateFilePath>.ledger.jsonl"
+   */
+  ledgerFilePath?: string
+
+  /**
+   * How long, in milliseconds, a completed goal's summary remains
+   * available through `/goal status` after the goal leaves active memory.
+   * @default 604800000
+   */
+  resultRetentionMs?: number
+
+  /**
+   * Maximum number of completed-goal summaries retained in process memory
+   * before the oldest ones are evicted.
+   * @default 200
+   */
+  maxStoredResults?: number
+
+  /**
+   * The slash command the plugin owns. Set to e.g. `"objective"` to drive
+   * the workflow with `/objective` instead of `/goal`; a leading slash is
+   * tolerated and stripped. Remember to register the matching command
+   * name in your OpenCode `command` config.
+   * @default "goal"
+   */
+  commandName?: string
+
+  /**
+   * Whether the plugin installs its `command.execute.before` hook at all.
+   * Set to `false` if you only want the auto-continue/persistence
+   * behavior driven programmatically (e.g. via {@link registerTools})
+   * and don't want the plugin to own a slash command.
+   * @default true
+   */
+  registerCommand?: boolean
+
+  /**
+   * Whether the plugin registers the agent-facing goal tools
+   * (`get_goal`, `get_goal_history`, `set_goal`, `update_goal`,
+   * `clear_goal`). Requires the optional `@opencode-ai/plugin` peer
+   * dependency; when it is absent, tool registration is silently skipped
+   * and the command/event hooks still work.
+   * @default true
+   */
+  registerTools?: boolean
+
+  /**
+   * Enables the built-in child-session completion auditor: before a
+   * `[goal:complete]` is archived, the plugin spawns an independent
+   * OpenCode session to verify the completion against the goal and
+   * workspace. Ignored if {@link auditor} is also set (the custom
+   * auditor takes precedence). Tune the built-in auditor with
+   * {@link auditorOptions}.
+   * @default false
+   */
+  completionAudit?: boolean
+
+  /**
+   * Supply a custom completion auditor instead of the built-in
+   * child-session one. Takes precedence over `completionAudit: true`.
+   * A verdict of `{ approved: false }` pauses the goal (stop reason
+   * `"audit rejected"`) instead of archiving it. A thrown error is
+   * treated as a rejection (fail closed).
+   */
+  auditor?: (context: CompletionAuditContext) => Promise<CompletionAuditVerdict>
+
+  /**
+   * Tuning options for the built-in child-session auditor. Ignored when
+   * a custom {@link auditor} is supplied.
+   */
+  auditorOptions?: CompletionAuditorOptions
+
+  /**
+   * Whether the plugin announces completion/blocked audits (an
+   * audit-start and an audit-result message) instead of running silently.
+   * @default true
+   */
+  auditMessages?: boolean
+
+  /**
+   * Custom sink for audit announcements. Defaults to routing through
+   * OpenCode's structured log (`client.app.log`). Provide this to route
+   * audit messages elsewhere, e.g. into the live conversation.
+   */
+  auditMessenger?: (sessionID: string, text: string) => Promise<void>
+}
+
+/**
+ * OpenCode plugin hook map returned by the plugin's `server` factory.
+ * Matches OpenCode's plugin hook contract; kept loose (`unknown`
+ * input/output) since hook payload shapes are defined by OpenCode itself,
+ * not by this package.
+ */
+export interface GoalPluginHooks {
+  /** Omitted entirely when {@link GoalPluginOptions.registerCommand} is `false`. */
+  "command.execute.before"?: (input: unknown, output: unknown) => Promise<void>
+  event: (input: unknown) => Promise<void>
+  "experimental.chat.system.transform": (input: unknown, output: unknown) => Promise<void>
+  "experimental.compaction.autocontinue": (input: unknown, output: unknown) => Promise<void>
+  /**
+   * Agent-facing tool definitions, present only when
+   * {@link GoalPluginOptions.registerTools} is enabled (default) and the
+   * optional `@opencode-ai/plugin` peer dependency is installed.
+   */
+  tool?: Record<string, unknown>
+  [hook: string]: unknown
+}
+
+/**
+ * The plugin's `server` factory. OpenCode calls this with a client bound
+ * to the running session and the resolved plugin options from
+ * `opencode.json`.
+ */
+export function GoalPlugin(
+  context: { client: unknown },
+  options?: GoalPluginOptions,
+): Promise<GoalPluginHooks>
+
+/**
+ * Default export consumed by OpenCode's plugin loader:
+ * `{ "opencode-goal-plugin": { ... } }` in `opencode.json` resolves `id`
+ * and calls `server` to obtain the plugin's hooks.
+ */
+declare const goalPlugin: {
+  id: "opencode-goal-plugin"
+  server: typeof GoalPlugin
+}
+
+export default goalPlugin

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "opencode-goal-plugin",
-  "version": "0.4.7",
+  "version": "0.5.0",
   "description": "Session-scoped /goal workflow for OpenCode.",
   "type": "module",
   "main": "./src/goal-plugin.js",
+  "types": "./index.d.ts",
   "exports": {
     ".": "./src/goal-plugin.js",
     "./server": "./src/goal-plugin.js"
   },
+  "bin": {
+    "opencode-goal-plugin": "./scripts/verify.mjs"
+  },
   "files": [
     "src",
     "scripts",
     "examples",
+    "index.d.ts",
     "README.md",
     "CHANGELOG.md",
     "CONTRIBUTING.md",
@@ -20,9 +25,10 @@
     ".nvmrc"
   ],
   "scripts": {
-    "test": "node --test",
-    "test:coverage": "node --test --experimental-test-coverage",
+    "test": "node --test test/*.test.js",
+    "test:coverage": "node --test --experimental-test-coverage test/*.test.js",
     "smoke": "node scripts/smoke-command-hook.mjs",
+    "verify": "node scripts/verify.mjs",
     "check": "node -c src/goal-plugin.js && npm test",
     "pack:check": "npm pack --dry-run"
   },

package/scripts/verify.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// Installation verification for opencode-goal-plugin.
+// Checks the plugin can be loaded and wired up correctly without ever
+// invoking a model — every check below uses the same mock-client approach
+// as scripts/smoke-command-hook.mjs.
+
+import assert from "node:assert/strict"
+
+const REQUIRED_HOOKS = [
+  "command.execute.before",
+  "event",
+  "experimental.chat.system.transform",
+  "experimental.compaction.autocontinue",
+]
+
+const results = []
+
+function check(name, fn) {
+  return Promise.resolve()
+    .then(fn)
+    .then(() => {
+      results.push({ name, ok: true })
+      console.log(`  ✅ ${name}`)
+    })
+    .catch((error) => {
+      results.push({ name, ok: false, error })
+      console.log(`  ❌ ${name}`)
+      console.log(`     ${error.message}`)
+    })
+}
+
+console.log("opencode-goal-plugin installation verification\n")
+
+await check("Node.js >= 18", () => {
+  const major = Number(process.versions.node.split(".")[0])
+  assert.ok(major >= 18, `Node ${process.versions.node} is below the required >=18`)
+})
+
+let pluginModule
+let GoalPlugin
+
+await check("plugin module resolves and exposes expected shape", async () => {
+  pluginModule = await import("opencode-goal-plugin")
+  GoalPlugin = pluginModule.GoalPlugin
+  assert.equal(pluginModule.default.id, "opencode-goal-plugin")
+  assert.equal(typeof pluginModule.default.server, "function")
+  assert.equal(typeof GoalPlugin, "function")
+})
+
+const sessionID = `verify-${process.pid}`
+const promptCalls = []
+const logCalls = []
+
+const client = {
+  app: {
+    log: async (input) => {
+      logCalls.push(input)
+    },
+  },
+  session: {
+    messages: async () => ({ data: [] }),
+    promptAsync: async (input) => {
+      promptCalls.push(input)
+      return {}
+    },
+  },
+}
+
+let hooks
+
+await check("plugin initializes and registers all 4 required hooks", async () => {
+  // registerTools defaults to true but silently no-ops without the optional
+  // @opencode-ai/plugin peer dependency, so it is not asserted here — the
+  // 4 hooks below are always present regardless of that peer dependency.
+  hooks = await GoalPlugin({ client }, { minDelayMs: 1, persistState: false })
+  for (const hookName of REQUIRED_HOOKS) {
+    assert.equal(
+      typeof hooks[hookName],
+      "function",
+      `missing or non-function hook: ${hookName}`,
+    )
+  }
+})
+
+async function runGoalCommand(args) {
+  const output = { parts: [] }
+  await hooks["command.execute.before"](
+    { command: "goal", sessionID, arguments: args },
+    output,
+  )
+  assert.equal(output.parts.length, 1)
+  assert.equal(output.parts[0].type, "text")
+  return output.parts[0].text
+}
+
+await check("/goal status works", async () => {
+  const text = await runGoalCommand("status")
+  assert.match(text, /No active goal/)
+})
+
+await check("/goal set works", async () => {
+  const text = await runGoalCommand("verify the installation --max-turns 1")
+  assert.match(text, /New active goal: verify the installation/)
+  const statusText = await runGoalCommand("status")
+  assert.match(statusText, /Active goal: verify the installation/)
+})
+
+await check("no model calls were made during verification", () => {
+  assert.equal(promptCalls.length, 0, "expected zero promptAsync calls")
+})
+
+// Clean up the goal created above so this script has no side effects.
+await runGoalCommand("clear")
+
+console.log()
+
+const failed = results.filter((r) => !r.ok)
+if (failed.length > 0) {
+  console.log(`${failed.length}/${results.length} checks failed.`)
+  process.exit(1)
+}
+
+console.log(`All ${results.length} checks passed. opencode-goal-plugin is installed correctly.`)

package/src/goal-plugin.js

@@ -2109,11 +2109,19 @@ function createChildSessionAuditor(client, { agent = "build", timeoutMs = 120_00
   }
 }
 
-export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
+export const GoalPlugin = async ({ client, directory } = {}, pluginOptions = {}) => {
   const defaultGoalOptions = normalizeOptions(pluginOptions)
+  // OpenCode's PluginInput carries the active session's project directory
+  // separately from the Node process's own process.cwd(), which — when
+  // OpenCode runs as a persistent server/daemon serving multiple
+  // projects/sessions — does NOT track the session's directory. Falling back
+  // to process.cwd() here would silently resolve the project-local state
+  // path against wherever the server happened to boot, not the project the
+  // user is actually working in. An explicit `cwd` plugin option (mainly for
+  // tests) still takes precedence.
   const persistenceOptions = normalizePersistenceOptions(pluginOptions, {
     env: pluginOptions.env,
-    cwd: pluginOptions.cwd,
+    cwd: pluginOptions.cwd || directory,
   })
   const { commandName, registerCommand } = normalizeCommandOptions(pluginOptions)
   // Serialize all persist() calls through a promise chain so concurrent callers
@@ -2531,6 +2539,7 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
       // goal and add another. Clear any ordered-sequence flag so the new
       // standalone goal does not trigger sisyphus auto-promotion of old sequence
       // goals that may still be in the registry (matches the agent setGoal path).
+      const replacedGoal = goalStates.get(sessionID)
       sessionOrdered.delete(sessionID)
       cleanupGoal(sessionID)
       lastGoalResults.delete(sessionID)
@@ -2540,6 +2549,13 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
       output.parts = [
         makeTextPart(
           [
+            ...(replacedGoal
+              ? [
+                  `⚠️ Replacing active goal: "${replacedGoal.condition}"`,
+                  `Use \`/${commandName} add <condition>\` instead to keep it running in the background.`,
+                  "",
+                ]
+              : []),
             `New active goal: ${goal.condition}`,
             goal.successCriteria ? `Success criteria: ${goal.successCriteria}` : null,
             goal.constraints ? `Constraints / non-goals: ${goal.constraints}` : null,