geneseed 4.0.0 → 4.1.0

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

@@ -116,23 +116,10 @@ async function writeTrace(rootDir, runId, lines) {
   } catch (e) { dlog(`trace write failed: ${e?.message || e}`); return "(trace write failed)" }
 }
 
-export const GeneseedWorkflow = async (ctx) => {
-  const { client, directory, worktree } = ctx
+// The `workflow` tool's body, shared by the V1 and V2 registrations: `client` is the V1
+// SDK client, or on V2 the facade `v2Client` builds over the plugin context.
+function makeExecute({ client, directory, worktree }) {
   const rootDir = worktree || directory
-  let toolHelper
-  try { ({ tool: toolHelper } = await import("@opencode-ai/plugin")) }
-  catch { dlog("@opencode-ai/plugin tool helper unavailable — registering a raw tool def") }
-
-  // One-line load banner (always on) so a restart visibly confirms the plugin loaded
-  // and the `workflow` tool is registered — and WARNS if this OpenCode build lacks the
-  // custom-tool helper (the silent "tool never appears" failure).
-  try {
-    const names = await listWorkflows()
-    const warn = toolHelper ? ""
-      : " — WARN: @opencode-ai/plugin 'tool' helper missing; the workflow tool may NOT register on this OpenCode version"
-    console.error(`[geneseed-workflow] loaded — tool 'workflow' registered, ${names.length} workflow(s) [${names.join(", ") || "none"}] from ${WORKFLOWS_DIR}${warn}`)
-  } catch (e) { console.error(`[geneseed-workflow] loaded but could not list workflows: ${e?.message || e}`) }
-
   // Normalize the `args` parameter. OpenCode's tool layer can deliver a structured
   // object param as a JSON STRING (or drop it) when the schema is untyped — so coerce
   // a string back to an object and reject non-object shapes to `{}`. Without this, the
@@ -185,22 +172,52 @@ export const GeneseedWorkflow = async (ctx) => {
     return summarize(name, result, stats, tracePath)
   }
 
+  return execute
+}
+
+// The `workflow` tool as the model sees it, on both majors.
+const TOOL_DESCRIPTION =
+  "Run a saved, code-driven Geneseed workflow that orchestrates subagents " +
+  "deterministically (parallel fan-out, find→verify pipeline, phased handoff). " +
+  "Call with no name to list available workflows."
+const NAME_DESCRIPTION = "saved workflow name; omit to list available"
+const ARGS_DESCRIPTION = "inputs passed to the workflow script as `args` (object, or a JSON object string)"
+
+// One-line load banner (always on) so a restart visibly confirms the plugin loaded and the
+// `workflow` tool is registered. tests/host_canary.mjs reads it as V1's proof of load.
+async function loadBanner(warn = "") {
+  try {
+    const names = await listWorkflows()
+    console.error(`[geneseed-workflow] loaded — tool 'workflow' registered, ${names.length} workflow(s) [${names.join(", ") || "none"}] from ${WORKFLOWS_DIR}${warn}`)
+  } catch (e) { console.error(`[geneseed-workflow] loaded but could not list workflows: ${e?.message || e}`) }
+}
+
+export const GeneseedWorkflow = async (ctx) => {
+  const { client, directory, worktree } = ctx
+  let toolHelper
+  try { ({ tool: toolHelper } = await import("@opencode-ai/plugin")) }
+  catch { dlog("@opencode-ai/plugin tool helper unavailable — registering a raw tool def") }
+
+  // Warn when this OpenCode build lacks the custom-tool helper (the silent "tool never
+  // appears" failure).
+  await loadBanner(toolHelper ? ""
+    : " — WARN: @opencode-ai/plugin 'tool' helper missing; the workflow tool may NOT register on this OpenCode version")
+
+  const execute = makeExecute({ client, directory, worktree })
+
   const def = {
-    description:
-      "Run a saved, code-driven Geneseed workflow that orchestrates subagents " +
-      "deterministically (parallel fan-out, find→verify pipeline, phased handoff). " +
-      "Call with no name to list available workflows.",
+    description: TOOL_DESCRIPTION,
     args: toolHelper
       ? {
-          name: toolHelper.schema.string().optional().describe("saved workflow name; omit to list available"),
+          name: toolHelper.schema.string().optional().describe(NAME_DESCRIPTION),
           // Keep this `any()` — it's the only param shape known to register cleanly on
           // this OpenCode build (record()/object schemas wedged tool registration → every
           // session message stuck "queued"). The provider may still deliver the object as
           // a JSON string or empty; normalizeArgs() in execute() recovers both cases.
-          args: toolHelper.schema.any().optional().describe("inputs passed to the workflow script as `args` (object, or a JSON object string)"),
+          args: toolHelper.schema.any().optional().describe(ARGS_DESCRIPTION),
         }
       : {
-          name: { type: "string", description: "saved workflow name; omit to list available" },
+          name: { type: "string", description: NAME_DESCRIPTION },
           args: { type: "object", description: "inputs passed to the workflow script as `args`" },
         },
     async execute(argv) { return execute(argv) },
@@ -209,4 +226,87 @@ export const GeneseedWorkflow = async (ctx) => {
   return { tool: { workflow: toolHelper ? toolHelper(def) : def } }
 }
 
-export default GeneseedWorkflow
+// ---- 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 registers tools through `tool.transform` with a plain JSON-schema `input` (no
+// `@opencode-ai/plugin` helper — that package is `@opencode/plugin` there, and not
+// needed). The runtime (`_runtime.js`) and every saved workflow speak the V1 SDK client,
+// so `v2Client` presents that client's few calls over the V2 session domain instead of
+// forking the runtime:
+//   create  → session.create (a worktree directory becomes the session's location)
+//   prompt  → switchAgent/switchModel when asked, then session.prompt — which only
+//             admits the input on V2 — then session.wait for the loop to go idle, and the
+//             last assistant message read back from session.context
+//   messages → session.context, reshaped to V1's `{ info, parts }`
+//   delete  → session.remove
+function v2Message(m) {
+  if (m?.type === "assistant") {
+    return {
+      info: { role: "assistant", tokens: m.tokens },
+      parts: (m.content || []).filter((p) => p?.type === "text").map((p) => ({ type: "text", text: p.text })),
+    }
+  }
+  return { info: { role: m?.type }, parts: typeof m?.text === "string" ? [{ type: "text", text: m.text }] : [] }
+}
+function v2ModelRef(model) {
+  if (typeof model === "string" && model.includes("/")) {
+    const [providerID, ...rest] = model.split("/")
+    return { providerID, id: rest.join("/") }
+  }
+  const id = model?.id ?? model?.modelID
+  return model?.providerID && id ? { providerID: model.providerID, id } : null
+}
+function v2Client(ctx) {
+  const context = async (sid) => (await ctx.session.context({ sessionID: sid })) || []
+  return {
+    session: {
+      create: async ({ body, query } = {}) => ctx.session.create({
+        ...(body?.title ? { title: body.title } : {}),
+        ...(query?.directory ? { location: { directory: query.directory } } : {}),
+      }),
+      prompt: async ({ path: p, body } = {}) => {
+        const sessionID = p?.id
+        if (body?.agent) await ctx.session.switchAgent({ sessionID, agent: body.agent })
+        const model = v2ModelRef(body?.model)
+        if (model) await ctx.session.switchModel({ sessionID, model })
+        const text = (body?.parts || []).filter((x) => x?.type === "text").map((x) => x.text).join("\n")
+        await ctx.session.prompt({ sessionID, text })
+        await ctx.session.wait({ sessionID })
+        const last = (await context(sessionID)).filter((m) => m?.type === "assistant").pop()
+        return last ? v2Message(last) : null
+      },
+      messages: async ({ path: p } = {}) => (await context(p?.id)).map(v2Message),
+      delete: async ({ path: p } = {}) => ctx.session.remove({ sessionID: p?.id }),
+    },
+  }
+}
+
+async function setupV2(ctx) {
+  const directory = ctx?.location?.directory
+  const worktree = ctx?.location?.project?.directory
+  const execute = makeExecute({ client: v2Client(ctx), directory, worktree })
+  await loadBanner()
+  await ctx.tool.transform((editor) => {
+    editor.add({
+      name: "workflow",
+      description: TOOL_DESCRIPTION,
+      input: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: NAME_DESCRIPTION },
+          args: { description: ARGS_DESCRIPTION },
+        },
+      },
+      // A rejected promise here is a defect that fails the whole agent step, not the call:
+      // every failure comes back as text, as the V1 tool's do.
+      execute: async (input) => {
+        try { return { content: await execute(input) } }
+        catch (e) { return { content: `Workflow failed: ${e?.message || e}` } }
+      },
+    })
+  })
+}
+
+export default { id: "geneseed-workflow", server: GeneseedWorkflow, setup: setupV2 }

