opencode-goal-plugin 0.1.13 → 0.2.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## 0.2.0 — 2026-06-14
+
+- **Add `/goal edit <new objective>`.** Revise the active goal's objective in place while preserving its turn/token/time budget and lifecycle history. Any pause/blocked state is cleared and `noProgressTurns` resets so the revised goal can continue; a goal already at a hard limit re-pauses on the next idle (use `/goal resume` for a fresh budget window). Ported from prevalentWare/opencode-goal-plugin's `update_goal_objective` tool, adapted to the marker-based command model.
+- **Preserve the goal across session compaction.** A new `experimental.session.compacting` hook injects the goal objective, status, budget usage, elapsed time, and latest checkpoint into the compaction context so a compaction no longer drops the goal thread mid-run. Ported from prevalentWare/opencode-goal-plugin's `compactionContext` injection.
+- **Disable generic post-compaction auto-continue while a goal is active.** A new `experimental.compaction.autocontinue` hook sets `enabled = false` whenever an active (non-stopped) goal is present, so OpenCode's native post-compaction continuation does not race the plugin's own idle-triggered continuation. Paused/stopped goals leave the native behavior untouched. Ported from prevalentWare/opencode-goal-plugin.
+
+## 0.1.14 — 2026-06-12
+
+- **Count cached context tokens in the budget.** `totalTokensForMessage` now includes `tokens.cache.read` / `cache.write` alongside `input + output + reasoning`. On providers with prompt caching (e.g. Anthropic) most of the conversation context arrives as cache reads with a tiny `input`, so the prior estimate undercounted the context window and the token budget / wrap-up could effectively never trigger.
+- **Honor `/goal pause` issued mid-handler.** The post-await re-checks in the idle handler now use a new `activeGoal` helper that treats a `stopped` goal as inactive, so a pause sent while messages are being fetched or during the cooldown no longer lets one more auto-continue slip through. Adds a regression test.
+- **Harden `escapeGoalText` against forged opening tags.** In addition to escaping closing tags, the plugin now neutralizes opening forms of its own structural tags (`<budget_wrapup>`, `<next_step>`, `<completion_audit>`, `<goal_objective>`, `<goal_continuation>`, `<progress_budget>`), closing a prompt-injection path where goal text could mimic elevated-instruction blocks. Non-structural tag-like text (e.g. `<div>`) is left untouched.
+- **Stop the smoke test from touching real state.** `scripts/smoke-command-hook.mjs` now runs with `persistState: false`, so `npm run smoke` can no longer read or overwrite `~/.opencode-goal-plugin/state.json`.
+- Document the `warnTurnsRemaining` / `warnDurationMsRemaining` / `warnTokensRemaining` options in the README.
+
 ## 0.1.13 — 2026-06-11
 
 > Fixes a significant token-tracking bug where the reported token count could be 5–10× higher than what OpenCode displays, making budgets appear exhausted far sooner than expected.

package/README.md

@@ -70,6 +70,14 @@ Resume a paused or stopped goal:
 /goal resume
 ```
 
+Edit the active goal's objective without losing its budget or history:
+
+```
+/goal edit fix the failing tests and also update the docs
+```
+
+`/goal edit <new objective>` revises the goal in place: the turn, token, and time budget plus the lifecycle history are preserved, and any pause/blocked state is cleared so the revised goal can continue. A goal that already hit a hard limit will re-pause on the next idle — run `/goal resume` for a fresh budget window.
+
 Pause without clearing the active goal:
 
 ```
@@ -89,6 +97,7 @@ Clear the active goal:
 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.
 2. Each time the session goes idle, the plugin sends a continuation prompt containing the goal, the remaining budget, and a completion audit asking the assistant to verify the current state before declaring done.
 3. The plugin stops auto-continuing when the assistant ends a response with `[goal:complete]` or `[goal:blocked]`, or when a safety limit is reached.
+4. If OpenCode compacts the session, the plugin injects the goal objective, budget usage, and latest checkpoint into the compaction context so the goal survives the compaction and the assistant keeps the thread. While a goal is active, the plugin also disables OpenCode's generic post-compaction auto-continue so it does not race the plugin's own continuation.
 
 ## Completion markers
 
@@ -187,6 +196,7 @@ Additional plugin-level options:
 
 - `maxRecentMessages` — 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.
 - `noProgressTurnsBeforePause` — grace window for low-output stalls. The plugin pauses only after this many consecutive stalled low-output turns rather than on the first one.
