opencode-goal-mode 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+## v0.4.4
+
+### Sidebar todos and gates stay correct and up to date
+
+- **Acceptance-criterion todos now check off.** They were matched against the
+  *display-clipped* criterion text, so any criterion longer than the sidebar width
+  never showed as done even with exact matching evidence. Matching now uses the full
+  criterion text (clipping is display-only). Verified live in the OpenCode TUI.
+- **The Goal section refreshes promptly.** It now updates on OpenCode activity
+  events (`message.part.updated`, …) — the same mechanism the reference TUI plugin
+  uses — in addition to the polling fallback, and forces a repaint on each refresh,
+  so gates and todos track the goal's real state as reviewers pass and evidence is
+  recorded instead of going stale.
+
+### Docs
+
+- The README preview is now a real TUI screenshot (`docs/sidebar-preview.png`).
+
+## v0.4.3
+
+### Build mode no longer behaves like a goal
+
+- Switching a session from the `goal` agent to Build (or any non-goal agent) now
+  **deactivates** it: `state.active` tracks the current agent (`isPrimaryAgent`),
+  instead of latching `true` forever. The sidebar also gates on the session's live
+  current agent (its latest message), so when you switch to Build the Goal section
+  disappears and OpenCode's native todos return — and a Build session can no longer
+  invoke the `goal-*` subagents or have its completion claims policed.
+- Goal **worker** subagents (e.g. `goal-implementer`) are no longer activated by
+  their own edits, so Goal completion enforcement is never injected into a worker's
+  prompt. Bookkeeping runs only for active goal sessions and review subagents.
+
+### `npm install -g` now updates everything, automatically
+
+- A global-install `postinstall` runs the installer for you — it copies the
+  components into `~/.config/opencode`, registers the Goal sidebar, and clears
+  OpenCode's stale plugin cache — so `npm install -g opencode-goal-mode` **alone**
+  fully installs or upgrades Goal Mode and the new version actually loads on the
+  next restart. It runs only for global installs, never for repo/dev/dependency
+  installs, and never fails the npm install (it prints a hint if it can't finish).
+
+### Fixes
+
+- **CI green again:** the headless visual test no longer requires
+  `@opentui/solid/jsx-dev-runtime` (the CI visual job was failing).
+- Hardened `gatePassedFresh` against partial/legacy snapshots so the TUI never
+  silently fails to render an active goal.
+- Compaction context is only added for active goal sessions (no stray Goal state in
+  a Build session's compaction summary).
+- Docs: corrected the sidebar description (separate gate/status lines; the label is
+  `GOAL`, not "Goal todos").
+
 ## v0.4.2
 
 ### The sidebar Goal section now actually renders in the live TUI

package/README.md

@@ -60,7 +60,7 @@ config, including `.opencode/tui.json`. See [Installer options](#installer-optio
 [![license](https://img.shields.io/npm/l/opencode-goal-mode?color=2da44e)](LICENSE)
 [![node](https://img.shields.io/node/v/opencode-goal-mode?color=2da44e)](package.json)
 
-![OpenCode Goal Mode sidebar todo section](docs/sidebar-demo.svg)
+![OpenCode Goal Mode sidebar preview](docs/sidebar-preview.png)
 
 <sub>↑ In goal mode, the Goal plugin takes over the sidebar todo section with a
 structured, evidence-aware Goal todo list — a bold `GOAL` label, then the goal
@@ -244,9 +244,11 @@ enforcement and writes its state to disk, and an experimental TUI plugin
   slot, stacked on separate lines, each in its own colour so it never reads as one
   run of text:
   - a bold **`GOAL`** label (yellow while running, red when done);
-  - the short goal title;
-  - a `passing/total gates · status` line (lifecycle only — no "changes pending"
-    noise; pending work shows as a todo row instead);
+  - the short goal title (white);
+  - the gate count `passing/total gates` (cyan), on its own line;
+  - the lifecycle status (orange) on its own line — `in progress`, or
+    `completed · N review cycles`. No "changes pending" noise; pending work shows
+    as a todo row instead;
   - structured todo rows derived from real guard state: one per acceptance
     criterion (✓ when fresh evidence covers it), a re-verify row when the tree
     changed, and one row per still-missing review gate by friendly name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-goal-mode",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Strict Goal Mode agents, commands, and guard plugin for OpenCode.",
   "type": "module",
   "main": "plugins/goal-sidebar.tsx",
@@ -25,6 +25,7 @@
     "plugins/",
     "research/",
     "scripts/install.mjs",
+    "scripts/postinstall.mjs",
     "ARCHITECTURE.md",
     "CHANGELOG.md",
     "LICENSE",
@@ -51,7 +52,8 @@
     "ci": "npm run validate && npm run audit",
     "prepublishOnly": "npm run ci && npm run publish:check",
     "install:local": "node scripts/install.mjs",
-    "install:global": "node scripts/install.mjs --global"
+    "install:global": "node scripts/install.mjs --global",
+    "postinstall": "node scripts/postinstall.mjs"
   },
   "keywords": [
     "opencode",

package/plugins/goal-guard/gates.js

@@ -71,7 +71,7 @@ export function requiredGates(state, config) {
 
 /** A gate is satisfied when its latest verdict is PASS and newer than the last edit. */
 export function gatePassedFresh(state, agent) {
-  const v = state.latestVerdict[agent];
+  const v = state.latestVerdict?.[agent];
   if (!v || v.verdict !== "PASS") return false;
   return v.seq > (state.lastEditSeq || 0);
 }

package/plugins/goal-guard/guard.js

@@ -93,7 +93,10 @@ export function createGuard(input = {}, options = {}, overrides = {}) {
       try {
         if (!inp?.sessionID) return;
         const state = store.stateFor(inp.sessionID);
-        if (isPrimaryAgent(inp.agent)) state.active = true;
+        // `active` reflects whether this session is CURRENTLY a Goal session. Switching
+        // the session's agent to Build (or anything non-goal) must deactivate it, or
+        // the sidebar/guard would keep treating an explicit Build session as a goal.
+        if (inp.agent) state.active = isPrimaryAgent(inp.agent);
         const text = partsText(out?.parts);
         if (text && state.active) {
           // Accumulate goal text (bounded) so contextual gates can be derived.
@@ -115,7 +118,10 @@ export function createGuard(input = {}, options = {}, overrides = {}) {
         if (!normalized) return;
         const state = store.stateFor(normalized);
         state.currentAgent = inp.agent;
-        if (isPrimaryAgent(inp.agent)) state.active = true;
+        // Track the current mode: a session is active (a goal) only while its agent
+        // is the goal primary. Switching to Build/Plan/etc. deactivates it so the
+        // Goal sidebar and enforcement stop treating it as a goal.
+        if (inp.agent) state.active = isPrimaryAgent(inp.agent);
       } catch {
         /* ignore */
       }
@@ -178,13 +184,14 @@ export function createGuard(input = {}, options = {}, overrides = {}) {
     async "tool.execute.after"(inp, out) {
       try {
         const state = store.stateFor(inp?.sessionID);
-        // Goal bookkeeping is GOAL-ONLY. A Build/Plan/custom session must never have
-        // its edits, mutations, verification, or verdicts recorded as goal state —
-        // otherwise the guard would treat a non-Goal message/task as if it were a
-        // goal. Only an active Goal session (or a goal-namespace subagent's own
-        // session, for verdict capture) is tracked. Destructive-command blocking is
-        // handled in tool.execute.before and still applies in every mode.
-        if (!state.active && !isGoalAgent(state.currentAgent)) return;
+        // Goal bookkeeping runs only for an active Goal session, or for a REVIEW
+        // subagent's own child session (so the agent-path can capture its verdict).
+        // It must NOT run for a Build/Plan/custom session, nor for a non-review goal
+        // WORKER child session (e.g. goal-implementer/goal-explorer) — otherwise that
+        // worker's edits would mark it dirty and activate it, leaking goal completion
+        // enforcement into a worker's prompt. Destructive-command blocking lives in
+        // tool.execute.before and still applies in every mode.
+        if (!state.active && !isReviewAgent(state.currentAgent)) return;
         const tool = inp?.tool;
         const isReviewing = isReviewAgent(state.currentAgent);
 
@@ -278,6 +285,7 @@ export function createGuard(input = {}, options = {}, overrides = {}) {
       try {
         if (!inp?.sessionID || !out || !Array.isArray(out.context)) return;
         const state = store.stateFor(inp.sessionID);
+        if (!state.active) return; // only preserve goal state for active Goal sessions
         out.context.push(
           `Goal Guard state: ${summarizeState(state, config)}. Preserve Goal Contract, Verification Ledger, ` +
             `Review Ledger, Reviewer Memory, review cycle count, dirty state, and open findings across compaction.`,

package/plugins/goal-guard/summary.js

@@ -54,9 +54,12 @@ function sidebarTodos(state, required, missing) {
   const criteria = Array.isArray(state?.contract?.acceptanceCriteria) ? state.contract.acceptanceCriteria : [];
   const items = [];
   for (const criterion of criteria.slice(0, 4)) {
-    const text = clip(criterion, 52);
-    if (!text) continue;
-    items.push({ status: criterionEvidenceFresh(state, text) ? "done" : "todo", text });
+    // Match evidence against the FULL criterion text; clip only for display. (Clipping
+    // before matching meant any criterion longer than the display width never checked
+    // off — the recorded evidence carries the full text.)
+    const full = String(criterion || "").replace(/\s+/g, " ").trim();
+    if (!full) continue;
+    items.push({ status: criterionEvidenceFresh(state, full) ? "done" : "todo", text: clip(full, 52) });
   }
   if (state?.dirty) items.push({ status: "todo", text: "Re-verify & re-review after recent edits" });
   // One row per missing/stale review gate, by friendly name — more scannable than a

package/plugins/goal-sidebar.tsx

@@ -35,6 +35,7 @@ const META_COLOR = "#8BE9FD"; // gates line (running) — cyan accent
 const STATUS_COLOR = "#FFB86C"; // status line (running) — orange, distinct from the cyan gates line
 const TODO_DONE_COLOR = "#50FA7B"; // ✓ done todo rows — green
 const POLL_MS = 1500;
+const GOAL_AGENT = "goal"; // the primary Goal agent id (mirrors agents.js PRIMARY_AGENT)
 const RAINBOW = ["#FF5555", "#FFAA00", "#FFFF55", "#55FF55", "#55FFFF", "#5599FF", "#FF55FF"];
 
 function resolveOptions(options, env) {
@@ -127,8 +128,33 @@ const tui = async (api, options) => {
         slots: {
           sidebar_content(_ctx, props) {
             if (!props?.session_id) return undefined;
+            // The session's CURRENT agent, from its latest message (mirrors the
+            // reference OpenCode TUI plugin). This is the authoritative, immediate
+            // signal of whether the session is in Goal mode right now — so when the
+            // user switches to Build (or any non-goal agent) the Goal section vanishes
+            // and OpenCode's native todos return, without waiting for persisted state.
+            const currentAgent = () => {
+              try {
+                const msgs = api?.state?.session?.messages?.(props.session_id);
+                if (Array.isArray(msgs)) {
+                  for (let i = msgs.length - 1; i >= 0; i--) {
+                    const a = msgs[i] && msgs[i].agent;
+                    if (a) return String(a).toLowerCase();
+                  }
+                }
+              } catch {
+                /* messages API unavailable — fall back to persisted goal state */
+              }
+              return undefined;
+            };
             const read = () => {
               try {
+                const agent = currentAgent();
+                // Render only in Goal mode. "goal" and its `goal-*` subagents count as
+                // Goal mode (so the section doesn't flicker out while reviewers run);
+                // any other primary agent (build/plan/custom) renders nothing here.
+                const goalMode = !agent || agent === GOAL_AGENT || agent.startsWith(`${GOAL_AGENT}-`);
+                if (!goalMode) return NO_GOAL;
                 return readModel(worktrees, props?.session_id) || NO_GOAL;
               } catch {
                 return NO_GOAL;
@@ -141,9 +167,42 @@ const tui = async (api, options) => {
             // Returning undefined at mount (the old behavior) meant the poll never
             // ran and the Goal section never showed even once a goal existed.
             const first = read();
-            const [model, setModel] = createSignal(first);
-            const timer = setInterval(() => setModel(read()), POLL_MS);
+            // equals:false → every refresh re-notifies, so a changed snapshot always
+            // repaints (gates/todos stay live even when the new object compares equal).
+            const [model, setModel] = createSignal(first, { equals: false });
+            const refresh = () => setModel(read());
+            // Refresh on OpenCode activity. Tool calls (verdicts, evidence, edits)
+            // change the gates/todos and emit message-part events, so subscribing here
+            // keeps the section up to date promptly — this is the mechanism the
+            // reference OpenCode TUI plugin uses. The interval is a fallback for any
+            // quiet period or runtime where the event bus is unavailable.
+            const offs = [];
+            try {
+              const bus = api && api.event;
+              if (bus && typeof bus.on === "function") {
+                for (const ev of ["message.part.updated", "message.updated", "session.idle"]) {
+                  try {
+                    const off = bus.on(ev, refresh);
+                    if (typeof off === "function") offs.push(off);
+                  } catch {
+                    /* unknown event type on this OpenCode build — skip it */
+                  }
+                }
+              }
+            } catch {
+              /* no event bus — rely on the interval */
+            }
+            const timer = setInterval(refresh, POLL_MS);
             onCleanup(() => clearInterval(timer));
+            onCleanup(() => {
+              for (const off of offs) {
+                try {
+                  off();
+                } catch {
+                  /* ignore */
+                }
+              }
+            });
             // First-display rainbow: starts the moment a goal FIRST appears. If a goal
             // is already present at mount it starts immediately; otherwise the effect
             // fires when the goal later appears (the common case — the goal is set

package/scripts/postinstall.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * Auto-setup on a GLOBAL install.
+ *
+ * When a user runs `npm install -g opencode-goal-mode` (a fresh install OR an
+ * upgrade), this runs the installer for them so that, with a single command, the
+ * package's components are (re)copied into `~/.config/opencode`, the Goal sidebar
+ * is registered in `tui.json`, and OpenCode's stale plugin cache is cleared so the
+ * just-installed version actually loads. That makes `npm install -g` "really
+ * update" — no separate `opencode-goal-mode --global` step required.
+ *
+ * Safety:
+ *  - Runs ONLY for global installs (npm sets `npm_config_global`). Repo development
+ *    (`npm ci` / `npm install`) and installs as a project dependency are no-ops, so
+ *    this never writes to a user's config when it shouldn't.
+ *  - Best-effort: it NEVER fails the npm install. Any problem prints a one-line
+ *    hint to run `opencode-goal-mode --global` manually and exits 0.
+ */
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { join, dirname } from "node:path";
+
+function isGlobalInstall() {
+  const g = process.env.npm_config_global;
+  return g === "true" || g === "1" || g === true;
+}
+
+if (!isGlobalInstall()) {
+  // Local/dev/dependency install — do not touch the user's OpenCode config.
+  process.exit(0);
+}
+
+try {
+  const installer = join(dirname(fileURLToPath(import.meta.url)), "install.mjs");
+  console.log("opencode-goal-mode: global install detected — updating ~/.config/opencode…");
+  const res = spawnSync(process.execPath, [installer, "--global"], { stdio: "inherit" });
+  // spawnSync does not throw on a non-zero exit (e.g. the installer refused to
+  // overwrite a file you edited). Surface a clear, actionable hint instead of
+  // leaving only the child's raw error.
+  if (res.error || res.status !== 0) {
+    console.warn(
+      "opencode-goal-mode: auto-setup didn't fully complete. " +
+        "Run `opencode-goal-mode --global` manually (add --force to replace files you've edited), then restart OpenCode.",
+    );
+  }
+} catch (err) {
+  console.warn(
+    `opencode-goal-mode: auto-setup skipped (${(err && err.message) || err}). ` +
+      "Run `opencode-goal-mode --global` to finish, then restart OpenCode.",
+  );
+}
+// Never fail `npm install`, regardless of the installer's outcome.
+process.exit(0);