package/docs/guides/mcp-filesystem.md

@@ -6,7 +6,7 @@ kind: "concept"
 section: "Set up"
 description: "File access limited to the folders you list, and the placeholder path to replace."
 ---
-One of the [MCP server](mcp.md) presets. Where each host keeps the config, and how to check the server connected, are on that page.
+One of the [MCP servers](mcp.md) Geneseed documents. Where each host keeps the config, and how to check the server connected, are on that page.
 
 [`@modelcontextprotocol/server-filesystem`](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem) gives the agent file access limited to the folders you list, through `npx`. **The allowed folders are command-line arguments.** The server refuses any path outside them, so grant the narrowest set that works, not `$HOME` or `/`.
 
@@ -34,7 +34,7 @@ One of the [MCP server](mcp.md) presets. Where each host keeps the config, and h
 ```
 <!--/harness-->
 
-> **Replace the placeholder.** The preset ships with the literal path `/path/to/allowed/dir`. If you enable the server without changing it, the server runs but can reach nothing. This is the classic "the filesystem MCP sees nothing" problem.
+> **Replace the placeholder.** The blocks above end with a sample path. If you register the server without changing it, the server runs but can reach nothing. This is the classic "the filesystem MCP sees nothing" problem.
 
 ---
 

package/docs/guides/mcp-gitlab.md

@@ -6,7 +6,7 @@ kind: "concept"
 section: "Set up"
 description: "Merge requests, issues and CI from the agent: token scopes, the config block, a second instance."
 ---
-One of the [MCP server](mcp.md) presets. Where each host keeps the config, and how to check the server connected, are on that page.
+One of the [MCP servers](mcp.md) Geneseed documents. Where each host keeps the config, and how to check the server connected, are on that page.
 
 > **Never commit a real token.** The presets ship with an empty `GITLAB_PERSONAL_ACCESS_TOKEN` and a sample filesystem path. Fill them in your own config, never in a tracked file.
 
@@ -59,7 +59,7 @@ You can also register it with `claude mcp add`.
 
 Keep the `/api/v4` suffix on the URL.
 
-**A second instance** (gitlab.com plus a self-hosted server, for example) is a copy of the same block under a new name, such as `gitlab-acme`, with its own `GITLAB_API_URL` and token. The preset covers the first instance only. You add the copy by hand.
+**A second instance** (gitlab.com plus a self-hosted server, for example) is a copy of the same block under a new name, such as `gitlab-acme`, with its own `GITLAB_API_URL` and token. You add the copy by hand, like the first.
 
 ---
 

package/docs/guides/mcp-markitdown.md

@@ -6,13 +6,13 @@ kind: "concept"
 section: "Set up"
 description: "Convert PDF and Office files to markdown: uvx or pipx, OCR extras, corporate TLS."
 ---
-One of the [MCP server](mcp.md) presets. Where each host keeps the config, and how to check the server connected, are on that page.
+One of the [MCP servers](mcp.md) Geneseed documents. Where each host keeps the config, and how to check the server connected, are on that page.
 
 [MarkItDown](https://github.com/microsoft/markitdown) (Microsoft) converts PDF, Word, Excel, PowerPoint and HTML to markdown. It exposes one tool, `convert_to_markdown(uri)`, which accepts `file:`, `http:`, `https:` and `data:` URIs.
 
 **1. Make the command resolve.**
 
-- **`uvx` (recommended, nothing to install).** If you have [uv](https://docs.astral.sh/uv/), `uvx markitdown-mcp` fetches and caches the server on first use. This is the command the preset uses.
+- **`uvx` (recommended, nothing to install).** If you have [uv](https://docs.astral.sh/uv/), `uvx markitdown-mcp` fetches and caches the server on first use. This is the command the blocks in [MCP servers](mcp.md) use.
 - **`pipx`.** Without uv, run `pipx install markitdown-mcp`, then use `markitdown-mcp` alone as the command (OpenCode: `["markitdown-mcp"]`; Claude: `"command": "markitdown-mcp"`, no args).
 
 ```
