geneseed 4.0.0 → 4.2.0

package/CHANGELOG.md

@@ -8,6 +8,72 @@ label. For the capability ↔ spec map, see [SHIPPED.md](SHIPPED.md).
 
 ## [Unreleased]
 
+## [4.2.0] — 2026-10-14
+
+Minor: the web console's Overview becomes a control panel over every installed harness, rebuild, prune and uninstall keep owned files you edited, and skill and subagent calls are counted.
+
+### Upgrade notes
+- Run `geneseed rebuild-all` once after updating to wire the usage counter and record the per-file hashes that edit detection reads. An install built before 4.2.0 has no hashes, so until it is rebuilt its owned files are treated as before.
+- Run `geneseed web restart` to load the new console.
+
+### Added
+- **The Overview as a control panel.** The default Overview lists every installed harness on the machine: whether it matches its source, hand edits, its always-on cost against the root-file ceiling, its build time, and Rebuild when it is behind or edited. Below that: what needs attention, then charts of always-on cost by part, which skills and agents fire over 30 days, and gate asks per rule. Hosts with nothing installed are not listed; installing stays on the Installs page. The four older views are still in the Appearance palette. New read endpoints: `GET /api/fleet` (each install with its own sync verdict and always-on cost), `GET /api/usage`, `GET /api/gates` and `GET /api/update`.
+- **Update check.** The console shows "*x.y.z* available" with an Update button only when npm has a release newer than the running source, and "update check unavailable" when the check failed. It asks `registry.npmjs.org` at most once a day (once an hour after a failure, with a 3-second timeout). `GENESEED_NO_UPDATE_CHECK` turns it off.
+- **Usage counting.** Every Skill or subagent call appends one `{day, kind, name}` line to the install's `notebook/usage.jsonl`. It records counts only, never the prompt, arguments or paths, and adds no process and no model tokens. It is on by default. `GENESEED_NO_USAGE` or a `.usage-off` file in the install turns it off. On Claude Code and OpenClaude it is a new `Skill|Agent|Task` hook group with no `onFailure: block`, so a counter can never stop a skill. On Bob, skill detection is best-effort. Lines older than 90 days are pruned.
+
+### Changed
+- **Rebuild, prune and uninstall keep owned files you edited.** The manifest now records a hash of every owned file. A rebuild leaves an owned file you edited in place and tells you to delete it if you want Geneseed's copy back, and a prune does not remove it. Uninstall leaves it too, completes around it, and names it; `geneseed uninstall --force` deletes it anyway. The console's Remove does the same and names the files it kept. The hash ignores CRLF vs LF, so a checkout with the other OS's line endings does not count as an edit.
+- **review**: when a spec exists and the diff spans more than a few files, the spec-fidelity pass runs in its own subagent, given only the diff and the spec. The smell baseline gains message chains and refused bequest.
+- **security-audit**: a finding stands only once it is traced from an attacker-controlled source to an unguarded sink through the real callers. Until then it stays a lead. The skill also names three shortcuts that produce false positives.
+- **wayfinder**: each decision ticket has a type (research, prototype, grilling or task) that says how it gets resolved. Research tickets run in parallel when the map is charted, a ticket worked with the user resolves only in that live exchange, and a sweep that finds nothing unclear produces no map.
+- **develop** names three test anti-patterns: implementation-coupled, tautological and horizontal slicing.
+- Nine registry entities move from experimental to approved: researcher, git-history, dependencies, security-audit, worktree, token-report, explain-changes, rule and skill-forge.
+- `doctor` checks that the host matrix and the enforcement table have exactly one column per host.
+
+### Fixed
+- A prune no longer follows a manifest path outside the install. A per-repo manifest entry such as `../victim.txt` could delete a file outside the install on re-emit. Prune now applies the same containment check as uninstall.
+- An emit never writes through a symlink planted at an owned path. This covers every path an emit writes, including `rules/geneseed.md`, `.gitignore`, the OpenCode global `AGENT.md` and the version marker.
+
+### Removed
+
+- The `herdr` skill. Orca now covers multi-pane and multi-agent work, so a skill limited to a herdr pane only added to the catalogue. It joins `RETIRED_SKILL_IDS`, so an install that excluded it still rebuilds. Skills: 47 → 46.
+
+## [4.1.0] — 2026-10-13
+
+Minor: the planning, review, debugging and multi-agent skills take the lessons of Superpowers 7.0, and the host canary.
+
+### Changed
+- **brainstorm** asks which build choices (platform, language, key libraries) you want to own; one the agent makes goes in the decision list as its own call. It sizes the work: a quick task is just done, a small change keeps the confirmed list in chat as its spec, and only a project gets a spec file. A fresh subagent then reads that spec as the person who will build it and asks what they would have to guess, replacing the agent rereading its own spec.
+- **plan**: a step records decisions (files, signatures, the spec's values, the test, the check command), not code. A step is marked done only once its check has run green, with the command on the line. A decision taken without asking gets a `Ruling:` line that is reported at the end, and the mid-run "stop for review" clause is gone. The plan file names its task and its spec, and the spec wins a conflict.
+- **debug**: compare against the nearest working twin, trace a bad value back to where it was born, cite evidence as `file:line`, and probe a secret's presence, never its value. The CI branch diffs against the last green run first and replaces guessed sleeps with bounded waits.
+- **Code review**: where the spec says nothing, a crash, hang or data loss on an input it implies is still blocking. Findings end with a *Set aside* list the caller rules on, and `ship` rules on it before pushing. The base is `origin/<default branch>` after a fetch. The reviewer never moves HEAD and never dispatches another reviewer.
+- **pipeline / parallel-agents**: the developer↔tester loop gets two repair rounds, then one fresh developer, then stops (it allowed five, against `bound-the-loop`). An ambiguity is decided and recorded rather than stalling, small edits of one kind run as one unit, no dispatched agent dispatches its own, and an empty diff counts as a failure. `worktree` never forces a refused removal.
+- The `cover-and-verify` doctrine and `develop` run the whole suite once at the end and name every failure, including ones the change did not cause; per step, only the affected tests still run.
+
+### Fixed
+- The daydream skill's cost line showed a mangled price on Claude Code, which replaces a dollar sign followed by a digit with the skill's arguments.
+- On OpenCode 2, the Activity view now names each tool call. OpenCode 2 sends a tool's name only when its input starts streaming, not with the call itself, so every tool card read "undefined".
+
+### Added
+- A host canary, `node tests/host_canary.mjs`. It installs the real OpenCode 1, OpenCode 2, Claude Code and OpenClaude from npm and points each at a throwaway home holding the Geneseed install. It fails when a host refuses one of our OpenCode plugins, reports one of our Claude settings as invalid, or never runs our session-start hook. It never calls a model and needs no account. It runs in CI every Monday against the latest releases and on every pull request that changes what Geneseed installs, so the next host release that breaks the contract is caught within a week rather than by a user. IBM Bob is not covered, because Bob Shell is not published on npm.
+
+## [4.0.2] — 2026-10-12
+
+Patch: none of the OpenCode plugins loaded on OpenCode 2, and MCP is read-only.
+
+### Fixed
+- The seven OpenCode plugins now load on OpenCode 2. OpenCode 2 rewrote the plugin API and refused every Geneseed plugin with *"Plugin must export a default definition with an id and an effect or setup function"*. It skipped them without crashing, so the context load, learn, notify, ponytail, activity and the `workflow` tool were all gone, and the guard's safety gates were silently off. Each plugin now carries both APIs in one file and works on OpenCode 1.3.4 or newer and on OpenCode 2. Plugins no longer load on OpenCode older than 1.3.4. On OpenCode 2 a guard block shows up as a failed tool call that gives the reason, and the Activity view shows no todo list or files-touched count, because OpenCode 2 sends no event for either. Run `geneseed rebuild-all` after updating to install the new plugin files.
+
+### Changed
+- MCP is read-only in the web console and in `geneseed mcp`. Each active install lists only the servers its config already holds, enabled or disabled, with its config path and an **Open folder** button. The **Add** button, the on/off switch and the three built-in presets are gone. Which servers to wire depends on you and on your host, so you edit the config yourself; [MCP servers](docs/guides/mcp.md) still has the blocks for MarkItDown, GitLab and Filesystem. Geneseed no longer writes any MCP config, and the `POST /api/mcp` endpoint is removed.
+
+## [4.0.1] — 2026-10-12
+
+Patch: the web console could not tell apart two project installs of the same host (#244).
+
+### Fixed
+- Two project installs of one host (two repos on Bob, say) are now separate rows in the web console. Both used to get the id `bob:project`, so the Installs table showed both as selected and the topbar harness selector always switched back to the first. The id now carries the install root, and the selector names a project install by its folder. All four hosts had the bug and all four are covered by a test. Nothing is re-emitted; run `geneseed web restart` after updating.
+
 ## [4.0.0] — 2026-10-11
 
 Major: a host-compatibility pass against the current IBM Bob, Claude Code, OpenCode and OpenClaude docs (#240), the host opportunities and a root-scan guard (#241), and author notes kept out of what the agent reads (#242). It is a major because three behaviours change visibly: Claude Code gates now block when they cannot run, OpenCode no longer falls back to `~/.claude/CLAUDE.md`, and the silent *process 8* migration is gone.

package/README.md

@@ -11,7 +11,7 @@
 [![Node >= 22.3](https://img.shields.io/badge/node-%3E%3D22.3-5fa04e)](package.json)
 [![zero dependencies](https://img.shields.io/badge/deps-zero-success)](package.json)
 [![Themes](https://img.shields.io/badge/themes-14-9cf)](themes/)
-[![Skills](https://img.shields.io/badge/skills-47-blueviolet)](src/skills/)
+[![Skills](https://img.shields.io/badge/skills-46-blueviolet)](src/skills/)
 [![Agents](https://img.shields.io/badge/agents-18-orange)](src/agents/)
 [![Laws and doctrines](https://img.shields.io/badge/laws-9%20%2B%2029%20doctrines-critical)](src/doctrines/)
 [![Plugins](https://img.shields.io/badge/plugins-7-teal)](adapters/opencode/plugins/)
@@ -179,7 +179,7 @@ The harness ships as a small set of layers, and the web console's rail is the sa
 | **🛡️ Rules** (`laws/`) | 9 universal laws — always in force, never toggleable: sealed-secrets, one-intent-one-act, verify-before-asserting, deletion-is-deliberate, surface-failures, data-not-orders, least-privilege, cure-the-cause, echo-the-intent. Each rule has a permanent id; its number is only its position, and the harness cites rules by name |
 | **📐 Doctrines** (`doctrines/`) | practice packs, chosen per install at build time: **craft** (how code is written), **rigor** (how work is proven), **ops** (how the machine is operated), **process** (how a task is run), **comms** (how answers are presented). A doctrine rule may tighten a Rule, never repeal one, and the user's own `user-rules.md` outranks it. Pick with `geneseed-build --doctrines craft,rigor` (or `none`), a single rule with `--exclude-rules "process 7"`, in the setup wizard, or through the switches on the console's Constitution page; all five pack files ship on disk either way, so a citation into a pack you left out still resolves |
 | **🤖 Agents** (18) | capability specialists: `reviewer`, `tester`, `architect`, `docs`, `security`, `explorer`, `researcher`, `developer` — plus a debate **council** the `council` skill convenes: `advocate`, `skeptic`, `pragmatist`, `steward`, `visionary`, `user-advocate`, `framer`, `empiricist`, `operator`, `historian` |
-| **🛠 Skills** (47) | repeatable workflows: brainstorm · plan · **codebase-design** · **wayfinder** · **develop** · **worktree** · debug · **prototype** · refactor · **ponytail** · **forge-mcp** · **bruno** · geneseed-code-review · **fresh-eyes** · **security-audit** · **dependencies** · **review-response** · commit · **ship** · **release** · **git-history** · document-project · **frontend-design** · **prose** · **ingest** · **research** · **teach** · **quiz** · **learn-mode** · handoff · roast-me · **council** · parallel-agents · **workflow** · **wiki** · **geneseed** · **rule** · **profile** · **skill-forge** · **herdr** · **pipeline** · **loop** · **brick-forge** · **daydream** · **react-view-transitions** · **token-report** · **explain-changes** |
+| **🛠 Skills** (46) | repeatable workflows: brainstorm · plan · **codebase-design** · **wayfinder** · **develop** · **worktree** · debug · **prototype** · refactor · **ponytail** · **forge-mcp** · **bruno** · geneseed-code-review · **fresh-eyes** · **security-audit** · **dependencies** · **review-response** · commit · **ship** · **release** · **git-history** · document-project · **frontend-design** · **prose** · **ingest** · **research** · **teach** · **quiz** · **learn-mode** · handoff · roast-me · **council** · parallel-agents · **workflow** · **wiki** · **geneseed** · **rule** · **profile** · **skill-forge** · **pipeline** · **loop** · **brick-forge** · **daydream** · **react-view-transitions** · **token-report** · **explain-changes** |
 | **🔌 Plugins** (OpenCode) | `geneseed-context` injects project docs *and your machine wiki* every session (and across compaction); `geneseed-learn` distils memory at session end; `geneseed-guard` enforces the safety Laws and protected wiki folders at the tool boundary; `geneseed-workflow` registers the `workflow` tool that runs saved orchestration scripts; `geneseed-notify` sends a native OS notification when a long run finishes; `geneseed-ponytail` holds a minimal-code mode (`/ponytail lite\|full\|ultra\|off`), opt-in, injecting the laziest-that-works ruleset every turn so it doesn't drift; `geneseed-activity` streams what each session is doing to the web console's Activity view |
 | **🧠 Memory** (`memory/`) | one-fact-per-file durable knowledge, indexed by `MEMORY.md` (git-ignored, personal) |
 | **📓 Notebook** (`notebook/`) | the agent's sovereign space — any medium (code, tools, data, notes), self-ruled via a seed-once charter, always git-ignored; only its `.gitignore` is build-asserted |

package/SHIPPED.md

@@ -20,7 +20,7 @@ historical references, not files distributed with the repo.
 > **On version numbers.** [`harness.config.json`](harness.config.json)'s `version` is a
 > human-readable label only. The canonical identity of an installed harness is the
 > **source fingerprint** stamped in `.geneseed-version` (see `geneseed version`), not the
-> string. Current label: **4.0.0**.
+> string. Current label: **4.2.0**.
 
 ## Capabilities
 
@@ -29,7 +29,7 @@ Every row below is present in the tree today; "Spec" names the design record.
 | Capability | What it is | Spec |
 | --- | --- | --- |
 | **Themed generator** | One neutral `src/` → 14 themed bundles via `geneseed-build` (zero dependencies); structure stays theme-independent | [DESIGN.md](DESIGN.md) |
-| **Laws / Agents / Skills / Memory / Notebook** | 9 laws, 18 agents, 47 skills, the memory convention, and the agent's sovereign notebook | `2026-06-11-notebook-sovereign-space` · `2026-06-10-notebook-agent-own-space` |
+| **Laws / Agents / Skills / Memory / Notebook** | 9 laws, 18 agents, 46 skills, the memory convention, and the agent's sovereign notebook | `2026-06-11-notebook-sovereign-space` · `2026-06-10-notebook-agent-own-space` |
 | **Three-tier constitution** | The governance surface splits into an always-on **Ontology** (Telos, Evidence, Decisions, Conduct — the Pact absorbed into Telos), the nine always-on **Invariants**, and five toggleable **Doctrine** packs (craft, rigor, ops, process, comms) addressed `<pack> <n>`. Every rule carries a permanent id; its number is its position, computed at render time, and a citation renders as the rule's principle name. Packs are chosen at build time with `--doctrines` or the setup wizard; the whole catalogue ships on disk either way, so a citation into an inactive pack still resolves. Precedence, in order: Ontology + Invariants, then the user's `user-rules.md`, then the active Doctrines, then `PROFILE.md`. `doctor`'s `constitutionProblems` gates rule ids (declared, unique, never a retired one), the per-rule Principle column, every `{{LAW:<id>}}` / `{{DOCTRINE:<id>}}` citation in `src/`, and the rule that an always-on tier may never cite a toggleable one | `2026-08-19-three-tier-constitution-design` |
 | **`doctor`** | One check: unresolved tokens, dead/non-hermetic links, theme-key parity, authoring gates, rendered-bundle drift | `2026-06-07-theme-aware-doctor-diff` |
 | **`diff` + improvements export** | Deployed-vs-source drift report; export an `improvements.md` back-port | `2026-06-12-improvements-export` |
@@ -44,7 +44,7 @@ Every row below is present in the tree today; "Spec" names the design record.
 | **Collaboration layer** | Negotiated postures (peer/mentor/expert/assistant/artisan, chosen at setup, inlined in AGENT.md), the bidirectional Pact, epistemically-typed memory (`force:` + Bridge rule), and a seed-once `PROFILE.md` identity with a web editor tab and a `profile` skill that interviews the user to draft it | `2026-07-12-collaboration-layer` |
 | **Rule front door** | Both durable stores enter through the `rule` skill's fork (*standing rule, or fact to remember?* — always asked, never inferred): the memory branch elicits the binding `force` and shows the file before writing, the rule branch pressure-tests by reformulation and a mandatory counter-example. Doctrine process 1 carries the norm on every host; a `rule-gate` PreToolUse hook (Claude, Bob) and a `geneseed-guard` speed bump (OpenCode) hold it at the tool boundary | `2026-07-30-rule-front-door` |
 | **Entity registry** | `registry.json` records a lifecycle status, version, owner and add-date for every agent and skill in the tree (maintainer-side — never rendered into a bundle, so it costs no session context). `doctor` gates it against `src/` in both directions, sweeps everything that ships for credentials, and holds each vendored skill folder to an immutable upstream commit. The status surfaces as a badge in the web catalog, shown only where it deviates from `approved` | `2026-07-31-entity-registry` |
-| **Node runtime + npm package** | The whole harness runs from Node: every command `js/cli-table.json` declares, all five hook verbs, every web-console endpoint (the OS-native folder picker excepted, and declined on purpose) and both generators. Every commit runs the unit suite, `doctor --all` across every theme × host × footprint, and the generator's two self-comparisons, on Linux and Windows both; the frozen emit/cli/web recordings that also gated it retired on 2026-08-17 (see the 2.0.0 entry in [CHANGELOG.md](CHANGELOG.md)). It ships as the zero-dependency `geneseed` package (`geneseed`, `geneseed-hook`, `geneseed-build`), so `npx geneseed setup` needs no clone and nothing else installed; `geneseed migrate` moves an existing checkout install across. Node is the only runtime it asks for: the `token-report` skill's own script is `token_report.mjs`, gated over seeded transcripts for all four hosts, and `daydream` and `herdr` call `node -e` | `2026-08-06-npx-distribution` |
+| **Node runtime + npm package** | The whole harness runs from Node: every command `js/cli-table.json` declares, all five hook verbs, every web-console endpoint (the OS-native folder picker excepted, and declined on purpose) and both generators. Every commit runs the unit suite, `doctor --all` across every theme × host × footprint, and the generator's two self-comparisons, on Linux and Windows both; the frozen emit/cli/web recordings that also gated it retired on 2026-08-17 (see the 2.0.0 entry in [CHANGELOG.md](CHANGELOG.md)). It ships as the zero-dependency `geneseed` package (`geneseed`, `geneseed-hook`, `geneseed-build`), so `npx geneseed setup` needs no clone and nothing else installed; `geneseed migrate` moves an existing checkout install across. Node is the only runtime it asks for: the `token-report` skill's own script is `token_report.mjs`, gated over seeded transcripts for all four hosts, and `daydream` calls `node -e` | `2026-08-06-npx-distribution` |
 | **Runtime awareness** | MCP discovery, web research, tool-call batching, review discipline — carried by the doctrine packs (`ops 1` tool discovery, `process 4` read the docs first, `rigor 2`/`rigor 3` honest tests and cover-and-verify), not by the invariants | `2026-06-07-runtime-awareness-and-review-discipline` |
 | **Run from anywhere / uninstall** | `link`/`unlink` onto PATH; global uninstall that keeps the memory store | `2026-06-07-version-and-uninstall` |
 

package/adapters/claude-code/README.md

@@ -92,27 +92,6 @@ hooks or plugins, the AGENT.md prose still carries the rule.
 > plugin. A `context.json` still overrides, and `"extend": true` layers a manifest
 > on top of discovery.
 
-## Bundled skill — `herdr`
-
-The canonical herdr skill lives in the Geneseed source tree at
-[`src/skills/herdr.md`](../../src/skills/herdr.md). The build renders it into
-every emit — `.opencode/skills/herdr/SKILL.md` for OpenCode hosts, the
-portable bundle for everyone else — so a deployed harness picks it up
-automatically alongside every other Geneseed skill.
-
-A copy is also kept at
-[`.claude/skills/herdr/SKILL.md`](../../.claude/skills/herdr/SKILL.md) so Claude
-Code running **inside this repo** (i.e. people working on Geneseed itself)
-discovers it directly, since the build doesn't write into `.claude/`. The two
-copies share content; keep them in sync when you edit either.
-
-Either way, you only need:
-
-- the **`herdr` binary** on your `PATH` (install via [herdr.dev](https://herdr.dev)),
-- the agent launched **inside a herdr pane** — the skill self-gates on
-  `HERDR_ENV=1` and stays silent everywhere else, so shipping it is harmless
-  for users who don't run herdr.
-
 ## Other tools
 
 This adapter is Claude-Code-specific. On tools without hooks, the harness still

package/adapters/opencode/HOW-OPENCODE-LOADS.md

@@ -64,6 +64,41 @@ export const MyPlugin = async ({ client, $, directory, worktree }) => ({
   **without** triggering a reply with `client.session.prompt({ path, body: { noReply: true, parts } })`.
 - **`$`** — a shell executor for running commands.
 
+### OpenCode 2 — a different plugin API
+
+OpenCode 2 (the `@opencode/cli` package; V1 is still `opencode-ai`) still auto-loads every
+`.js`/`.ts` in `plugins/` (or `plugin/`), but it accepts **only** a default-exported
+definition: `export default { id, setup(ctx) }`. A V1 plugin fails to load with *"Plugin
+must export a default definition with an id and an effect or setup function"*. Each one
+is marked failed on its own and OpenCode carries on, so nothing warns you.
+
+V1 (>= 1.3.4) also accepts an object default, `{ id, server }`, and each loader ignores
+the other's key. So every Geneseed plugin exports **one object for both majors**:
+`export default { id: "<file stem>", server: <V1 factory>, setup: <V2 setup> }`. On V1
+older than 1.3.4 the plugins no longer load.
+
+`setup(ctx)` gets domains instead of hooks returned in a map. Hooks register by name
+(`ctx.tool.hook("execute.before")`, `ctx.session.hook("context" | "prompt" |
+"compaction")`), tools through `ctx.tool.transform`, and events come from
+`ctx.event.subscribe()` as `{ type, created, data }` (not `{ type, properties }`). What
+changed for each plugin:
+
+| V1 | V2 |
+| --- | --- |
+| `session.idle` | not published by core (deprecated). The turn ends with `session.execution.succeeded` / `failed` / `interrupted` |
+| `experimental.chat.messages.transform` / `chat.system.transform` | `session.hook("context")`: mutable `system` parts and `LLM.Message` instances, on every request |
+| `command.execute.before` | none. A markdown command's expanded template arrives through `session.hook("prompt")` |
+| `client.session.messages` | `ctx.session.context({ sessionID })`: `user` / `assistant` messages after the last compaction |
+| throwaway session + `prompt` to distil | `ctx.generate.text({ prompt, model })`: one stateless call |
+| a hook throws to block a tool | a throw is a **defect that fails the whole step**. The guard renames the call instead (see `geneseed-guard.js`) |
+| `@opencode-ai/plugin` `tool()` helper | `@opencode/plugin`; a plain JSON-schema `input` needs no helper |
+| `todo.updated`, session `summary` diffs | no V2 event. The activity cards show no todos or files on V2 |
+| tool part carries its name | `session.tool.called` has no name; it rides on `session.tool.input.started` |
+| tools `bash`, `apply_patch`, `task` | renamed `shell`, `patch`, `subagent` (the old ids are aliases). The guard's substring classes cover both spellings |
+
+None of this is checked by a mock alone: `node tests/host_canary.mjs` starts the real V1 and V2
+and fails on the host's own `failed to load plugin` log line.
+
 ## 4. Subagents, skills & commands
 
 Subdir names are **plural** canonically (`agents/`, `skills/`, `commands/`,

package/adapters/opencode/plugins/geneseed-activity.js

@@ -425,6 +425,109 @@ export const GeneseedActivity = async () => {
 
 // ponytail: OpenCode treats every export as a plugin and rejects non-functions; hang
 // the test helpers off the factory instead — reachable via import, invisible to the loader.
-Object.assign(GeneseedActivity, { sidOf, nextStatus, applyEvent, acctTotals, errStr, snip, safeName, activityDir, enabledFromFlag })
+Object.assign(GeneseedActivity, { sidOf, nextStatus, applyEvent, acctTotals, errStr, snip, safeName, activityDir, enabledFromFlag, toV1Events })
 
-export default GeneseedActivity
+// --- OpenCode 2 --------------------------------------------------------------
+// `export default { id, server, setup }` serves V1 (>= 1.3.4) and V2 from one file — why, and
+// each V1 hook's V2 counterpart: adapters/opencode/HOW-OPENCODE-LOADS.md.
+//
+// V2's event stream is a different vocabulary (`{ type, created, data }`, the turn as an
+// execution, a message as steps, tool calls as called/success/failed), but every fact the
+// cards show is still in it. Rather than a second reducer, `toV1Events` translates each
+// V2 event into the V1 event(s) the handler above already reduces, so both majors write
+// the same files. Not carried: todos (V2 publishes no todo event) and files-touched (the
+// V1 session summary has no V2 event).
+
+// A V2 SessionError ({ type, message }) in the V1 error union errStr reads.
+const v1Error = (e) => (e ? { name: e.type, data: { message: e.message || e.type } } : undefined)
+
+// V2 event -> the V1 events it means ([] for one the cards ignore). `tools` remembers each
+// running call's name and start (callID -> { name, start }) so its end can say both.
+// Pure but for `tools`; exported for tests.
+function toV1Events(ev, tools) {
+  const d = ev?.data ?? {}
+  const sessionID = d.sessionID
+  if (!sessionID) return []
+  const t = typeof ev.created === "number" ? ev.created : Date.now()
+  const msg = (info) => ({ type: "message.updated", properties: { info: { role: "assistant", sessionID, ...info } } })
+  const part = (p) => ({ type: "message.part.updated", properties: { part: { sessionID, ...p } } })
+  switch (ev.type) {
+    case "session.created":
+      return [{ type: "session.created", properties: { info: {
+        id: sessionID, title: d.title, parentID: d.parentID, directory: d.location?.directory } } }]
+    case "session.renamed":
+      return [{ type: "session.updated", properties: { info: { id: sessionID, title: d.title } } }]
+    case "session.deleted":
+      return [{ type: "session.deleted", properties: { sessionID } }]
+    case "session.execution.started":
+      return [{ type: "session.status", properties: { sessionID, status: { type: "busy" } } }]
+    case "session.execution.succeeded":
+      return [{ type: "session.idle", properties: { sessionID } }]
+    case "session.execution.failed":
+      return [{ type: "session.error", properties: { sessionID, error: v1Error(d.error) } },
+        { type: "session.idle", properties: { sessionID } }]
+    case "session.execution.interrupted":
+      return [{ type: "session.status", properties: { sessionID, status: { type: "idle" } } }]
+    case "session.retry.scheduled":
+      return [{ type: "session.status", properties: { sessionID, status: { type: "retry" } } }]
+    case "session.step.started":
+      return [msg({ id: d.assistantMessageID, mode: d.agent, modelID: d.model?.id, time: { created: t } })]
+    case "session.step.ended":
+      return [msg({ id: d.assistantMessageID, cost: d.cost, tokens: d.tokens, time: { completed: t } })]
+    case "session.step.failed":
+      return [msg({ id: d.assistantMessageID, cost: d.cost, tokens: d.tokens, error: v1Error(d.error), time: { completed: t } })]
+    // The name rides only on `input.started`; `called` carries the input but no name.
+    case "session.tool.input.started":
+      tools.set(d.id, { name: d.name, start: undefined })
+      return []
+    case "session.tool.called": {
+      const name = tools.get(d.id)?.name ?? "tool"
+      tools.set(d.id, { name, start: t })
+      return [part({ type: "tool", callID: d.id, tool: name, messageID: d.assistantMessageID,
+        state: { status: "running", title: name, time: { start: t } } })]
+    }
+    case "session.tool.success":
+    case "session.tool.failed": {
+      const call = tools.get(d.id) ?? { name: "tool", start: undefined }
+      tools.delete(d.id)
+      const failed = ev.type === "session.tool.failed"
+      return [part({ type: "tool", callID: d.id, tool: call.name, messageID: d.assistantMessageID,
+        state: { status: failed ? "error" : "completed", title: call.name,
+          error: failed ? d.error?.message || d.error?.type : undefined, time: { start: call.start, end: t } } })]
+    }
+    case "session.reasoning.started":
+    case "session.reasoning.ended":
+      return [part({ type: "reasoning", id: `r:${d.assistantMessageID}:${d.ordinal}`, text: d.text ?? "" })]
+    case "session.text.ended":
+      return [part({ type: "text", id: `t:${d.assistantMessageID}:${d.ordinal}`, messageID: d.assistantMessageID, text: d.text })]
+    case "permission.asked":
+      return [{ type: "permission.updated", properties: { sessionID, id: d.id, title: d.message || d.action } }]
+    case "permission.replied":
+      return [{ type: "permission.replied", properties: { sessionID, permissionID: d.requestID } }]
+    default:
+      return []
+  }
+}
+
+async function setupV2(ctx) {
+  const hooks = await GeneseedActivity()
+  const tools = new Map()
+  // The user's prompt, as V1's chat.message hook received it.
+  await ctx.session.hook("prompt", async (event) => {
+    try {
+      await hooks["chat.message"]({ sessionID: event?.sessionID, messageID: event?.messageID },
+        { parts: [{ type: "text", text: event?.prompt?.text }] })
+    } catch (err) { log(`prompt hook failed: ${err?.message ?? err}`) }
+  })
+  const controller = new AbortController()
+  void (async () => {
+    for await (const ev of ctx.event.subscribe({ signal: controller.signal })) {
+      for (const event of toV1Events(ev, tools)) {
+        try { await hooks.event({ event }) } catch (err) { log(`event ${event.type} failed: ${err?.message ?? err}`) }
+      }
+    }
+  })().catch((err) => log(`event stream ended: ${err?.message ?? err}`))
+  return () => controller.abort()
+}
+
+export default { id: "geneseed-activity", server: GeneseedActivity, setup: setupV2 }

package/adapters/opencode/plugins/geneseed-context.js

@@ -989,4 +989,99 @@ export const GeneseedContext = async (ctx) => {
   }
 }
 
-export default GeneseedContext
+// ---- OpenCode 2 ----------------------------------------------------------------
+// `export default { id, server, setup }` serves V1 (>= 1.3.4) and V2 from one file — why, and
+// each V1 hook's V2 counterpart: adapters/opencode/HOW-OPENCODE-LOADS.md.
+//
+// V2 has no `messages.transform`: `session.hook("context")` is its stable per-request
+// equivalent (the outgoing system + messages, mutable), so the invisible delivery needs
+// no fallback detection there. Messages are `LLM.Message` class instances, not V1's
+// `{info, parts}`. A V2 hook that throws is a defect that fails the whole request,
+// so every callback below swallows its own errors.
+
+// Build a user message the request will accept: reuse the class of a message already in
+// it (LLM.Message validates on construction), else a plain object of the same shape.
+function v2UserMessage(messages, text) {
+  const content = [{ type: "text", text }]
+  const Ctor = messages.find((m) => m && m.constructor && m.constructor !== Object)?.constructor
+  if (Ctor) { try { return new Ctor({ role: "user", content }) } catch {} }
+  return { role: "user", content }
+}
+const v2HasMarker = (messages) => messages.some((m) =>
+  (m?.content ?? []).some((p) => typeof p?.text === "string" && p.text.includes(MARKER)))
+const v2Model = (ref) => (ref?.providerID && ref?.id ? `${ref.providerID}/${ref.id}` : null)
+
+async function setupV2(ctx) {
+  const root = repoRoot({ worktree: ctx?.location?.project?.directory, directory: ctx?.location?.directory })
+  const blockCache = { text: null, at: 0 }
+  // Same scope rule as V1's skipSession: child/subagent sessions inherit the parent's
+  // context, geneseed-* sessions stay clean. A failed lookup is not cached.
+  const sessionSkip = new Map()
+  async function skipSession(sid) {
+    if (!sid) return false
+    const hit = sessionSkip.get(sid)
+    if (hit !== undefined) return hit
+    try {
+      const info = await ctx.session.get({ sessionID: sid })
+      const skip = Boolean(info?.parentID) || String(info?.title ?? "").startsWith("geneseed-")
+      sessionSkip.set(sid, skip)
+      return skip
+    } catch {
+      return false
+    }
+  }
+
+  if (!VISIBLE) {
+    await ctx.session.hook("context", async (event) => {
+      if (INJECT_OFF) return
+      try {
+        if (await sovereignBypass(root)) return
+        if (!Array.isArray(event?.messages) || v2HasMarker(event.messages)) return
+        if (await skipSession(event.sessionID)) return
+        const cached = await cachedBlockText(root, blockCache)
+        if (!cached) return
+        event.messages.unshift(v2UserMessage(event.messages, withModel(cached, v2Model(event.model) || envModelStr())))
+        log("context hook: injected context invisibly")
+      } catch (err) {
+        log(`context hook error: ${err?.message ?? err}`)
+      }
+    })
+    return
+  }
+
+  // Visible delivery (GENESEED_CONTEXT_VISIBLE): one synthetic message when a session is
+  // created, re-pushed into the compaction request so it outlives the summary.
+  await ctx.session.hook("compaction", async (event) => {
+    if (INJECT_OFF) return
+    try {
+      if (await sovereignBypass(root)) return
+      if (!Array.isArray(event?.messages) || await skipSession(event.sessionID)) return
+      const { block } = await resolveBlock(root)
+      if (block) event.messages.unshift(v2UserMessage(event.messages, block.text))
+    } catch (err) {
+      log(`compaction error: ${err?.message ?? err}`)
+    }
+  })
+  const controller = new AbortController()
+  void (async () => {
+    for await (const ev of ctx.event.subscribe({ signal: controller.signal })) {
+      if (ev?.type !== "session.created" || INJECT_OFF) continue
+      const d = ev.data ?? {}
+      try {
+        if (d.parentID || String(d.title ?? "").startsWith("geneseed-")) continue
+        if (await sovereignBypass(root)) continue
+        const { block } = await resolveBlock(root)
+        if (!block) continue
+        await ctx.session.synthetic({
+          sessionID: d.sessionID, text: withModel(block.text, v2Model(d.model) || envModelStr()),
+          description: "Geneseed project context", resume: false,
+        })
+      } catch (err) {
+        log(`visible injection error: ${err?.message ?? err}`)
+      }
+    }
+  })().catch((err) => log(`event stream ended: ${err?.message ?? err}`))
+  return () => controller.abort()
+}
+
+export default { id: "geneseed-context", server: GeneseedContext, setup: setupV2 }

package/adapters/opencode/plugins/geneseed-guard.js

@@ -546,11 +546,42 @@ function protectedCheck(p) {
 // substring stance: over-matching the class is harmless (see WRITE_TOOLS note).
 const WIKI_MUTATE_TOOLS = [...WRITE_TOOLS, "delete", "remove", "rename", "move", "trash"]
 
+// Usage counting: the same rules as js/hosts/usage.mjs, inline because a plugin cannot import
+// from the repo (V2 loads every .js in plugins/ as a plugin). One line per skill or subagent
+// call, the day and the name only, under <cfg>/notebook/usage.jsonl. Silent and never throws:
+// a counter must not change, slow or fail a tool call. tests/unit/usage.test.mjs holds this
+// copy and the hook's to one table.
+const USAGE_NAME_RE = /^[A-Za-z0-9][\w.:@/-]{0,99}$/
+function usageOf(tool, args) {
+  const t = String(tool || "").toLowerCase()
+  const a = args || {}
+  let kind = null
+  let name = null
+  if (!t.startsWith("mcp") && t.includes("skill")) { kind = "skill"; name = a.skill ?? a.name ?? a.skill_name }
+  else if (t === "agent" || t === "task") { kind = "agent"; name = a.subagent_type ?? a.agent }
+  if (!kind || typeof name !== "string") return null
+  name = name.trim().replace(/^\/+/, "")
+  return USAGE_NAME_RE.test(name) ? { kind, name } : null
+}
+async function recordUse(tool, args) {
+  try {
+    if (process.env.GENESEED_NO_USAGE) return
+    const use = usageOf(tool, args)
+    if (!use) return
+    const cfg = path.dirname(PLUGIN_DIR)
+    if (existsSync(path.join(cfg, ".usage-off"))) return
+    if (!(await isDir(path.join(cfg, "notebook")))) return
+    await fs.appendFile(path.join(cfg, "notebook", "usage.jsonl"),
+      `${JSON.stringify({ ts: new Date().toISOString().slice(0, 10), ...use })}\n`)
+  } catch { /* a counter never fails a tool call */ }
+}
+
 export const GeneseedGuard = async (ctx) => {
   // The session's working directory, the same resolution the context plugin uses.
   const root = () => ctx?.worktree || ctx?.directory || process.cwd()
   return {
     "tool.execute.before": async (input, output) => {
+      await recordUse(input?.tool || input?.name, output?.args || input?.args)
       if (OFF) return
       if (await sovereignBypass(root())) return
       const tool = (input?.tool || input?.name || "").toLowerCase()
@@ -633,4 +664,36 @@ export const GeneseedGuard = async (ctx) => {
   }
 }
 
-export default GeneseedGuard
+// ---- OpenCode 2 ----------------------------------------------------------------
+// `export default { id, server, setup }` serves V1 (>= 1.3.4) and V2 from one file — why, and
+// each V1 hook's V2 counterpart: adapters/opencode/HOW-OPENCODE-LOADS.md.
+//
+// V2 runs the same gates through `tool.hook("execute.before")`, but cannot block the
+// V1 way: a V2 hook that throws is a defect, which fails the whole agent step instead
+// of the one call (only a `Tool.Error` settles a call cleanly, and a hook cannot raise
+// one). So a deny RENAMES the call: core then finds no tool by that name and settles it
+// with a `Tool.Error` whose text carries the reason — the call never runs, the model sees
+// why, the session continues. The input is emptied as well, for code mode, which runs the
+// original tool whatever the event's name says; every tool this guard gates requires
+// arguments, so `{}` fails validation there before anything executes.
+//
+// `permission.evaluate` (V2's deny hook) was not used: it sees only the action and a
+// resource list (the shell tool's is per sub-command), not the full input the content
+// scan and the patch-path gates need.
+async function setupV2(ctx) {
+  const hooks = await GeneseedGuard({
+    worktree: ctx?.location?.project?.directory, directory: ctx?.location?.directory,
+  })
+  await ctx.tool.hook("execute.before", async (event) => {
+    try {
+      await hooks["tool.execute.before"]({ tool: event.tool }, { args: event.input })
+    } catch (err) {
+      const why = String(err?.message || "")
+      if (!why.startsWith("[geneseed-guard]")) return
+      event.tool = why
+      event.input = {}
+    }
+  })
+}
+
+export default { id: "geneseed-guard", server: GeneseedGuard, setup: setupV2 }