opencode-goal-mode 0.3.6 → 0.3.8

package/ARCHITECTURE.md

@@ -15,9 +15,9 @@ configuration directory:
    — a runtime guard that enforces review discipline, blocks destructive shell
    commands, preserves state across compaction and restarts, and exposes
    first-class `goal_*` tools.
-4. **An experimental TUI companion** (`plugins/goal-sidebar.js`) — a separate
-   `{ tui }` plugin module that renders the active goal as a yellow sidebar
-   banner. It is *paired* with the server plugin purely through the on-disk state
+4. **An experimental TUI companion** (`plugins/goal-sidebar.tsx`) — a separate
+   `{ tui }` plugin module that renders Goal sessions as a Goal-owned sidebar
+   todo section. It is *paired* with the server plugin purely through the on-disk state
    snapshot (no extra IPC) and no-ops on any runtime without the slot API.
 
 This document focuses on the plugin, where the engineering lives.
@@ -54,7 +54,7 @@ as plugins. Each module is independently unit-tested.
 | `goal-guard/system.js` | Live state block injected into the system prompt. |
 | `goal-guard/summary.js` | Status/evidence projections, the short goal label, and the sidebar view. |
 | `goal-guard/tools.js` | The `goal_status` / `goal_evidence_map` / `goal_reviewer_memory` / `goal_contract` / `goal_evidence` / `goal_reset` tools. |
-| `goal-guard/sidebar-data.js` | Pure reader that projects the persisted snapshot into the sidebar banner model. |
+| `goal-guard/sidebar-data.js` | Pure reader that projects the persisted snapshot into the sidebar todo model. |
 | `goal-guard/logger.js` | Best-effort logging/toasts over the OpenCode client. |
 
 ## Hooks used
@@ -165,14 +165,15 @@ hooks still load.
 
 ## TUI companion (experimental)
 
-`plugins/goal-sidebar.js` is a TUI plugin module — `export const tui = async (api)
-=> …` — distinct from the server plugin (`@opencode-ai/plugin` types it as a
-`{ tui }` module, mutually exclusive with `{ server }`). It registers a
-`sidebar_content` slot via `api.slots.register({ slots: { sidebar_content } })`
-and renders, in the configured colour (`#FFD700` by default), the short goal
-label plus a `passing/total gates · dirty/ready` line. It renders
-unconditionally: when a task is running with no goal set, it shows a muted grey
-`No goal` (`sidebarView` returns `{ hasGoal: false }`) rather than a blank slot.
+`plugins/goal-sidebar.tsx` is a TUI plugin module — default-exporting `{ id, tui }`
+— distinct from the server plugin. It waits until the persisted state contains an
+active Goal session, then registers a `sidebar_content` slot via
+`api.slots.register({ slots: { sidebar_content } })` and renders the short goal
+label, gate/status line, and structured Goal todos derived from acceptance
+criteria, evidence freshness, dirty state, and missing gates. It starts with a
+brief rainbow foreground effect, then returns to the configured running colour
+(`#FFD700` by default). When there is no active Goal session it does not register
+the slot, so Build and other modes keep OpenCode's native todo section in place.
 
 It is *paired* with the server plugin only through the persisted state file:
 `sidebar-data.js` recomputes the same `stateBaseDir`/`projectKey` path the guard
@@ -187,7 +188,7 @@ progress is visible even without the banner.
 The JSX renderer is verified headlessly with `@opentui/solid`'s `testRender` in
 `tools/visual-test/sidebar-visual.jsx` (`npm run test:visual`, needs Bun + the
 OpenTUI stack): it asserts the rendered text, the exact foreground colours, and
-the bold attribute for goal / "No goal" / ready states. That tool is excluded from
+the bold attribute for Goal todo / done / native-todo-preserved states. That tool is excluded from
 the npm package and from `node --test`/CI.
 
 ## Configuration

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## Unreleased
+
+- Installer docs and `--help` now put the one-command `npx opencode-goal-mode --global`
+  flow first, clarify global vs project targets, and document the merge-safe
+  `tui.json` registration/uninstall behavior.
+- The TUI companion now renders a Goal-owned, structured todo section only for
+  active Goal sessions, with a first-display rainbow effect before returning to
+  normal lifecycle colours. Non-Goal modes render nothing from the Goal plugin so
+  OpenCode's native todo section remains in place.
+- Destructive-command blocking no longer activates Goal enforcement for Build or
+  other non-Goal sessions, preventing non-Goal tasks from being classified as goals.
+
+## v0.3.7
+
+- **FIX: the sidebar now actually loads.** OpenCode loads a TUI plugin via the
+  package's `exports["./tui"]` subpath (verified against the OpenCode binary), and
+  ours had no `exports`, so it silently never loaded. The package now maps
+  `"./tui"` (and `main`) to `plugins/goal-sidebar.tsx`, and the entry is shipped as
+  `.tsx` so OpenCode transpiles it. Confirmed working in a real OpenCode 1.17.6 TUI.
+- **Sidebar layout, as requested:** three stacked lines — `GOAL  <title>`, then the
+  gate count (`n/m gates`), then the status (`in progress` / `… · changes pending`
+  / `completed · k review cycles`). The leading orb (◆) is removed.
+- **AI-generated goal title:** `goal_contract` takes a short `title` the Goal agent
+  writes (the objective, like a session title); the sidebar shows it, falling back
+  to the raw goal text until titled.
+- **One-command install:** `npx opencode-goal-mode --global` (new `opencode-goal-mode`
+  bin alias). The installer registers the sidebar in `tui.json` (merge-safe) and
+  `--uninstall` removes that entry too. Install instructions moved to the top of the
+  README.
+- Colours configurable: `sidebarColor` (running), `sidebarDoneColor` (done),
+  `sidebarMutedColor` (no goal).
+
 ## v0.3.6
 
 - **FIX: the sidebar never loaded.** TUI plugins are loaded from

package/README.md