@@ -29,7 +29,7 @@ export UV_SYSTEM_CERTS=true      # older uv: UV_NATIVE_TLS=true
 # fallback: export SSL_CERT_FILE=/path/to/corporate-root-ca.pem
 ```
 
-**3. Register it**, with the console toggle or one of the blocks in [MCP servers](mcp.md). Then restart your agent.
+**3. Register it** by adding one of the blocks in [MCP servers](mcp.md) to your config. Then restart your agent.
 
 ---
 

package/docs/guides/mcp.md

@@ -4,15 +4,15 @@ order: 16
 title: "MCP servers"
 kind: "concept"
 section: "Set up"
-description: "Where MCP config lives for each host, the three presets, and how to check a server connected."
+description: "Where MCP config lives for each host, three servers worth adding, and how to check a server connected."
 ---
-MCP (Model Context Protocol) servers give your agent extra tools: converting a PDF, opening a merge request, reading files outside the repo. Geneseed ships three ready-made server **presets** (MarkItDown, GitLab and Filesystem) that you can switch on without writing JSON by hand.
+MCP (Model Context Protocol) servers give your agent extra tools: converting a PDF, opening a merge request, reading files outside the repo. Geneseed documents three servers worth adding (MarkItDown, GitLab and Filesystem), with the config block for each host. You add them to your config yourself: which servers you need depends on you and on your host.
 
 > **You already know this:** an MCP entry is a line in a Procfile. It names a command the agent starts on demand. Writing the line does not install the program behind it.
 
-Each preset is a *local* server, a command your agent launches when it needs the server. Registering a preset only points the agent at that command. **You** install the tool behind it (or let `uvx` or `npx` fetch it) and you supply any credentials.
+Each of the three is a *local* server, a command your agent launches when it needs the server. Registering one only points the agent at that command. **You** install the tool behind it (or let `uvx` or `npx` fetch it) and you supply any credentials.
 
-> **Never commit a real token.** The presets ship with an empty `GITLAB_PERSONAL_ACCESS_TOKEN` and a sample filesystem path. Fill them in your own config, never in a tracked file.
+> **Never commit a real token.** The blocks here carry an empty `GITLAB_PERSONAL_ACCESS_TOKEN` and a sample filesystem path. Fill them in your own config, never in a tracked file.
 
 ## Where the config lives
 
@@ -35,11 +35,11 @@ The same MarkItDown server in both shapes:
 { "mcpServers": { "markitdown": { "command": "uvx", "args": ["markitdown-mcp"] } } }
 ```
 
