opencode-goal-plugin 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 0.4.1 — 2026-06-29
+
+### Bug fixes
+
+- **Fix provider prefix cache invalidation caused by volatile limit warnings in system prompt (#14).** `experimental.chat.system.transform` was calling `buildLimitWarning`, which appends a string containing `Date.now()`-derived `remainingMs` and a per-turn `remainingTokens` counter. Once any warning threshold was crossed (default: 25 000 tokens remaining, ≤ 3 turns left, ≤ 60 s left), the system prompt changed on every provider request — including tool-call sub-requests mid-turn — invalidating the prefix cache from byte 0 each time. On a 200 k-context thinking model consuming 20–30 k reasoning tokens/turn, this triggered O(turns × tool_calls × context_size) cache misses instead of O(1), causing the ~$12/8 min cost spike reported in issue #13. Fix: `buildLimitWarning` is removed from `system.transform`; the system prompt is now byte-stable for the full lifetime of a goal. Limit warnings continue to reach the model on every continuation turn via `buildContinueMessage`, which already included them.
+- **Cap consecutive format-validation re-prompts (#15).** A model that repeatedly omitted `[goal:evidence]` on a `[goal:complete]` marker, or omitted a concrete blocker on `[goal:blocked]`, was re-prompted indefinitely: the existing `promptFailures` counter only incremented on network/protocol errors. Added a separate `formatFailures` counter that increments on each `completionUnverified` or `blockerUnstated` re-prompt and resets on a valid response. After `maxPromptFailures` consecutive format failures the goal pauses with stop reason `format validation failures` and a descriptive status message; `/goal resume` retries.
+- **Exclude tool-calling turns from the noProgress stall detector (#16).** `lowOutputLooksStalled` could fire on a reasoning-heavy model doing a pure tool call (small prose output, reasoning tokens only): `latestText` is empty and `latestOutputTokens` is below the 50-token threshold, matching the stall condition. Added `!latestHasToolCall` to `lowOutputLooksStalled` so a turn that invoked any tool is never counted as stalled regardless of prose output. `latestHasToolCall` is now hoisted above both the `noProgress` and `noToolCall` blocks so both gates share the same computation.
+
 ## 0.4.0 — 2026-06-21
 
 - **Expose agent-facing goal tools (`get_goal`, `get_goal_history`, `set_goal`, `update_goal`, `clear_goal`)** when the host provides `@opencode-ai/plugin` (a new *optional* peer dependency, loaded via a cached dynamic import so the zero-runtime-dependency posture is preserved). `set_goal` is constrained by its description to explicit user requests (so the agent does not set goals on its own); it accepts optional `maxTurns` / `maxTokens` / `maxDurationMs` overrides plus `successCriteria` / `constraints` / `mode`. `update_goal` supports objective edits and `complete` / `blocked` / `paused` / `resumed` transitions (with `evidence` / `blocker`). Tools create, replace, and clear goals through the **multi-goal registry** (the same `buildGoalState` → `registerSessionGoal` → `focusGoal` path the `/goal` command uses), so tool-created goals persist, appear in `/goal list`, and are driven by the idle handler; `complete` archives with evidence and auto-promotes the next goal in an ordered (sisyphus) sequence. Registration is skipped gracefully when the package is absent or with `registerTools: false`. New `buildAgentToolHandlers` / `buildAgentTools` / `agentToolSessionID` helpers. Implements megalist items 7.1 and 7.2. _(This is the work the 0.3.0 changelog mistakenly listed as already shipped; it is now actually implemented and adapted to the current multi-goal architecture.)_

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-goal-plugin",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Session-scoped /goal workflow for OpenCode.",
   "type": "module",
   "main": "./src/goal-plugin.js",

package/src/goal-plugin.js

@@ -520,6 +520,7 @@ function resetGoalBudget(goal) {
   goal.budgetWrapupSent = false
   goal.messageIDs = new Set()
   goal.promptFailures = 0
+  goal.formatFailures = 0
   goal.lastAssistantMessageID = ""
   goal.history = [...(goal.history || [])].slice(-MAX_HISTORY_ENTRIES)
 }
@@ -1583,6 +1584,7 @@ function buildGoalState(sessionID, condition, options, meta = {}, lastStatus = "
     stopped: false,
     stopReason: "",
     promptFailures: 0,
+    formatFailures: 0,
     messageIDs: new Set(),
     history: [],
     checkpoints: [],
@@ -2600,12 +2602,23 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
           return
         }
 
+        // Hoist tool-call check so both the noProgress and noToolCall gates can
+        // use it. A tool call is evidence of real work even when prose output
+        // is tiny (e.g. a thinking model that calls a tool with < 50 output
+        // tokens), so it resets noProgressTurns the same way the noToolCall
+        // gate already resets noToolCallTurns.
+        const latestHasToolCall = messageHasToolCall(latestAssistant)
+
         const lowOutputTurn =
           activeGoalAfterMessages.turnCount > 0 &&
           latestOutputTokens !== null &&
           latestOutputTokens < activeGoalAfterMessages.options.noProgressTokenThreshold
+        // A turn that used a tool is never stalled even with low output tokens:
+        // reasoning-heavy models often produce small prose output while doing
+        // real work via tool calls. Excluding tool-call turns prevents false
+        // noProgress pauses on thinking models.
         const lowOutputLooksStalled =
-          lowOutputTurn && (assistantRepeated || !latestText || !assistantChanged)
+          lowOutputTurn && !latestHasToolCall && (assistantRepeated || !latestText || !assistantChanged)
         if (lowOutputLooksStalled) {
           activeGoalAfterMessages.noProgressTurns += 1
           if (
@@ -2640,7 +2653,6 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         // configured grace window. Complements the low-output check above:
         // a turn can be high-output yet still make no real progress because it
         // never touched a tool.
-        const latestHasToolCall = messageHasToolCall(latestAssistant)
         const noToolCallContinuation =
           activeGoalAfterMessages.turnCount > 0 && Boolean(latestAssistant) && !latestHasToolCall
         if (noToolCallContinuation) {
@@ -2694,14 +2706,35 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         activeGoalBeforePrompt.lastContinueAt = Date.now()
         if (!budgetWrapup) {
           if (completionUnverified) {
+            activeGoalBeforePrompt.formatFailures += 1
             activeGoalBeforePrompt.lastStatus = `Rejected an unverified [goal:complete] (no [goal:evidence]); re-prompting for evidence on turn ${activeGoalBeforePrompt.turnCount}.`
           } else if (blockerUnstated) {
+            activeGoalBeforePrompt.formatFailures += 1
             activeGoalBeforePrompt.lastStatus = `Rejected a [goal:blocked] with no concrete blocker; re-prompting on turn ${activeGoalBeforePrompt.turnCount}.`
           } else {
+            activeGoalBeforePrompt.formatFailures = 0
             activeGoalBeforePrompt.lastStatus = latestText
               ? `Continuing after assistant turn ${activeGoalBeforePrompt.turnCount}.`
               : `Continuing after idle event ${activeGoalBeforePrompt.turnCount}.`
           }
+
+          // Pause after too many consecutive format-validation failures. Unlike
+          // promptFailures (which counts network/protocol errors), this counts turns
+          // where the model signalled completion or a blocker but omitted the required
+          // evidence or concrete-blocker line. The same maxPromptFailures cap applies;
+          // resume resets the counter via resetGoalBudget.
+          if (activeGoalBeforePrompt.formatFailures >= activeGoalBeforePrompt.options.maxPromptFailures) {
+            activeGoalBeforePrompt.stopped = true
+            activeGoalBeforePrompt.stopReason = "format validation failures"
+            activeGoalBeforePrompt.lastStatus = `Paused after ${activeGoalBeforePrompt.formatFailures} consecutive format-validation failure(s) (missing [goal:evidence] or concrete blocker). Run /${commandName} resume to retry.`
+            pushHistory(
+              activeGoalBeforePrompt,
+              "paused",
+              `Paused after ${activeGoalBeforePrompt.formatFailures} consecutive format-validation failure(s).`,
+            )
+            await persist()
+            return
+          }
         }
 
         const response = await client.session.promptAsync({
@@ -2776,13 +2809,21 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
       const systemBlocks = Array.isArray(output.system) ? [...output.system] : []
       if (systemBlocks.some(systemBlockContainsGoal)) return
 
+      // Only static content here — volatile fields (limit warnings, turn counters,
+      // token counts, wall-clock values) must not appear in the system prompt.
+      // system.transform fires on every provider request including tool-call
+      // sub-requests; any per-turn drift in the system prompt invalidates the
+      // provider-side prefix cache from byte 0, turning O(1) cache hits into
+      // O(N*turns) full-context misses. Limit warnings are already delivered
+      // on every continuation turn via buildContinueMessage (buildLimitWarning
+      // and <progress_budget>), which is sufficient — the model doesn't need
+      // them in the system prompt mid-turn.
       const goalBlock = [
         buildGoalBlock(goal),
         "Keep working until the goal is fully satisfied.",
         "When fully satisfied, put a `[goal:evidence]` line summarizing what you verified immediately before `[goal:complete]`. A `[goal:complete]` without evidence is rejected.",
         "If user input is required, explain the concrete blocker in the line immediately before `[goal:blocked]`. A `[goal:blocked]` without a concrete blocker is rejected.",
-        buildLimitWarning(goal),
-      ].filter(Boolean).join("\n")
+      ].join("\n")
 
       if (systemBlocks.length === 0) {
         output.system = [goalBlock]