@@ -7,22 +7,55 @@
 [![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)
 
-Strict Goal Mode for OpenCode: a primary `goal` agent, a matrix of specialized
-review subagents, slash commands, and a `goal-guard` plugin that enforces review
-discipline, blocks destructive shell commands, and preserves goal state across
-compaction **and** restarts.
+Strict Goal Mode for OpenCode: a primary `goal` agent, specialized review
+subagents, slash commands, a `goal-guard` plugin that enforces review discipline
+and blocks destructive shell commands, and a live Goal-owned todo section in the
+TUI sidebar.
+
+## Install
+
+**One command** (recommended; needs [Node](https://nodejs.org) 20.11+ and a working [OpenCode](https://opencode.ai) install):
 
 ```bash
-npm install -g opencode-goal-mode && opencode-goal-mode-install --global
+npx opencode-goal-mode --global
 ```
 
-![OpenCode Goal Mode sidebar banner](docs/sidebar-demo.svg)
+Then **restart OpenCode**. That's the whole install: it copies the Goal agent,
+review subagents, slash commands, and guard plugin into `~/.config/opencode`, and
+merge-safely registers the Goal todo sidebar in `~/.config/opencode/tui.json`.
+In the agent picker you'll see only the **`goal`** agent; reviewers are subagents
+it drives automatically. Goal Mode inherits your existing OpenCode model/provider.
 
-<sub>↑ Illustrative mockup of the **experimental** sidebar banner. The enforcement
-core (guard + agents) is the verified product; the TUI sidebar is opt-in and its
-live render depends on your OpenCode build — see [TUI integration](#tui-integration).</sub>
+<details>
+<summary>Other ways to install</summary>
 
-**[Quick start](#quick-start) · [Install](#install) · [Why it's different](#why-its-different) · [Benchmarks](#benchmarks-honest-edition) · [TUI integration](#tui-integration) · [Configuration](#configuration) · [Releasing](#releasing) · [Architecture](ARCHITECTURE.md)**
+```bash
+# Global npm install, then run the installer
+npm install -g opencode-goal-mode
+opencode-goal-mode --global          # alias of opencode-goal-mode-install
+
+# Into a single project (writes ./.opencode, including ./.opencode/tui.json)
+npx opencode-goal-mode
+
+# From source
+git clone https://github.com/devinoldenburg/opencode-goal-mode
+cd opencode-goal-mode && npm ci && npm run install:global
+```
+
+Use global install for normal daily use. Use project install only when you want
+Goal Mode scoped to one repo and your OpenCode build reads project `.opencode`
+config, including `.opencode/tui.json`. `--dry-run` previews changes;
+`--uninstall` removes only what it installed (and its `tui.json` entry), leaving
+your edits untouched. See [Installer options](#installer-options).
+</details>
+
+![OpenCode Goal Mode sidebar todo section](docs/sidebar-demo.svg)
+
+<sub>↑ In Goal mode, the sidebar todo slot becomes a Goal-owned todo section with
+a first-display rainbow effect, then normal goal colours. Build and other modes
+keep OpenCode's native todo section — see [TUI integration](#tui-integration).</sub>
+
+**[Quick start](#quick-start) · [Why it's different](#why-its-different) · [Benchmarks](#benchmarks-honest-edition) · [TUI integration](#tui-integration) · [Configuration](#configuration) · [Releasing](#releasing) · [Architecture](ARCHITECTURE.md)**
 
 ## Quick start
 
@@ -46,8 +79,8 @@ opencode agent list | grep goal
    **cannot** answer `Goal Completed` until every required review gate passes — the
    guard rewrites a premature claim to `Goal Not Completed`. Try a destructive
    command mid-session (e.g. `rm -rf build`) and watch it get blocked. If your
-   OpenCode build supports TUI plugins, the active goal also appears in the sidebar
-   in yellow (experimental — see [TUI integration](#tui-integration)).
+   OpenCode build supports TUI plugins, Goal sessions also get the Goal-owned
+   sidebar todo section (experimental — see [TUI integration](#tui-integration)).
 
 That's it. Everything below is detail.
 
@@ -131,7 +164,12 @@ second) — negligible for a per-tool-call guard:
 ## Requirements
 
 - Node.js 20.11 or newer.
-- OpenCode configured to load local agents, commands, and plugins.
+- OpenCode configured to load local agents, commands, and plugins. The package is
+  tested against `@opencode-ai/plugin` 1.17.6 and declares compatibility with the
+  1.15+ plugin hook surface used here; newer OpenCode builds that change plugin
+  or TUI slot APIs may need a package update.
+- A working OpenCode provider/model; Goal Mode does not configure API keys or
+  choose a model for you.
 
 ## What it adds
 
@@ -164,9 +202,10 @@ second) — negligible for a per-tool-call guard:
   - **TUI toasts**: a toast on each review verdict (PASS/FAIL), with the
     reviewer's friendly name, and a single "completion unlocked" toast the moment
     the last required gate clears.
-- An **experimental** companion TUI plugin (`plugins/goal-sidebar.js`) that shows
-  the active goal as a shining-yellow banner in the sidebar with a compact gate
-  status line. See [TUI integration](#tui-integration).
+- An **experimental** companion TUI plugin (`plugins/goal-sidebar.tsx`) that, in
+  Goal sessions only, replaces the native todo sidebar area with a Goal-owned,
+  evidence-aware todo section. It shows a brief rainbow effect the first time it
+  appears, then normal goal colours. See [TUI integration](#tui-integration).
 - A test suite validating the analyzer, plugin hooks, state store, install
   safety, and config compatibility.
 
@@ -174,84 +213,62 @@ second) — negligible for a per-tool-call guard:
 
 Goal Mode is a **plugin pair**: the server-side `goal-guard` plugin owns
 enforcement and writes its state to disk, and an experimental TUI plugin
-(`plugins/goal-sidebar.js`) reads that same state to render a live banner.
-
-- **Sidebar goal banner.** In the sidebar's content area, under the session
-  title/context, it shows the current goal with generated status text, colour-coded
-  by lifecycle:
-  - **yellow** — a goal is set and running (`◆ GOAL …` + `in progress · N/M gates`);
-  - **red** — the goal is done (all required gates pass, tree clean: `✓ GOAL …` +
-    `completed · N/M gates passed · K review cycles`);
-  - **grey** — a task is running with no goal set (`No goal available`).
+(`plugins/goal-sidebar.tsx`) reads that same state to render a live todo section.
+
+- **Goal-mode todo replacement.** In a `goal` session, the sidebar content/todo
+  area is replaced by a Goal-owned todo section: short goal title, gate progress,
+  lifecycle status, and structured todo rows derived from acceptance criteria,
+  evidence freshness, dirty state, and missing review gates. It starts with a
+  brief rainbow foreground effect (`sidebarRainbowMs`) so the replacement is
+  visible, then returns to the normal lifecycle colours:
+  - **yellow** — a goal is set and running;
+  - **red** — the goal is done (all required gates pass and the tree is clean);
+  - **no render** — Build and every non-Goal mode keep OpenCode's native todo
+    section in the same sidebar position instead of being classified as a goal.
 
   Toggle/recolour with `sidebarBanner`, `sidebarColor` (running), `sidebarDoneColor`
-  (done), `sidebarMutedColor` (no goal), or the `GOAL_GUARD_SIDEBAR_*` env vars.
+  (done), `sidebarMutedColor`, `sidebarRainbowMs`, or the `GOAL_GUARD_SIDEBAR_*`
+  env vars.
 
   **How it loads — important.** TUI plugins are **not** loaded from the `plugins/`
-  dir; OpenCode loads them from `~/.config/opencode/tui.json`. The installer writes
-  that for you (merge-safe):
+  dir; OpenCode loads them from `tui.json`. The Goal sidebar waits to register its
+  `sidebar_content` slot until a real Goal session exists, so non-Goal modes do not
+  get a blank replacement slot. With `--global`, the installer writes
+  `~/.config/opencode/tui.json` for you (merge-safe):
 
   ```json
   { "$schema": "https://opencode.ai/tui.json", "plugin": ["opencode-goal-mode"] }
   ```
 
   Restart OpenCode after install so it picks up the TUI plugin (it resolves the
-  package and provides the `@opentui/solid` runtime). The banner appears in a
-  **session** view (not the home screen). The three states are rendered and
-  asserted — text + exact colours — by a real headless OpenTUI renderer in the
-  [visual test](tools/visual-test/README.md) (`npm run test:visual`, 18/18). The
+  package and provides the `@opentui/solid` runtime). The Goal todo section appears
+  in a **Goal session** view (not the home screen and not Build mode). The visual
+  harness renders it with a headless OpenTUI renderer in
+  [visual test](tools/visual-test/README.md) (`npm run test:visual`). The
   enforcement core is a separate server plugin and works regardless of the sidebar.
 - **Toasts.** Review verdicts and completion-unlock events surface as toasts
   (`toastOnReview`), and blocked destructive commands / premature completions
   toast as before (`toastOnBlock`).
 
-## Install
-
-### From npm (recommended)
-
-```bash
-npm install -g opencode-goal-mode
-opencode-goal-mode-install --global    # installs into ~/.config/opencode
-```
-
-Then restart OpenCode (it loads agents, commands, and plugins at startup). In the
-agent picker you will see **only the `goal` agent** — the specialist reviewers are
-subagents the Goal agent drives for you; they are never selectable by the user.
-
-Install into a single project instead of globally:
-
-```bash
-npm install -D opencode-goal-mode
-npx opencode-goal-mode-install         # writes to ./.opencode
-```
-
-Upgrade later by re-running the same install command after `npm install -g
-opencode-goal-mode@latest`; the installer replaces only the files it owns and
-leaves your local edits alone (see [Installer options](#installer-options)).
-
-### From source
-
-```bash
-git clone https://github.com/devinoldenburg/opencode-goal-mode
-cd opencode-goal-mode
-npm ci
-npm run validate
-npm run install:global                 # or: npm run install:local
-```
-
 ## Installer options
 
 ```bash
+npx opencode-goal-mode --global --dry-run
+npx opencode-goal-mode --global
+opencode-goal-mode-install --global --uninstall
 node scripts/install.mjs --dry-run
 node scripts/install.mjs --target /path/to/opencode-config
 node scripts/install.mjs --global --force
 node scripts/install.mjs --global --uninstall
 ```
 
-The installer records a manifest of the files it writes. On upgrade it replaces
-files it owns but refuses to clobber files you have locally modified unless
-`--force` is passed. `--uninstall` removes only the files it installed and leaves
-your local edits in place.
+Default target rules are simple: `--global` writes to `~/.config/opencode`; no
+flag writes to `./.opencode`; `--target` writes to exactly the directory you pass.
+In every target, the installer copies only `agents/`, `commands/`, `plugins/`,
+writes `.goal-mode-manifest.json`, and merge-safely adds `opencode-goal-mode` to
+`tui.json` in that same target. On upgrade it replaces files it owns but refuses
+to clobber files you have locally modified unless `--force` is passed.
+`--uninstall` removes only owned files and removes only its own `tui.json` entry.
 
 ## Configuration
 
@@ -280,10 +297,11 @@ Or via environment variables (`GOAL_GUARD_*`):
 | `sessionTtlMs` / `GOAL_GUARD_SESSION_TTL_MS` | `86400000` | Idle session TTL. |
 | `toastOnBlock` / `GOAL_GUARD_TOAST_ON_BLOCK` | `true` | Toast when something is blocked. |
 | `toastOnReview` / `GOAL_GUARD_TOAST_ON_REVIEW` | `true` | Toast on each review verdict and when completion unlocks. |
-| `sidebarBanner` / `GOAL_GUARD_SIDEBAR_BANNER` | `true` | Show the experimental yellow goal banner in the TUI sidebar. |
-| `sidebarColor` / `GOAL_GUARD_SIDEBAR_COLOR` | `#FFD700` | Colour of a **running** goal in the sidebar (yellow). |
+| `sidebarBanner` / `GOAL_GUARD_SIDEBAR_BANNER` | `true` | Show the experimental Goal todo section in the TUI sidebar. |
+| `sidebarColor` / `GOAL_GUARD_SIDEBAR_COLOR` | `#FFD700` | Normal colour of a **running** goal after the first-show rainbow. |
 | `sidebarDoneColor` / `GOAL_GUARD_SIDEBAR_DONE_COLOR` | `#FF5555` | Colour of a **done** goal in the sidebar (red). |
-| `sidebarMutedColor` / `GOAL_GUARD_SIDEBAR_MUTED_COLOR` | `#808080` | Colour of the "No goal available" line (grey). |
+| `sidebarMutedColor` / `GOAL_GUARD_SIDEBAR_MUTED_COLOR` | `#808080` | Reserved muted colour for no-goal projections. |
+| `sidebarRainbowMs` / `GOAL_GUARD_SIDEBAR_RAINBOW_MS` | `4500` | First-display rainbow duration for the Goal todo section. |
 
 ## Custom tools
 
@@ -303,7 +321,7 @@ criterion against recorded evidence, reviewer status, gaps, and the next
 required action. The command is backed by the `goal_evidence_map` tool, so it
 uses persisted Goal Guard state rather than relying on transcript memory.
 
-## Validation
+## Contributor validation
 
 ```bash
 npm test

package/agents/goal.md

@@ -85,7 +85,7 @@ Required internal artifacts:
 
 Guard tools (provided by the goal-guard plugin):
 
-- Call `goal_contract` once the Goal Contract is settled. This activates strict enforcement and tells the guard which specialist review gates your goal requires (security, data, api, perf, etc., inferred from the contract text).
+- Call `goal_contract` once the Goal Contract is settled. Always include a concise `title` (max ~8 words, no trailing punctuation) that captures what the user ultimately wants — phrased like a session title but about the objective (e.g. "Rate-limit the login endpoint", "Migrate auth to JWT"). This title is shown live in the TUI sidebar, so make it specific and readable. Recording the contract activates strict enforcement and tells the guard which specialist review gates your goal requires (security, data, api, perf, etc., inferred from the contract text).
 - Call `goal_evidence` after each meaningful verification run to record the command and result in the Verification Ledger.
 - Call `goal_status` whenever you are unsure what the guard currently requires; it returns the authoritative list of passing, missing, and stale gates and whether completion is allowed. Trust it over your own recollection.
 - The guard injects a live state block into your context each turn and will rewrite a premature `Goal Completed` into `Goal Not Completed` with the missing gates. Use `goal_status` to avoid that rather than guessing.

package/commands/goal.md

@@ -11,11 +11,12 @@ $ARGUMENTS
 
 Run this sequence:
 
-1. **Seed the contract first.** Call the `goal_contract` tool with the original
-   request, explicit/inferred requirements, non-goals, and concrete acceptance
-   criteria. This activates enforcement, fixes the required specialist review
-   gates, and lights up the goal banner in the sidebar. Ask only essential
-   clarifying questions before recording it.
+1. **Seed the contract first.** Call the `goal_contract` tool with a concise
+   `title` (≤8 words, what the user ultimately wants — like a session title for
+   the objective), the original request, explicit/inferred requirements,
+   non-goals, and concrete acceptance criteria. This activates enforcement, fixes
+   the required specialist review gates, and shows the `title` live in the sidebar
+   goal banner. Ask only essential clarifying questions before recording it.
 2. Delegate discovery and research to subagents; implement in the main agent.
 3. Verify, and record each verification with the `goal_evidence` tool so it maps
    to your acceptance criteria.

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "opencode-goal-mode",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Strict Goal Mode agents, commands, and guard plugin for OpenCode.",
   "type": "module",
-  "main": "plugins/goal-sidebar.js",
+  "main": "plugins/goal-sidebar.tsx",
+  "exports": {
+    ".": "./plugins/goal-sidebar.tsx",
+    "./tui": "./plugins/goal-sidebar.tsx",
+    "./package.json": "./package.json"
+  },
   "engines": {
     "node": ">=20.11"
   },
   "packageManager": "npm@10",
   "bin": {
+    "opencode-goal-mode": "scripts/install.mjs",
     "opencode-goal-mode-install": "scripts/install.mjs"
   },
   "files": [
@@ -93,8 +99,14 @@
     "solid-js": "*"
   },
   "peerDependenciesMeta": {
-    "@opencode-ai/plugin": { "optional": true },
-    "@opentui/solid": { "optional": true },
-    "solid-js": { "optional": true }
+    "@opencode-ai/plugin": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
   }
 }

package/plugins/goal-guard/config.js

@@ -28,14 +28,16 @@ export const DEFAULT_CONFIG = Object.freeze({
   toastOnBlock: true,
   /** Emit a TUI toast when a review gate records a PASS/FAIL, and when completion unlocks. */
   toastOnReview: true,
-  /** Show the experimental yellow goal banner in the TUI sidebar (TUI-plugin-capable OpenCode only). */
+  /** Show the experimental goal todo section in the TUI sidebar (TUI-plugin-capable OpenCode only). */
   sidebarBanner: true,
-  /** Foreground colour (hex) for the sidebar goal banner. */
+  /** Foreground colour (hex) for the sidebar goal todo section after the first-show rainbow. */
   sidebarColor: "#FFD700",
   /** Foreground colour (hex) for a completed goal in the sidebar (running → done turns yellow → red). */
   sidebarDoneColor: "#FF5555",
-  /** Foreground colour (hex) for the muted "No goal available" sidebar line. */
+  /** Reserved muted foreground colour for no-goal projections. */
   sidebarMutedColor: "#808080",
+  /** Duration for the first-display rainbow effect on the Goal todo section. */
+  sidebarRainbowMs: 4500,
   /** Phrase that, at the start of an assistant message, claims completion. */
   completionMarker: "Goal Completed",
   /** Replacement marker when completion is blocked. */
@@ -74,6 +76,7 @@ function fromEnv(env) {
     GOAL_GUARD_SIDEBAR_COLOR: ["sidebarColor", (v) => (v == null ? undefined : String(v))],
     GOAL_GUARD_SIDEBAR_DONE_COLOR: ["sidebarDoneColor", (v) => (v == null ? undefined : String(v))],
     GOAL_GUARD_SIDEBAR_MUTED_COLOR: ["sidebarMutedColor", (v) => (v == null ? undefined : String(v))],
+    GOAL_GUARD_SIDEBAR_RAINBOW_MS: ["sidebarRainbowMs", coerceInt],
   };
   for (const [key, [field, coerce]] of Object.entries(map)) {
     if (env[key] !== undefined) out[field] = coerce(env[key], DEFAULT_CONFIG[field]);

package/plugins/goal-guard/guard.js

@@ -136,7 +136,6 @@ export function createGuard(input = {}, options = {}, overrides = {}) {
         const blockDestructive = config.blockDestructive && analysis.destructive;
         const blockNetwork = config.blockNetworkExec && analysis.networkExec;
         if (blockDestructive || blockNetwork) {
-          state.active = true;
           state.dirtyReasons.push(`blocked risky bash: ${analysis.reasons.join("; ") || "destructive"}`);
           if (config.toastOnBlock) logger.toast("Goal Guard blocked a destructive command", "error");
           persist();

package/plugins/goal-guard/sidebar-data.js

@@ -1,5 +1,5 @@
 /**
- * Read-only projection of persisted guard state for the TUI sidebar banner.
+ * Read-only projection of persisted guard state for the TUI sidebar todo section.
  *
  * The sidebar plugin runs in OpenCode's TUI process, separate from the server
  * plugin that owns the live store. The two are paired through the same on-disk
@@ -49,10 +49,9 @@ export function pickSession(snapshot, sessionId) {
 }
 
 /**
- * Build the sidebar banner model for a worktree. ALWAYS returns an object so the
- * sidebar renders unconditionally: `{ hasGoal: false }` when there is no state,
- * no active session, or no goal (render a muted "No goal"); otherwise
- * `{ hasGoal: true, goal, status, … }` (see summary.sidebarView).
+ * Build the sidebar todo model for a worktree. ALWAYS returns an object: `state:
+ * "none"` when there is no Goal session (render nothing and keep native todos), otherwise
+ * `state: "running"|"done", goal, status, todos, …` (see summary.sidebarView).
  *
  * @param {object} opts
  * @param {string} opts.worktree   Project worktree root (same key the guard uses).

package/plugins/goal-guard/summary.js

@@ -6,12 +6,18 @@
 import { requiredGates, missingGates, gatePassedFresh } from "./gates.js";
 
 /**
- * A short, single-line human label for the current goal — preferring the
- * recorded Goal Contract's original request, falling back to the captured goal
- * text. Collapses whitespace and truncates to `max` chars for compact display
- * (status reports, the TUI sidebar banner).
+ * A short, single-line label for the current goal.
+ *
+ * Prefers `contract.title` — a concise, AI-generated summary of the objective
+ * (what the user wants), written by the Goal agent when it records the contract
+ * via `goal_contract` (think "session title", but the goal/objective). Falls back
+ * to the contract's original request, then the captured goal text, so something
+ * sensible still shows before the agent has titled the goal. Collapses whitespace
+ * and truncates to `max` chars for the compact sidebar.
  */
 export function shortGoalLabel(state, max = 80) {
+  const title = String(state?.contract?.title || "").replace(/\s+/g, " ").trim();
+  if (title) return title.length <= max ? title : `${title.slice(0, max - 1).trimEnd()}…`;
   const raw = String(state?.contract?.original || state?.goalText || "").replace(/\s+/g, " ").trim();
   if (!raw) return "";
   // Prefer the first sentence/clause if it is reasonably short.
@@ -21,18 +27,40 @@ export function shortGoalLabel(state, max = 80) {
   return `${base.slice(0, max - 1).trimEnd()}…`;
 }
 
-/** Sentinel for "a task is running but no goal is set" — the sidebar shows a muted "No goal available". */
-export const NO_GOAL = Object.freeze({ state: "none", goal: "", detail: "" });
+/** Sentinel for "no active Goal session" — the TUI plugin renders nothing so native todos remain. */
+export const NO_GOAL = Object.freeze({ state: "none", goal: "", gates: "", status: "" });
+
+function criterionEvidenceFresh(state, criterion) {
+  const entries = Array.isArray(state.evidence) ? state.evidence : [];
+  return entries.some((entry) => evidenceMatchesCriterion(entry, criterion) && evidenceFresh(entry, state));
+}
+
+function sidebarTodos(state, required, missing) {
+  const criteria = Array.isArray(state?.contract?.acceptanceCriteria) ? state.contract.acceptanceCriteria : [];
+  const items = [];
+  for (const criterion of criteria.slice(0, 5)) {
+    const text = String(criterion || "").replace(/\s+/g, " ").trim();
+    if (!text) continue;
+    items.push({
+      status: criterionEvidenceFresh(state, text) ? "done" : "todo",
+      text: text.length <= 58 ? text : `${text.slice(0, 57).trimEnd()}…`,
+    });
+  }
+  if (state?.dirty) items.push({ status: "todo", text: "Rerun verification and reviews after latest changes" });
+  if (missing.length > 0) items.push({ status: "todo", text: `Clear review gates: ${missing.slice(0, 3).join(", ")}${missing.length > 3 ? "…" : ""}` });
+  if (items.length === 0 && required.length > 0) items.push({ status: "todo", text: "Record Goal Contract acceptance criteria" });
+  return items.slice(0, 7);
+}
 
 /**
- * Compact projection for the TUI sidebar banner. ALWAYS returns an object with a
- * three-way `state` so the sidebar renders unconditionally:
- *   - `state: "none"`    → no active goal: grey "No goal available".
- *   - `state: "running"` → goal in progress: yellow, with a generated status line.
- *   - `state: "done"`    → goal complete (all required gates pass, tree clean):
- *                           red, with a generated completion line.
- * `goal` is the short goal label; `detail` is generated descriptive text derived
- * from the current goal's gate/cycle/dirty state.
+ * Compact projection for the TUI sidebar todo section. ALWAYS returns an object with a
+ * three-way `state`, plus three lines that stack vertically in the sidebar:
+ *   - `goal`   → line 1: the short AI goal title.
+ *   - `gates`  → line 2: the gate count, e.g. "0/7 gates".
+ *   - `status` → line 3: the lifecycle status, e.g. "in progress · changes pending"
+ *                or "completed · 2 review cycles".
+ * State drives colour: "running" = rainbow first, then yellow; "done" = red;
+ * "none" = render nothing so non-Goal modes keep the native todo section.
  */
 export function sidebarView(state, config) {
   if (!state || !state.active) return NO_GOAL;
@@ -42,24 +70,29 @@ export function sidebarView(state, config) {
   const missing = missingGates(state, config);
   const passing = required.length - missing.length;
   const cycles = Number(state.reviewCycles) || 0;
+  const gates = `${passing}/${required.length} gates`;
+  const todos = sidebarTodos(state, required, missing);
   const done = required.length > 0 && missing.length === 0 && !state.dirty;
   if (done) {
     return {
       state: "done",
       goal,
-      detail: `completed · ${passing}/${required.length} gates passed · ${cycles} review cycle${cycles === 1 ? "" : "s"}`,
+      gates,
+      status: `completed · ${cycles} review cycle${cycles === 1 ? "" : "s"}`,
+      todoTitle: "Goal todos",
+      todos: todos.length ? todos.map((item) => ({ ...item, status: "done" })) : [{ status: "done", text: "All Goal completion gates are clear" }],
       passing,
       required: required.length,
       reviewCycles: cycles,
     };
   }
-  const bits = [`${passing}/${required.length} gates`];
-  if (state.dirty) bits.push("changes pending");
-  if (cycles) bits.push(`cycle ${cycles}`);
   return {
     state: "running",
     goal,
-    detail: `in progress · ${bits.join(" · ")}`,
+    gates,
+    status: `in progress${state.dirty ? " · changes pending" : ""}`,
+    todoTitle: "Goal todos",
+    todos,
     passing,
     required: required.length,
     reviewCycles: cycles,

package/plugins/goal-guard/tools.js

@@ -92,6 +92,13 @@ export function createGoalTools({ store, config, persist }) {
         "inferred requirements, non-goals, and acceptance criteria). Establishing a contract " +
         "activates strict goal enforcement and drives which specialist review gates are required.",
       args: {
+        title: s
+          .string()
+          .describe(
+            "A short (max ~8 words) human-friendly title summarizing the GOAL/objective — what the user " +
+              "ultimately wants, phrased like a session title but about the outcome. Shown in the TUI sidebar. " +
+              "e.g. 'Rate-limit the login endpoint', 'Migrate auth to JWT'. No trailing punctuation.",
+          ),
         original: s.string().describe("The original user request, verbatim or faithfully summarized."),
         requirements: s.array(s.string()).optional().describe("Explicit requirements stated by the user."),
         inferred: s.array(s.string()).optional().describe("Reasonable inferred requirements."),
@@ -104,6 +111,7 @@ export function createGoalTools({ store, config, persist }) {
         const state = store.stateFor(ctx.sessionID);
         state.active = true;
         state.contract = {
+          title: String(args.title || "").replace(/\s+/g, " ").trim(),
           original: String(args.original || ""),
           requirements: args.requirements || [],
           inferred: args.inferred || [],

package/plugins/goal-sidebar.tsx

@@ -0,0 +1,164 @@
+/** @jsxImportSource @opentui/solid */
+/**
+ * Goal Mode — TUI sidebar todo section.
+ *
+ * In Goal agent sessions this replaces the native-looking todo area with a
+ * Goal-owned, evidence-aware todo section. Non-Goal sessions render nothing here
+ * so Build and other modes keep OpenCode's normal todo section in the same slot.
+ *
+ * How OpenCode loads this: TUI plugins are listed in `~/.config/opencode/tui.json`
+ * (NOT the plugins/ dir) and resolved via the package's `exports["./tui"]`. The
+ * installer writes tui.json (`plugin: ["opencode-goal-mode"]`); package.json maps
+ * `./tui` → this file; OpenCode supplies the `@opentui/solid` + `solid-js` runtime
+ * (declared as peer deps). The pure projection (`summary.sidebarView`) is shared
+ * with the server plugin and unit-tested via goal-guard/sidebar-data.js.
+ *
+ * Runtime notes: single `export default { id, tui }`; node built-ins are require()d
+ * lazily (the Bun TUI runtime rejects top-level node: imports). Never imported by
+ * the Node test suite.
+ */
+
+import { createSignal, onCleanup, For, Show } from "solid-js";
+import { sidebarView, NO_GOAL } from "./goal-guard/summary.js";
+import { DEFAULT_CONFIG } from "./goal-guard/config.js";
+
+const DEFAULT_COLOR = "#FFD700"; // running — yellow
+const DEFAULT_DONE = "#FF5555"; // done — red
+const DEFAULT_MUTED = "#808080"; // no goal — grey
+const POLL_MS = 1500;
+const RAINBOW = ["#FF5555", "#FFAA00", "#FFFF55", "#55FF55", "#55FFFF", "#5599FF", "#FF55FF"];
+
+function resolveOptions(options, env) {
+  const e = env || {};
+  const enabledOpt = options?.sidebarBanner;
+  const enabledEnv = e.GOAL_GUARD_SIDEBAR_BANNER;
+  const disabled =
+    enabledOpt === false || enabledEnv === "0" || enabledEnv === "false" || enabledEnv === "off";
+  return {
+    enabled: !disabled,
+    color: options?.sidebarColor || e.GOAL_GUARD_SIDEBAR_COLOR || DEFAULT_COLOR,
+    doneColor: options?.sidebarDoneColor || e.GOAL_GUARD_SIDEBAR_DONE_COLOR || DEFAULT_DONE,
+    muted: options?.sidebarMutedColor || e.GOAL_GUARD_SIDEBAR_MUTED_COLOR || DEFAULT_MUTED,
+    rainbowMs: Number(options?.sidebarRainbowMs ?? e.GOAL_GUARD_SIDEBAR_RAINBOW_MS ?? 4500),
+  };
+}
+
+/** Read the guard's persisted snapshot for a worktree (path logic mirrors persistence.js). */
+function readSnapshot(worktree) {
+  try {
+    const fs = require("node:fs");
+    const path = require("node:path");
+    const os = require("node:os");
+    const crypto = require("node:crypto");
+    const xdg = process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.trim();
+    const base = xdg || path.join(os.homedir(), ".local", "state");
+    const key = crypto.createHash("sha256").update(String(worktree || "default")).digest("hex").slice(0, 16);
+    const file = path.join(base, "opencode", "goal-guard", `${key}.json`);
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Most-recently-touched active session, preferring an explicit active sessionId. */
+function pickSession(snapshot, sessionId) {
+  if (!snapshot || !Array.isArray(snapshot.sessions)) return null;
+  const records = snapshot.sessions
+    .filter((e) => Array.isArray(e) && e.length === 2)
+    .map(([key, st]) => [key, st && typeof st === "object" ? st : {}]);
+  if (sessionId) {
+    const direct = records.find(([key, st]) => key === sessionId && st.active);
+    if (direct) return direct[1];
+    return null;
+  }
+  const active = records.filter(([, st]) => st.active);
+  if (active.length === 0) return null;
+  active.sort((a, b) => (b[1].touchedAt || 0) - (a[1].touchedAt || 0));
+  return active[0][1];
+}
+
+function readModel(worktree, sessionId) {
+  try {
+    const snapshot = readSnapshot(worktree);
+    if (!snapshot) return NO_GOAL;
+    const record = pickSession(snapshot, sessionId);
+    if (!record) return NO_GOAL;
+    return sidebarView(record, DEFAULT_CONFIG);
+  } catch {
+    return NO_GOAL;
+  }
+}
+
+const id = "goal-mode-sidebar";
+
+/** @type {import("@opencode-ai/plugin/tui").TuiPlugin} */
+const tui = async (api, options) => {
+  try {
+    const { enabled, color, doneColor, rainbowMs } = resolveOptions(options, typeof process !== "undefined" ? process.env : {});
+    if (!enabled) return;
+    if (!api?.slots?.register) return; // runtime without the slot API → no-op.
+
+    const worktree = api.state?.path?.worktree || api.state?.path?.directory;
+
+    let registered = false;
+    const register = () => {
+      if (registered) return;
+      registered = true;
+      api.slots.register({
+        order: 50,
+        slots: {
+          sidebar_content(_ctx, props) {
+            if (!props?.session_id) return undefined;
+            const read = () => {
+              try {
+                return readModel(worktree, props?.session_id) || NO_GOAL;
+              } catch {
+                return NO_GOAL;
+              }
+            };
+            const initial = read();
+            if (initial.state === "none") return undefined;
+            const [model, setModel] = createSignal(initial);
+            const [rainbow, setRainbow] = createSignal((rainbowMs || 0) > 0);
+            const timer = setInterval(() => setModel(read()), POLL_MS);
+            const rainbowTimer = setTimeout(() => setRainbow(false), Math.max(0, rainbowMs || 0));
+            onCleanup(() => clearInterval(timer));
+            onCleanup(() => clearTimeout(rainbowTimer));
+            const fg = () => (model().state === "done" ? doneColor : color);
+            const lineColor = (index = 0) => (rainbow() && model().state === "running" ? RAINBOW[index % RAINBOW.length] : fg());
+            // Goal sessions render a Goal-owned todo section; non-Goal sessions return undefined so native todos remain.
+            return (
+              <Show when={model().state !== "none"}>
+                <box flexDirection="column" paddingTop={1}>
+                  <text fg={lineColor(0)}>
+                    <b>{model().todoTitle || "Goal todos"}</b>
+                    {`  ${model().goal}`}
+                  </text>
+                  <text fg={lineColor(1)}>{`${model().gates} · ${model().status}`}</text>
+                  <For each={model().todos || []}>
+                    {(item, index) => <text fg={lineColor(index() + 2)}>{`${item.status === "done" ? "✓" : "□"} ${item.text}`}</text>}
+                  </For>
+                </box>
+              </Show>
+            );
+          },
+        },
+      });
+    };
+
+    if (readModel(worktree).state !== "none") {
+      register();
+    } else {
+      const registrationTimer = setInterval(() => {
+        if (readModel(worktree).state !== "none") {
+          clearInterval(registrationTimer);
+          register();
+        }
+      }, POLL_MS);
+    }
+  } catch {
+    /* TUI runtime missing or API drift — render nothing rather than crash. */
+  }
+};
+
+export default { id, tui };

package/scripts/install.mjs

@@ -40,11 +40,13 @@ if (values.help) {
   console.log(`Install or remove OpenCode Goal Mode components.
 
 Usage:
+  npx opencode-goal-mode --global
+  opencode-goal-mode-install --global
   node scripts/install.mjs [--global | --target <dir>] [--force] [--dry-run]
   node scripts/install.mjs --uninstall [--global | --target <dir>] [--dry-run]
 
 Options:
-  --global       Install into ~/.config/opencode.
+  --global       Install into ~/.config/opencode (recommended for everyday use).
   --target DIR   Install into a specific OpenCode config directory.
   --force        Replace destination files even if locally modified.
   --uninstall    Remove files this installer previously wrote (per manifest).
@@ -53,7 +55,8 @@ Options:
 
 The installer records a manifest of the files it writes so that a later
 upgrade can distinguish files it owns (safe to replace) from files you have
-locally customized (left untouched unless --force).`);
+locally customized (left untouched unless --force). It also merge-safely adds
+the Goal sidebar plugin to <target>/tui.json; --uninstall removes that entry.`);
   process.exit(0);
 }
 
@@ -75,6 +78,15 @@ function fileHash(path) {
   return createHash("sha256").update(readFileSync(path)).digest("hex").slice(0, 16);
 }
 
+function safeTargetPath(rel) {
+  const dest = resolve(target, rel);
+  const back = relative(target, dest);
+  if (back === "" || back.startsWith("..") || resolve(back) === back) {
+    throw new Error(`Refusing to operate outside target: ${rel}`);
+  }
+  return dest;
+}
+
 /** Recursively list regular files under a directory, returning paths relative to
  * `base`. Uses lstat and skips symlinks so the installer only copies files it can
  * reason about (no following links outside the package tree). */
@@ -140,8 +152,13 @@ function ensureTuiPlugin(remove = false) {
   try {
     const existing = JSON.parse(readFileSync(tuiPath, "utf8"));
     if (existing && typeof existing === "object") data = existing;
-  } catch {
-    /* missing or invalid → start fresh */
+  } catch (err) {
+    if (existsSync(tuiPath)) {
+      if (!values.force) throw new Error(`Refusing to replace invalid ${tuiPath}. Fix it or rerun with --force.`);
+      const backupPath = `${tuiPath}.goal-mode-backup`;
+      if (!values["dry-run"]) copyFileSync(tuiPath, backupPath);
+      console.log(`${values["dry-run"] ? "Would back up" : "Backed up"} invalid ${tuiPath} to ${backupPath}`);
+    }
   }
   if (!Array.isArray(data.plugin)) data.plugin = [];
   const has = data.plugin.includes(TUI_PLUGIN_SPEC);
@@ -164,7 +181,7 @@ if (values.uninstall) {
   const removed = [];
   const kept = [];
   for (const [rel, hash] of Object.entries(manifest.files)) {
-    const dest = join(target, rel);
+    const dest = safeTargetPath(rel);
     if (!existsSync(dest)) continue;
     if (fileHash(dest) === hash) {
       if (!values["dry-run"]) rmSync(dest, { force: true });
@@ -242,7 +259,7 @@ for (const dir of COMPONENT_DIRS) {
 // plugin split into modules), but only if the user hasn't modified them.
 for (const [relKey, oldHash] of Object.entries(manifest.files)) {
   if (newManifestFiles[relKey] !== undefined) continue;
-  const dest = join(target, relKey);
+  const dest = safeTargetPath(relKey);
   if (!existsSync(dest)) continue;
   if (fileHash(dest) === oldHash) {
     if (!values["dry-run"]) rmSync(dest, { force: true });

package/plugins/goal-sidebar.js

@@ -1,147 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-/**
- * Goal Mode — TUI sidebar goal banner.
- *
- * This is a TUI plugin module (companion to the server-side goal-guard plugin).
- * It renders, in the sidebar's content area, the current goal with generated
- * status text and a colour that tracks the goal's lifecycle:
- *   - RUNNING (goal set, in progress)        → yellow
- *   - DONE    (all required gates pass, clean) → red
- *   - NONE    (a task is running, no goal set) → grey "No goal available"
- *
- * IMPORTANT — how OpenCode loads this: TUI plugins are NOT loaded from the
- * regular `plugin` array / plugins dir (that is server plugins). They are listed
- * in `~/.config/opencode/tui.json`:
- *     { "$schema": "https://opencode.ai/tui.json", "plugin": ["opencode-goal-mode"] }
- * The installer writes that automatically. OpenCode then loads this module
- * (the package `main`) and provides the `@opentui/solid` + `solid-js` runtime
- * (declared here as peer deps), so its slot shares OpenCode's renderer.
- *
- * Runtime constraints (from working OpenCode TUI plugins):
- *  - the module exports a single `export default { id, tui }`;
- *  - the Bun TUI runtime does not support top-level ESM imports of Node built-ins,
- *    so node:fs/path/os/crypto are require()d lazily inside functions;
- *  - it is never imported by the Node test suite (the pure projection it uses,
- *    summary.sidebarView, is tested via goal-guard/sidebar-data.js).
- */
-
-import { createSignal, onCleanup, Show } from "solid-js";
-import { sidebarView, NO_GOAL } from "./goal-guard/summary.js";
-import { DEFAULT_CONFIG } from "./goal-guard/config.js";
-
-const DEFAULT_COLOR = "#FFD700"; // shining yellow — running
-const DEFAULT_DONE = "#FF5555"; // red — completed
-const DEFAULT_MUTED = "#808080"; // grey — no goal
-const POLL_MS = 1500;
-
-function resolveOptions(options, env) {
-  const e = env || {};
-  const enabledOpt = options?.sidebarBanner;
-  const enabledEnv = e.GOAL_GUARD_SIDEBAR_BANNER;
-  const disabled =
-    enabledOpt === false || enabledEnv === "0" || enabledEnv === "false" || enabledEnv === "off";
-  return {
-    enabled: !disabled,
-    color: options?.sidebarColor || e.GOAL_GUARD_SIDEBAR_COLOR || DEFAULT_COLOR,
-    doneColor: options?.sidebarDoneColor || e.GOAL_GUARD_SIDEBAR_DONE_COLOR || DEFAULT_DONE,
-    muted: options?.sidebarMutedColor || e.GOAL_GUARD_SIDEBAR_MUTED_COLOR || DEFAULT_MUTED,
-  };
-}
-
-/** Read the guard's persisted snapshot for a worktree (path logic mirrors persistence.js). */
-function readSnapshot(worktree) {
-  try {
-    const fs = require("node:fs");
-    const path = require("node:path");
-    const os = require("node:os");
-    const crypto = require("node:crypto");
-    const xdg = process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.trim();
-    const base = xdg || path.join(os.homedir(), ".local", "state");
-    const key = crypto.createHash("sha256").update(String(worktree || "default")).digest("hex").slice(0, 16);
-    const file = path.join(base, "opencode", "goal-guard", `${key}.json`);
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return null;
-  }
-}
-
-/** Most-recently-touched active session, preferring an explicit active sessionId. */
-function pickSession(snapshot, sessionId) {
-  if (!snapshot || !Array.isArray(snapshot.sessions)) return null;
-  const records = snapshot.sessions
-    .filter((e) => Array.isArray(e) && e.length === 2)
-    .map(([key, st]) => [key, st && typeof st === "object" ? st : {}]);
-  if (sessionId) {
-    const direct = records.find(([key, st]) => key === sessionId && st.active);
-    if (direct) return direct[1];
-  }
-  const active = records.filter(([, st]) => st.active);
-  if (active.length === 0) return null;
-  active.sort((a, b) => (b[1].touchedAt || 0) - (a[1].touchedAt || 0));
-  return active[0][1];
-}
-
-function readModel(worktree, sessionId) {
-  try {
-    const snapshot = readSnapshot(worktree);
-    if (!snapshot) return NO_GOAL;
-    const record = pickSession(snapshot, sessionId);
-    if (!record) return NO_GOAL;
-    return sidebarView(record, DEFAULT_CONFIG);
-  } catch {
-    return NO_GOAL;
-  }
-}
-
-const id = "goal-mode-sidebar";
-
-/** @type {import("@opencode-ai/plugin/tui").TuiPlugin} */
-const tui = async (api, options) => {
-  try {
-    const { enabled, color, doneColor, muted } = resolveOptions(options, typeof process !== "undefined" ? process.env : {});
-    if (!enabled) return;
-    if (!api?.slots?.register) return; // runtime without the slot API → no-op.
-
-    const worktree = api.state?.path?.worktree || api.state?.path?.directory;
-
-    api.slots.register({
-      order: 50,
-      slots: {
-        sidebar_content(_ctx, props) {
-          const read = () => {
-            try {
-              return readModel(worktree, props?.session_id) || NO_GOAL;
-            } catch {
-              return NO_GOAL;
-            }
-          };
-          const [model, setModel] = createSignal(read());
-          const timer = setInterval(() => setModel(read()), POLL_MS);
-          onCleanup(() => clearInterval(timer));
-          const fg = () => (model().state === "done" ? doneColor : color);
-          // Always render: grey "No goal available" when none, else the goal in
-          // yellow (running) / red (done) with generated status text.
-          return (
-            <box flexDirection="column" paddingTop={1}>
-              <Show
-                when={model().state !== "none"}
-                fallback={<text fg={muted}>No goal available</text>}
-              >
-                <text fg={fg()}>
-                  {model().state === "done" ? "✓ " : "◆ "}
-                  <b>GOAL</b>
-                  {`  ${model().goal}`}
-                </text>
-                <text fg={fg()}>{model().detail}</text>
-              </Show>
-            </box>
-          );
-        },
-      },
-    });
-  } catch {
-    /* TUI runtime missing or API drift — render nothing rather than crash. */
-  }
-};
-
-export default { id, tui };