-**Toggle instead of editing.** In the web console (`geneseed web`), **Settings → MCP servers** adds, enables, disables or removes any preset in the right file, already in the right shape. Not sure which file that is? The **Harnesses** page shows the config path for each install, and `geneseed mcp` prints the same paths and lists the servers each install has wired, without starting anything.
+**See what is wired.** Geneseed never writes these files. The web console (`geneseed web`) shows, for each active install, its config path and the servers it holds, enabled or disabled, with a button that opens the folder so you can edit the file. `geneseed mcp` prints the same in a terminal, without starting anything.
 
-The reference OpenCode config ships MarkItDown enabled and the GitLab and Filesystem entries disabled, so a merge never switches on a server that has no credentials yet. Fill in the blanks, then switch the server on.
+The reference OpenCode config ships MarkItDown enabled and the GitLab and Filesystem entries disabled, so a merge never switches on a server that has no credentials yet. Fill in the blanks, then set `enabled` to `true`.
 
-## The presets
+## Three servers worth adding
 
 - [MarkItDown](mcp-markitdown.md): converts PDF, Word, Excel, PowerPoint and HTML to markdown.
 - [GitLab](mcp-gitlab.md): repository, merge request, issue and CI tools over the GitLab API.

package/docs/guides/project-context.md

@@ -99,7 +99,7 @@ A line is simply left out when its source is missing.
 
 ## How OpenCode delivers it
 
