opencode-goal-plugin 0.1.14 → 0.2.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## 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.

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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-goal-plugin",
-  "version": "0.1.14",
+  "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/src/goal-plugin.js

@@ -783,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) => {
@@ -1031,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))]
@@ -1362,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
+    },
   }
 }
 
@@ -1373,6 +1455,7 @@ export default {
 export const testInternals = {
   activeGoal,
   buildLimitWarning,
+  buildCompactionContext,
   buildContinueMessage,
   buildGoalBlock,
   budgetWrapupNeeded,