geneseed 4.0.0 → 4.1.0

package/CHANGELOG.md

@@ -8,6 +8,42 @@ label. For the capability ↔ spec map, see [SHIPPED.md](SHIPPED.md).
 
 ## [Unreleased]
 
+## [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/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.1.0**.
 
 ## Capabilities
 

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

@@ -633,4 +633,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 }

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

@@ -301,6 +301,23 @@ async function writeMemories(output, memDir, existing) {
   return written
 }
 
+// The distil's reply into the store: a child session's one agent lesson, else memory
+// files plus their MEMORY.md lines. Shared by the V1 and V2 runs.
+async function storeDistil(output, { isChild, memDir, agentName, existing }) {
+  if (!output.trim() || output.trim().toUpperCase() === "NOTHING") return
+  if (isChild) {
+    const lesson = output.trim().split("\n")[0].replace(/^[-*]\s*/, "").trim()
+    if (lesson.length < 10 || lesson.length > 300) return // junk / truncation guard
+    const f = await appendAgentLesson(memDir, agentName, lesson)
+    console.error(`[geneseed-learn] agent lesson -> ${f}`)
+    return
+  }
+  const written = await writeMemories(output, memDir, existing)
+  if (written.length) {
+    console.error(`[geneseed-learn] wrote ${written.length} memory file(s): ${written.join(", ")}`)
+  }
+}
+
 export const GeneseedLearn = async (ctx) => {
   const { client } = ctx ?? {}
   const ours = new Set()       // throwaway distil sessions — never mine our own output
@@ -376,18 +393,7 @@ export const GeneseedLearn = async (ctx) => {
         if (newId) await client.session.delete({ path: { id: newId } }).catch(() => {})
       }
 
-      if (!output.trim() || output.trim().toUpperCase() === "NOTHING") return
-      if (isChild) {
-        const lesson = output.trim().split("\n")[0].replace(/^[-*]\s*/, "").trim()
-        if (lesson.length < 10 || lesson.length > 300) return // junk / truncation guard
-        const f = await appendAgentLesson(memDir, agentName, lesson)
-        console.error(`[geneseed-learn] agent lesson -> ${f}`)
-        return
-      }
-      const written = await writeMemories(output, memDir, existing)
-      if (written.length) {
-        console.error(`[geneseed-learn] wrote ${written.length} memory file(s): ${written.join(", ")}`)
-      }
+      await storeDistil(output, { isChild, memDir, agentName, existing })
     } catch (err) {
       // Never break the session over a memory write.
       console.error(`[geneseed-learn] skipped: ${err?.message ?? err}`)
@@ -426,6 +432,113 @@ export const GeneseedLearn = async (ctx) => {
 
 // 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(GeneseedLearn, { writeMemories, resolveAgentName, appendAgentLesson })
+Object.assign(GeneseedLearn, { writeMemories, resolveAgentName, appendAgentLesson, flattenV2 })
+
+// ---- 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.
+//
+// What differs on V2:
+//   - The debounce re-arms on `session.execution.succeeded`: V2 core never publishes
+//     `session.idle` (deprecated in its schema), and the execution pair is its turn
+//     boundary. Events are `{ type, data }`, not `{ type, properties }`.
+//   - The transcript is `session.context()` — the messages after the last compaction —
+//     typed `user` (text) / `assistant` (content parts, `model: { providerID, id }`).
+//   - The distil is one stateless `generate.text({ prompt, model })` call with the
+//     session's own model: no throwaway session to create, guard against and delete.
+function flattenV2(messages) {
+  const lines = []
+  let model = null
+  for (const m of messages || []) {
+    if (m?.type === "user") {
+      const text = String(m.text ?? "").trim()
+      if (text) lines.push(`user: ${text}`)
+    } else if (m?.type === "assistant") {
+      const text = (m.content || [])
+        .filter((p) => p?.type === "text" && typeof p.text === "string")
+        .map((p) => p.text).join("\n").trim()
+      if (text) lines.push(`assistant: ${text}`)
+      if (m.model?.providerID && m.model?.id) model = m.model
+    }
+  }
+  return { notes: lines.join("\n\n"), model }
+}
+
+async function setupV2(ctx) {
+  const root = ctx?.location?.project?.directory || ctx?.location?.directory || process.cwd()
+  const timers = new Map()
+  const inFlight = new Set()
+  let warnedNoDir = false
+
+  async function runDistill(sid) {
+    if (await sovereignBypass(root)) return
+    if (inFlight.has(sid)) return
+    inFlight.add(sid)
+    try {
+      const meta = await ctx.session.get({ sessionID: sid }).catch(() => null)
+      if (String(meta?.title ?? "").startsWith("geneseed-")) return
+      const isChild = !!meta?.parentID
+      const agentName = isChild ? resolveAgentName(meta) : null
+      if (isChild && !agentName) return
+
+      const memDir = await resolveMemoryDir()
+      if (!memDir) {
+        if (!warnedNoDir) {
+          warnedNoDir = true
+          console.error("[geneseed-learn] no memory dir — set $GENESEED_HARNESS or $GENESEED_MEMORY.")
+        }
+        return
+      }
+
+      let { notes, model } = flattenV2(await ctx.session.context({ sessionID: sid }))
+      if (notes.length < MIN_NOTES_CHARS) return
+      notes = notes.slice(-MAX_NOTES_CHARS)
+      if (!model) {
+        const env = envModel()
+        model = env ? { providerID: env.providerID, id: env.modelID } : null
+      }
+      if (!model) {
+        console.error("[geneseed-learn] could not determine a model — set $GENESEED_MODEL=provider/model.")
+        return
+      }
+
+      const existing = await existingSlugs(memDir)
+      const prompt = isChild
+        ? [AGENT_LESSON_PROMPT, "", "NOTES:", notes].join("\n")
+        : buildPrompt(notes, existing)
+      const reply = await ctx.generate.text({
+        prompt, model: { providerID: model.providerID, id: model.id, ...(model.variant ? { variant: model.variant } : {}) },
+      })
+      await storeDistil(String(reply?.text ?? ""), { isChild, memDir, agentName, existing })
+    } catch (err) {
+      console.error(`[geneseed-learn] skipped: ${err?.message ?? err}`)
+    } finally {
+      inFlight.delete(sid)
+    }
+  }
+
+  const controller = new AbortController()
+  void (async () => {
+    for await (const ev of ctx.event.subscribe({ signal: controller.signal })) {
+      const sid = ev?.data?.sessionID
+      if (!sid) continue
+      if (ev.type === "session.deleted") {
+        const t = timers.get(sid)
+        if (t) clearTimeout(t)
+        timers.delete(sid)
+        continue
+      }
+      if (ev.type !== "session.execution.succeeded") continue
+      const prev = timers.get(sid)
+      if (prev) clearTimeout(prev)
+      timers.set(sid, setTimeout(() => { timers.delete(sid); runDistill(sid) }, DEBOUNCE_MS))
+    }
+  })().catch((err) => console.error(`[geneseed-learn] event stream ended: ${err?.message ?? err}`))
+  return () => {
+    controller.abort()
+    for (const t of timers.values()) clearTimeout(t)
+    timers.clear()
+  }
+}
 
-export default GeneseedLearn
+export default { id: "geneseed-learn", server: GeneseedLearn, setup: setupV2 }

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

@@ -157,4 +157,49 @@ export const GeneseedNotify = async ({ client }) => {
 // off the factory instead — reachable via `import`, invisible to the loader.
 Object.assign(GeneseedNotify, { lastUserMs, shouldNotify, notifyCommand })
 
-export default GeneseedNotify
+// ---- 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 core never publishes `session.idle` (deprecated in its schema). The turn boundary is
+// the execution pair instead: `session.execution.started` stamps when the agent began,
+// `session.execution.succeeded`/`failed` ends it — so the turn length comes straight off
+// the events, no transcript read. An interrupted execution is the user's own doing (or a
+// shutdown) and is not announced. Events are `{ type, created, data }`, not V1's
+// `{ type, properties }`.
+async function setupV2(ctx) {
+  if (OFF) return
+  const started = new Map()
+  const controller = new AbortController()
+  void (async () => {
+    for await (const ev of ctx.event.subscribe({ signal: controller.signal })) {
+      const sid = ev?.data?.sessionID
+      if (!sid) continue
+      if (ev.type === "session.execution.started") { started.set(sid, ev.created); continue }
+      if (ev.type === "session.execution.interrupted" || ev.type === "session.deleted") { started.delete(sid); continue }
+      if (ev.type !== "session.execution.succeeded" && ev.type !== "session.execution.failed") continue
+      const begin = started.get(sid) ?? null
+      started.delete(sid)
+      try {
+        let title = "", parentID
+        try {
+          const info = await ctx.session.get({ sessionID: sid })
+          title = info?.title ?? ""
+          parentID = info?.parentID
+        } catch {}
+        const now = typeof ev.created === "number" ? ev.created : Date.now()
+        if (!shouldNotify({ now, lastUserMs: begin, parentID, title, minMs: MIN_MS })) {
+          log(`skipped ${sid} (child/throwaway or turn under ${MIN_MS}ms)`)
+          continue
+        }
+        deliver(TITLE, title ? `Done: ${title}` : "Agent finished — your turn.")
+        log(`notified for ${sid}`)
+      } catch (err) {
+        log(`skipped: ${err?.message ?? err}`)
+      }
+    }
+  })().catch((err) => log(`event stream ended: ${err?.message ?? err}`))
+  return () => controller.abort()
+}
+
+export default { id: "geneseed-notify", server: GeneseedNotify, setup: setupV2 }

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

@@ -143,6 +143,48 @@ export const GeneseedPonytail = async () => ({
 // any that isn't a function — a bare helper export crashes startup ("null is not an
 // object") or logs "not a function". Hang the test helpers off the factory instead;
 // they ride along for `import`, invisible to the loader. Upgrade path: none needed.
-Object.assign(GeneseedPonytail, { normalizeMode, defaultMode, ponytailInstructions })
+Object.assign(GeneseedPonytail, { normalizeMode, defaultMode, ponytailInstructions, levelFromPrompt })
 
-export default GeneseedPonytail
+// --- 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 neither hook. `session.hook("context")` carries the outgoing system parts (the
+// ruleset is pushed there), and there is no `command.execute.before`: a markdown command
+// expands its template into the prompt, so the switch is read off the prompt instead —
+// the first line of PONYTAIL_COMMAND_BODY (js/hosts/opencode.mjs), `Ponytail level
+// requested: <args>`. Change that line and this pattern together.
+const PONYTAIL_PROMPT_RE = /^Ponytail level requested:[ \t]*(.*)$/m
+
+// The level a `/ponytail` prompt asks for: undefined when the text is not one, null
+// when its argument is no known level, else the level (empty argument = `full`).
+function levelFromPrompt(text) {
+  const m = PONYTAIL_PROMPT_RE.exec(String(text ?? ""))
+  if (!m || m.index !== 0) return undefined
+  const arg = m[1].trim()
+  return normalizeMode(arg) || (arg ? null : "full")
+}
+
+async function setupV2(ctx) {
+  await ctx.session.hook("prompt", (event) => {
+    try {
+      const mode = levelFromPrompt(event?.prompt?.text)
+      if (mode === undefined) return
+      if (!mode) { log("ignored unknown level"); return }
+      writeMode(mode)
+      log(`ponytail ${mode}`)
+    } catch (err) {
+      log(`prompt hook error: ${err?.message ?? err}`)
+    }
+  })
+  await ctx.session.hook("context", (event) => {
+    try {
+      const text = ponytailInstructions(readMode())
+      if (text && Array.isArray(event?.system)) event.system.push({ type: "text", text })
+    } catch (err) {
+      log(`context hook error: ${err?.message ?? err}`)
+    }
+  })
+}
+
+export default { id: "geneseed-ponytail", server: GeneseedPonytail, setup: setupV2 }