-By default, the plugin delivers the context invisibly. It prepends the context to each request through OpenCode's experimental `experimental.chat.messages.transform` hook, so nothing appears in the conversation. Because it is re-sent with every request, the context also survives compaction. If your OpenCode build lacks that hook, the plugin notices and falls back to posting a visible `PROJECT CONTEXT` message.
+By default, the plugin delivers the context invisibly. It prepends the context to each request through OpenCode's experimental `experimental.chat.messages.transform` hook, so nothing appears in the conversation. Because it is re-sent with every request, the context also survives compaction. If your OpenCode build lacks that hook, the plugin notices and falls back to posting a visible `PROJECT CONTEXT` message. On OpenCode 2 the same invisible delivery goes through its stable per-request `context` hook, so no fallback is needed.
 
 - `GENESEED_CONTEXT_VISIBLE=1` always shows the visible block, so you can see what the agent received.
 - `GENESEED_CONTEXT_INJECT=off` turns injection off. The agent then relies on the instruction in `AGENT.md` to read the docs itself.

package/docs/reference/opencode-plugins.md

@@ -14,6 +14,15 @@ Every plugin installs in the same step as the rest of the harness: `geneseed set
 
 Every plugin swallows its own errors — none can block or crash a session. Each plugin's page lists the variables that tune it.
 
+## OpenCode 2
+
+The same files work on OpenCode 1 (1.3.4 or newer) and OpenCode 2. OpenCode 2 rewrote the plugin API, and each plugin carries both halves. You don't need to configure anything. Two differences show on OpenCode 2:
+
+- **A guard block shows up as a failed tool call.** The call never runs. The model gets an error that starts with `[geneseed-guard] blocked:` and gives the reason.
+- **The Activity view shows no todo list or files-touched count.** OpenCode 2 publishes no event for either.
+
+If a plugin seems silent on OpenCode 2, check that `~/.config/opencode/plugins/` holds the current files. Copies from before this change fail to load with *"Plugin must export a default definition with an id and an effect or setup function"*. Running `geneseed rebuild-all` replaces them.
+
 ## The plugins
 
 - [geneseed-context](plugin-context.md): Puts your project docs, rules, profile, memory index and wiki in front of the agent.

package/harness.config.json

@@ -2,5 +2,5 @@
   "_comment": "version is a human-readable release label only; the canonical identity of an installed harness is the source fingerprint stamped in .geneseed-version (see `harness version`), not this string.",
   "theme": "neutral",
   "product": "Geneseed",
-  "version": "4.0.0"
+  "version": "4.1.0"
 }

package/js/cli-table.json

@@ -901,7 +901,7 @@
     },
     {
       "name": "mcp",
-      "help": "list the MCP servers wired into each active install, and the presets available to add",
+      "help": "list the MCP servers wired into each active install, read-only",
       "description": "",
       "positionals": [],
       "options": [],

package/js/hosts/mcp.mjs

@@ -1,22 +1,15 @@
 /**
- * MCP server presets, state and config I/O — `rituals/_harness_mcp.py`'s MCP block.
+ * MCP server state and config reading — `rituals/_harness_mcp.py`'s MCP block, minus its writers.
  *
- * WHAT THE PLAN SAID AND WHAT READING FOUND. The P6f plan scored `api_mcp` + `api_mcp_toggle`
- * at "~90 new, already in js/: `_mcp_load`/`readJsonc` (P6c), `settings.mjs`'s atomic write".
- * Measured against `js/`: `readJsonc` had crossed and NOTHING ELSE HAD. `js/web/api.mjs`
- * carries a five-line `mcpLoad` that is the no-host, comment-tolerant reader P6c needed for
- * `geneseed-wiki.jsonc`, which is one arm of one of these thirteen functions. `_MCP_PRESETS`,
- * `_mcp_servers_key`, `_mcp_preset_block`, `_mcp_apply`, `_mcp_state`, `_mcp_set_enabled`,
- * `_mcp_load`'s host fork, `_mcp_commented`, `_mcp_save`, `_mcp_config_for`,
- * `_mcp_install_targets`, `_mcp_known_names` and `_mcp_meta` are 168 lines of Python, all
- * new. The endpoints on top of them are the small half.
+ * READ-ONLY BY DECISION (2026-10). Which MCP servers an install wires depends on the user and on
+ * the host, so Geneseed shows what each config already holds and where that file lives, and the
+ * user edits it. The three presets (`MCP_PRESETS`), the block shaper, the applier, the
+ * enable/disable flip and the atomic saver went with the console's Add button and toggle;
+ * `docs/guides/mcp*.md` carry the blocks a user copies by hand. Nothing here writes.
  *
- * THE ROUND TRIP IS THE HAZARD, and it is why every read here goes through `parseJson`.
- * `_mcp_save` rewrites the WHOLE config, not the servers map — and for a Claude global
- * install that config is `~/.claude.json`, which holds projects and history far beyond MCP
- * wiring. A `JSON.parse` would turn every `"temperature": 1.0` in somebody's real file into
- * `1` on the way back out. `readJsonc` already learned this; the strict-JSON fork has to
- * learn it separately, because it does not go through `readJsonc` at all.
+ * THE READ IS STILL HOST-SHAPED. OpenCode nests servers under `mcp` with an `enabled` flag and
+ * may be `.jsonc`; the Claude-shaped three use `mcpServers`, are strict JSON, and have no flag —
+ * present IS enabled. `uninstall` reads through `mcpLoad` too.
  *
  * A JsonNumber IS AN OBJECT TO `typeof`, which is why `isDict` (js/lib/json.mjs) excludes
  * the wrapper rather than testing `typeof v === 'object'`. Python's `isinstance(x, dict)` is
@@ -31,7 +24,7 @@ import { installState, installTargets } from './installs.mjs';
 import { printOut, printErr } from '../lib/fs.mjs';
 import { isDict } from '../lib/json.mjs';
 import { padEndToWidth } from '../lib/text.mjs';
-import { atomicWriteJson, loadJsonObject, opencodeTarget } from './settings.mjs';
+import { loadJsonObject, opencodeTarget } from './settings.mjs';
 
 
 /** `dict.get(key, default)`. */
@@ -40,52 +33,6 @@ const dget = (obj, key, dflt) => (isDict(obj) && Object.hasOwn(obj, key) ? obj[k
 /** The hosts whose MCP config is strict JSON under `mcpServers`, with no `enabled` flag. */
 const FLAGLESS = CLAUDE_STYLE;
 
-/**
- * `_harness_mcp._MCP_PRESETS` — the ready-to-wire servers the MCP screen can toggle.
- *
- * The `desc` strings go on the wire verbatim (`api_mcp` returns them), so they are the one
- * place in this file where a byte matters more than the shape. Insertion order is the
- * listing order.
- */
-export const MCP_PRESETS = {
-  markitdown: {
-    label: 'MarkItDown',
-    desc: 'PDF / Office / HTML -> Markdown for the ingest skill. Runs via `uvx` '
-      + '(needs uv; zero-install, fetches on first call). No uv? Switch the command '
-      + 'to ["markitdown-mcp"] after `pipx install markitdown-mcp`. Exposes one '
-      + 'tool: convert_to_markdown(uri).',
-    block: { type: 'local', command: ['uvx', 'markitdown-mcp'], enabled: true },
-  },
-  gitlab: {
-    label: 'GitLab',
-    desc: 'GitLab repo / MR / issue / CI tools via @zereight/mcp-gitlab (npx, no '
-      + 'install). Edit GITLAB_PERSONAL_ACCESS_TOKEN (scopes: api, read_repository) '
-      + 'and GITLAB_API_URL before use. For a second instance (a self-hosted server), '
-      + 'copy this block by hand under a new name and point it at the other URL — '
-      + 'docs/guides/mcp-gitlab.md has the pattern.',
-    block: {
-      type: 'local',
-      command: ['npx', '-y', '@zereight/mcp-gitlab'],
-      environment: { GITLAB_PERSONAL_ACCESS_TOKEN: '',
-        GITLAB_API_URL: 'https://gitlab.com/api/v4' },
-      enabled: true,
-    },
-  },
-  filesystem: {
-    label: 'Filesystem',
-    desc: 'Read/write files under explicitly allowed directories via '
-      + '@modelcontextprotocol/server-filesystem (npx, no install). Replace the '
-      + 'trailing path arg(s) with only the dir(s) the agent may touch '
-      + '(least-privilege).',
-    block: {
-      type: 'local',
-      command: ['npx', '-y', '@modelcontextprotocol/server-filesystem',
-        '/path/to/allowed/dir'],
-      enabled: true,
-    },
-  },
-};
-
 /** `_mcp_servers_key` — OpenCode nests servers under `mcp`, the other three `mcpServers`. */
 const serversKey = (host) => (FLAGLESS.includes(host) ? 'mcpServers' : 'mcp');
 
@@ -95,50 +42,11 @@ const serversOf = (config, host) => {
   return isDict(s) ? s : {};
 };
 
-/**
- * `_mcp_preset_block` — the block to WRITE for a preset, shaped for `host`.
- *
- * OpenCode takes it verbatim. The flagless three split the command list into `command`
- * (head) + `args` (tail) and rename `environment` to `env`.
- */
-export function mcpPresetBlock(name, host = 'opencode') {
-  const block = { ...MCP_PRESETS[name].block };
-  if (!FLAGLESS.includes(host)) return block;
-  const cmd = [...(block.command || [])];
-  const out = { command: cmd.length ? cmd[0] : '', args: cmd.slice(1) };
-  const env = block.environment;
-  if (env) out.env = { ...env };
-  return out;
-}
-
-/**
- * `_mcp_apply` — a COPY of `config` with server `name` set to `block`, or removed when
- * `block` is null. Never touches another key; drops an emptied servers map.
- *
- * The key ORDER is behaviour, not cosmetics: `setdefault` appends `$schema` at the end of a
- * fresh dict and leaves an existing one where it is, and `_mcp_save` writes the result out
- * as the file the user then reads. `{...config}` plus a guarded assignment is the same rule.
- */
-export function mcpApply(config, name, block, host = 'opencode') {
-  const cfg = { ...config };
-  const key = serversKey(host);
-  if (host === 'opencode' && !Object.hasOwn(cfg, '$schema')) {
-    cfg.$schema = 'https://opencode.ai/config.json';
-  }
-  const servers = { ...serversOf(cfg, host) };
-  if (block === null) delete servers[name];
-  else servers[name] = block;
-  if (Object.keys(servers).length) cfg[key] = servers;
-  else delete cfg[key];
-  return cfg;
-}
-
 /**
  * `_mcp_state` — 'enabled' | 'disabled' | 'absent'.
  *
  * OpenCode: a present server with no explicit `enabled` counts as enabled (its default).
- * The flagless three have no such key, so present IS enabled and 'disabled' never occurs —
- * toggling one off removes its entry instead.
+ * The flagless three have no such key, so present IS enabled and 'disabled' never occurs.
  */
 export function mcpState(config, name, host = 'opencode') {
   const server = serversOf(config, host)[name];
@@ -147,25 +55,13 @@ export function mcpState(config, name, host = 'opencode') {
   return dget(server, 'enabled', true) ? 'enabled' : 'disabled';
 }
 
-/** `_mcp_set_enabled` — flip a present server's enabled-ness. No-op when it is absent. */
-export function mcpSetEnabled(config, name, enabled, host = 'opencode') {
-  const server = serversOf(config, host)[name];
-  if (!isDict(server)) return config;
-  if (FLAGLESS.includes(host)) {
-    return enabled ? config : mcpApply(config, name, null, host);
-  }
-  return mcpApply(config, name, { ...server, enabled }, host);
-}
-
 /**
  * `_mcp_load` — a config as a dict; `{}` when missing, unreadable, unparseable or not an
  * object.
  *
  * The host fork is the whole function. OpenCode is read comment-tolerantly because a
  * hand-maintained `opencode.jsonc` carries `//`; the other three are read STRICTLY, because