+- `warnTurnsRemaining` / `warnDurationMsRemaining` / `warnTokensRemaining` — thresholds at which the auto-continue prompt appends a "limits are near" warning (default `3` turns, `60000` ms, `25000` context tokens). Lower them to warn closer to the limit, or raise them to warn earlier.
 - `persistState` — whether to persist active goals and recent goal results to disk.
 - `stateFilePath` — where the persisted state JSON is written. Useful if you want per-project or ephemeral storage.
 - `resultRetentionMs` — how long a completed goal summary remains available through `/goal status` after the goal leaves active memory.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-goal-plugin",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "description": "Session-scoped /goal workflow for OpenCode.",
   "type": "module",
   "main": "./src/goal-plugin.js",
@@ -47,4 +47,4 @@
   "author": {
     "name": "willytop8"
   }
-}
+}

package/scripts/smoke-command-hook.mjs

@@ -23,7 +23,9 @@ const client = {
 assert.equal(pluginModule.id, "opencode-goal-plugin")
 assert.equal(pluginModule.server, GoalPlugin)
 
-const hooks = await GoalPlugin({ client }, { minDelayMs: 1 })
+// 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")

package/src/goal-plugin.js

@@ -285,6 +285,16 @@ function currentGoal(sessionID, goalID) {
   return goal
 }
 
+// Like currentGoal, but also returns null if the goal was stopped (paused,
+// cleared-and-replaced, blocked) while an async step was in flight. Used at the
+// post-await re-checks so a `/goal pause` issued during messages-fetch or the
+// cooldown sleep actually prevents the next auto-continue from firing.
+function activeGoal(sessionID, goalID) {
+  const goal = currentGoal(sessionID, goalID)
+  if (!goal || goal.stopped) return null
+  return goal
+}
+
 function toPositiveInteger(value, fallback) {
   const parsed = Number(value)
   return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback
@@ -685,10 +695,28 @@ function buildLimitWarning(goal) {
   return warnings.length ? ` Limits are near: ${warnings.join(", ")}.` : ""
 }
 
+// Tag names the plugin uses to frame its own instructions. Goal text must not
+// be able to forge either an opening or a closing form of any of these.
+const STRUCTURAL_TAGS = [
+  "goal_continuation",
+  "goal_objective",
+  "progress_budget",
+  "budget_wrapup",
+  "next_step",
+  "completion_audit",
+]
+const STRUCTURAL_OPEN_TAG_RE = new RegExp(`<(${STRUCTURAL_TAGS.join("|")})\\b`, "gi")
+
 function escapeGoalText(text) {
   // Escape every XML closing tag so user-supplied goal text cannot break the
-  // structural framing used in buildGoalBlock and buildContinueMessage.
-  return String(text).replaceAll("</", "<\\/")
+  // structural framing used in buildGoalBlock and buildContinueMessage...
+  let escaped = String(text).replaceAll("</", "<\\/")
+  // ...and neutralize opening forms of the plugin's own structural tags so goal
+  // text cannot inject a forged block (e.g. <budget_wrapup>, <next_step>) that
+  // mimics elevated instructions. Closing forms are already broken above, so
+  // this regex only matches genuine `<tag` openings.
+  escaped = escaped.replace(STRUCTURAL_OPEN_TAG_RE, "<\\$1")
+  return escaped
 }
 
 function buildGoalBlock(goal) {
@@ -755,6 +783,24 @@ function buildContinueMessage(goal, { budgetWrapup = false } = {}) {
   return lines.filter(Boolean).join("\n")
 }
 
+function buildCompactionContext(goal) {
+  // Preserve the active goal across an OpenCode session compaction. Without
+  // this, a compaction can drop the goal objective and budget state from the
+  // working context, so the assistant loses the thread mid-run even though the
+  // plugin still re-injects via system.transform afterward.
+  const elapsedSeconds = Math.round((Date.now() - goal.startedAt) / 1000)
+  return [
+    "An OpenCode goal is active for this session. Preserve it across compaction.",
+    buildGoalBlock(goal),
+    `Goal status: ${goal.stopped ? goal.stopReason || "stopped" : "active"}.`,
+    `Auto-continues used: ${goal.turnCount}/${goal.options.maxTurns}. Context tokens: ${goal.totalTokens}/${goal.options.maxTokens}. Elapsed: ${elapsedSeconds}s.`,
+    goal.lastCheckpoint ? `Latest checkpoint: ${goal.lastCheckpoint.summary}` : null,
+    "After compaction, continue from the next concrete unfinished step while the goal is active. Verify the result against the goal objective before ending; output [goal:complete] only when fully satisfied, or [goal:blocked] only if user input is required.",
+  ]
+    .filter(Boolean)
+    .join("\n")
+}
+
 function extractBlockedReason(text) {
   const lines = text.trimEnd().split("\n")
   const markerIndex = lines.findIndex((line) => {
@@ -798,12 +844,23 @@ function messageTokens(message) {
       : {}
 }
 
+function cacheTokensForMessage(tokens) {
+  // OpenCode reports cached context separately as `cache: { read, write }`.
+  // On cache-heavy providers (e.g. Anthropic prompt caching) most of the
+  // conversation context arrives as `cache.read` with a small `input`, so the
+  // cache fields must be counted toward the context-window estimate or the
+  // token budget is undercounted by an order of magnitude.
+  const cache = isPlainObject(tokens.cache) ? tokens.cache : {}
+  return toNonNegativeInteger(cache.read) + toNonNegativeInteger(cache.write)
+}
+
 function totalTokensForMessage(message) {
   const tokens = messageTokens(message)
   return (
     toNonNegativeInteger(tokens.input) +
     toNonNegativeInteger(tokens.output) +
-    toNonNegativeInteger(tokens.reasoning)
+    toNonNegativeInteger(tokens.reasoning) +
+    cacheTokensForMessage(tokens)
   )
 }
 
@@ -992,6 +1049,47 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         return
       }
 
+      if (args === "edit" || args.toLowerCase().startsWith("edit ")) {
+        const goal = goalStates.get(sessionID)
+        if (!goal) {
+          output.parts = [
+            makeTextPart("No active goal to edit. Set one with `/goal <condition>`."),
+          ]
+          return
+        }
+        const newObjective = stripWrappingQuotes(args.slice("edit".length).trim())
+        if (!newObjective) {
+          output.parts = [
+            makeTextPart("No new objective provided. Use `/goal edit <new objective>`."),
+          ]
+          return
+        }
+
+        goal.condition = newObjective
+        // Editing the objective revises the goal in place: keep the turn,
+        // token, and time budget plus history, but clear soft-stop state so the
+        // revised goal can continue. A goal that hit a hard limit will re-pause
+        // on the next idle (use /goal resume for a fresh budget window).
+        goal.stopped = false
+        goal.stopReason = ""
+        goal.blockedReason = ""
+        goal.budgetWrapupSent = false
+        goal.noProgressTurns = 0
+        goal.lastStatus = "Goal objective updated."
+        pushHistory(goal, "edited", `Objective updated to: ${summarizeText(newObjective, 400)}`)
+        await persist()
+        output.parts = [
+          makeTextPart(
+            [
+              `Goal objective updated: ${goal.condition}`,
+              "",
+              "Budgets and history are preserved. Run `/goal resume` for a fresh budget window, or `/goal status` to review.",
+            ].join("\n"),
+          ),
+        ]
+        return
+      }
+
       const parsed = parseGoalArguments(args, defaultGoalOptions)
       if (parsed.errors.length > 0) {
         output.parts = [makeTextPart(formatArgumentErrors(parsed.errors))]
@@ -1112,7 +1210,7 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
           path: { id: sessionID },
           query: { limit: goal.options.maxRecentMessages },
         })
-        const activeGoalAfterMessages = currentGoal(sessionID, goalID)
+        const activeGoalAfterMessages = activeGoal(sessionID, goalID)
         if (!activeGoalAfterMessages) return
 
         const latestAssistant = findLatestAssistantMessage(messages.data)
@@ -1217,7 +1315,7 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
           await sleep(activeGoalAfterMessages.options.minDelayMs - elapsedSinceLastContinue)
         }
 
-        const activeGoalBeforePrompt = currentGoal(sessionID, goalID)
+        const activeGoalBeforePrompt = activeGoal(sessionID, goalID)
         if (!activeGoalBeforePrompt) return
 
         const budgetWrapup = budgetWrapupNeeded(activeGoalBeforePrompt)
@@ -1323,6 +1421,29 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
       }
       output.system = systemBlocks
     },
+
+    "experimental.session.compacting": async (input, output) => {
+      if (!input?.sessionID || !output) return
+      const goal = goalStates.get(input.sessionID)
+      if (!goal) return
+      const context = buildCompactionContext(goal)
+      if (Array.isArray(output.context)) {
+        output.context.push(context)
+      } else {
+        output.context = [context]
+      }
+    },
+
+    "experimental.compaction.autocontinue": async (input, output) => {
+      // When a goal is active the plugin drives its own idle-triggered
+      // continuation, so disable OpenCode's generic post-compaction
+      // auto-continue to avoid two continuations racing after a compaction.
+      // Paused/stopped goals leave the native behavior untouched.
+      if (!input?.sessionID || !output) return
+      const goal = goalStates.get(input.sessionID)
+      if (!goal || goal.stopped) return
+      output.enabled = false
+    },
   }
 }
 
@@ -1332,13 +1453,16 @@ export default {
 }
 
 export const testInternals = {
+  activeGoal,
   buildLimitWarning,
+  buildCompactionContext,
   buildContinueMessage,
   buildGoalBlock,
   budgetWrapupNeeded,
   cleanupGoal,
   currentGoal,
   escapeGoalText,
+  totalTokensForMessage,
   extractBlockedReason,
   findLatestAssistantMessage,
   formatArgumentErrors,