- * their configs are plain JSON by contract, and a file that does not parse as such — for a
- * Claude global install, one that holds projects and history — is not one to rewrite from a
- * best-effort reading. (The comment stripper's trailing-comma pass IS string-aware; an older
+ * their configs are plain JSON by contract. (The comment stripper's trailing-comma pass IS string-aware; an older
  * version of this note said otherwise, and `generate.test.mjs` pins the string-aware case.)
  */
 export function mcpLoad(p, host = 'opencode') {
@@ -179,11 +75,6 @@ export function mcpCommented(p) {
   return loadJsonObject(p).hadComments;
 }
 
-/** `_mcp_save` — pretty JSON, written ATOMICALLY. The one writer, under its MCP name. */
-export function mcpSave(p, config) {
-  atomicWriteJson(p, config);
-}
-
 /**
  * `_mcp_config_for` — the file an install writes its MCP servers into, or null for a host
  * that carries no MCP wiring at that scope.
@@ -222,19 +113,9 @@ export function mcpInstallTargets() {
   return out;
 }
 
-/** `_mcp_known_names` — the presets first, then any server already in THIS config. */
-export function mcpKnownNames(config, host = 'opencode') {
-  const names = Object.keys(MCP_PRESETS);
-  const present = isDict(config) ? Object.keys(serversOf(config, host)) : [];
-  return names.concat(present.filter((n) => !Object.hasOwn(MCP_PRESETS, n)));
-}
-
-/** `_mcp_meta` — (label, description); the bare name and a generic note for an unknown one. */
-export function mcpMeta(name) {
-  const p = MCP_PRESETS[name];
-  if (p) return [p.label, p.desc];
-  return [name, 'User-defined MCP server (not a Harness preset). It lives in this '
-    + "config already — 'e' enables/disables it, Enter removes it."];
+/** The servers THIS config already has, in file order. Nothing it could have. */
+export function mcpServerNames(config, host = 'opencode') {
+  return isDict(config) ? Object.keys(serversOf(config, host)) : [];
 }
 
 export { isDict };
@@ -242,22 +123,11 @@ export { isDict };
 // ---- the verb ----------------------------------------------------------------------------
 
 /**
- * `geneseed mcp` — the CLI FACE this library never had.
- *
- * Everything above crossed with the web console rather than with a subcommand: the reference
- * kept it as a preset/state library whose only command was the uninstall path, and the one
- * way to see which servers an install had wired was to start a server and look. That is the
- * gap this verb closes, and it closes it by CALLING the library — the same `mcpInstallTargets`
- * / `mcpLoad` / `mcpKnownNames` / `mcpState` / `mcpMeta` sequence the console's read endpoint
- * runs, rendered as text instead of as JSON.
+ * `geneseed mcp` — the servers each active install has wired, and the file they live in.
  *
- * ponytail: READ-ONLY, on purpose, and this is the ceiling. Wiring a server from here needs
- * the console's toggle orchestration, whose load-bearing part is not the toggle at all — it
- * is the refusal to rewrite a config it could not parse strictly, because for a global
- * Claude install that file holds projects and history and a rewrite from an empty object
- * would erase them. A second copy of that guard is a second place for it to be wrong. When a
- * terminal toggle is wanted, move the console's non-HTTP core down into this module and have
- * both faces call it; do not grow a parallel one here.
+ * The same `mcpInstallTargets` / `mcpLoad` / `mcpServerNames` / `mcpState` sequence the
+ * console's read endpoint runs, rendered as text instead of as JSON. Read-only like the
+ * console: there is nothing here to add or toggle a server with.
  */
 export function cmdMcp() {
   const targets = mcpInstallTargets()
@@ -272,9 +142,10 @@ export function cmdMcp() {
     if (mcpCommented(p)) {
       printOut('  this config carries comments — edit it by hand so they survive.\n');
     }
-    for (const name of mcpKnownNames(cfg, host)) {
-      const [lbl] = mcpMeta(name);
-      printOut(`  ${padEndToWidth(mcpState(cfg, name, host), 8)}  ${padEndToWidth(name, 12)}  ${lbl}\n`);
+    const names = mcpServerNames(cfg, host);
+    if (!names.length) printOut('  no MCP server configured\n');
+    for (const name of names) {
+      printOut(`  ${padEndToWidth(mcpState(cfg, name, host), 8)}  ${name}\n`);
     }
   }
   return 0;

package/js/hosts/opencode.mjs

@@ -114,7 +114,7 @@ export const COMMAND_SET = {
 };
 
 /** Mirrors `_build_emit.PONYTAIL_COMMAND_BODY`. */
-const PONYTAIL_COMMAND_BODY =
+export const PONYTAIL_COMMAND_BODY =
   'Ponytail level requested: $ARGUMENTS\n\n'
   + 'The geneseed-ponytail plugin records this level and, from your next turn, appends '
   + 'the matching "laziest solution that works" ruleset to your system prompt — honour '