mirror-mind 0.35.0 → 0.36.0

package/AGENTS.md

@@ -18,8 +18,8 @@ Applies to all sessions, regardless of project.
 The mirror operates in four modes, chosen automatically based on context:
 Mirror, Builder, Explorer, and Soul.
 
-Each skill below is named three ways: `/mm-<skill>` in Pi, `$mm-<skill>` in
-Codex, `/mm:<skill>` in Claude Code. A **plugin** install prefixes the plugin's
+Each skill below is named three ways: `/mm-<skill>` in Pi and Grok Build,
+`$mm-<skill>` in Codex, `/mm:<skill>` in Claude Code. A **plugin** install prefixes the plugin's
 name — `/mirror-mind:mm:<skill>` in Claude Code's menu and in Antigravity,
 `$mirror-mind:mm:<skill>` in Codex, `mirror-mind:mm-<skill>` as the skill's own
 name — and the forms below refer to the same skill.

package/README.md

@@ -60,8 +60,8 @@ This is not a chatbot with memory. This is a mirror — and yours.
 
 ## How It Works
 
-Local-first. SQLite. Four supported runtimes: Pi, Claude Code, Codex,
-Antigravity. One TypeScript core, run by Node.js. Jungian architecture: Self, Ego,
+Local-first. SQLite. Five supported runtimes: Pi, Claude Code, Codex,
+Antigravity, Grok Build. One TypeScript core, run by Node.js. Jungian architecture: Self, Ego,
 Personas, Shadow.
 Context-activated modes — Mirror, Builder, Explorer, and Soul. The identity lives
 in your machine, not a server.
@@ -110,7 +110,7 @@ this repository, turning a personal experiment into a reusable framework:
 
 - **English** — full migration from Portuguese across code, CLI, schema, identity, and docs
 - **Framework/user separation** — user identity and memory live privately under `~/.mirror/<user>/`, outside the repository
-- **Multi-runtime** — from Claude Code only to Pi, Claude Code, Codex, and Antigravity
+- **Multi-runtime** — from Claude Code only to Pi, Claude Code, Codex, Antigravity, and Grok Build
 - **Multi-user** — independent mirrors for multiple users on the same machine
 - **Multi-session** — concurrent sessions tracked safely in a database-backed session registry
 - **Intelligence depth** — hybrid semantic and lexical search, honest reinforcement, two-pass extraction, memory consolidation, and shadow cultivation

package/docs/releases/index.md

@@ -12,6 +12,7 @@ Future release notes should use the structure defined in [Release Notes](../proc
 
 ## Releases
 
+- [v0.36.0 — Five Runtimes, and a Home's Extensions on Every One](v0.36.0.md) — minor release closing CV21.DS10: Grok Build is the fifth runtime, at its honest L3 through the canonical plugin in two printed steps, measured live on grok 1.0.62. With it, CV21.DS5.US2: a home's installed extensions reach Claude Code, Codex, Antigravity, and Grok Build as one generated plugin per home, chosen by measurement on all four. Three Change Requests found by use: an extension's settings file (`extensions/<id>.env`, merged under the environment for the one spawned process), a quiet exit on a closed pipe, and a `bind` that refuses what it cannot bind. No migration.
 - [v0.35.0 — Four Runtimes, One Successor](v0.35.0.md) — minor release closing CV21.DS8: the Gemini CLI integration no longer ships and Antigravity stands in its place, the gate met by DS7's live L4 on agy 1.4.2. Four runtimes — Pi, Claude Code, Codex, Antigravity — named everywhere; the cutoff recorded in full, with the four hook entries a Gemini CLI user deletes and v0.34.0 as the last release that carries the integration; a retired-surface guard keeps it removed. No migration.
 - [v0.34.0 — Codex Through the Canonical Plugin](v0.34.0.md) — minor release closing CV21.DS4: Codex runs Mirror through the canonical plugin, installed in two commands from a marketplace the package ships, measured live at L4 on Codex 0.163.0. The v0.32.1 wrapper wiring no longer ships; `runtime diagnose` and `runtime update` say when Codex's cached plugin copy is behind and name the re-add that brings it level. No migration.
 - [v0.33.4 — A Name Is a Key](v0.33.4.md) — patch release of three first-run corrections: two from a contributor's PR #43 and CR141, which its review opened. `init --help` created a home named `--help`, `init ../escaped` created one outside `.mirror-minds`, and `init "My User"` put a space into `MIRROR_USER`; a user name is now a kebab-case key like a journey slug or a persona id, refused otherwise with a name that would work and nothing created. `identity edit` on Windows opens Notepad when no editor is named. Existing homes untouched. No migration.

package/docs/releases/v0.36.0.md

@@ -0,0 +1,222 @@
+---
+digest: >
+  v0.36.0 is a minor release closing CV21.DS10: Grok Build is Mirror Mind's
+  fifth runtime, at its honest L3 through the canonical plugin, in two steps
+  `mirror init` prints and `runtime diagnose` understands. With it ships
+  CV21.DS5.US2: a home's installed extensions reach Claude Code, Codex,
+  Antigravity, and Grok Build as one generated plugin per home, the shape
+  DS5.TS1 chose by measurement on all four. Three Change Requests ride along,
+  each found by using the product: an extension's installation settings get a
+  file Mirror reads for them (`extensions/<id>.env`), a closed pipe ends a
+  command quietly instead of with a stack trace, and `bind` refuses what it
+  cannot bind instead of writing a row that does nothing. No migration.
+---
+
+# v0.36.0 — Five Runtimes, and a Home's Extensions on Every One
+
+**Date:** 2026-10-20
+
+## Highlights
+
+- **Grok Build is the fifth runtime** (CV21.DS10). Two printed steps — a
+  trusted plugin install and a home rule for the Operating Instructions — and
+  Grok has Mirror's skills, its hooks, and its MCP server. Measured live on
+  grok 1.0.62: the rule reaches the model, `/mm-mirror` answers signed by a
+  persona, every turn is logged as `grok_build`, the close fits Grok's 1.5 s
+  bound. Honest ceiling, written where a user reads it: Grok adds nothing to
+  the model's context per turn, so Mirror Mode lasts as long as the skill's
+  own instructions do.
+- **A home's extensions reach every plugin runtime** (CV21.DS5.US2).
+  `mirror extensions install` and `uninstall` regenerate one small plugin per
+  Mirror home, `runtime/plugin/mirror-ext-<user>/`, and print the one wiring
+  step a runtime on the `PATH` still needs. Chosen over two other shapes by a
+  measured table on claude 2.1.296, codex 0.163.0, agy 1.4.2, and grok 1.0.62
+  ([decision](../project/decisions.md#user-extensions-reach-every-runtime-as-a-per-home-plugin)).
+  `runtime diagnose` names a stale copy and the command that brings it level.
+- **An extension's installation settings have a home**
+  ([CR145](../project/refinement/rs011-extension-contract-completeness/cr145-an-extension-s-installation-settings-have-nowhere-to-live-but-the-login-shell.md)).
+  `~/.mirror-minds/<user>/extensions/<id>.env`, merged *under* the environment
+  for the one process Mirror spawns — subcommand or context provider — and
+  nothing else. The reason it had to be Mirror: Node reads
+  `NODE_EXTRA_CA_CERTS` before any extension code runs, so only the spawner can
+  set it, and the alternative was the login shell, where it broke every other
+  Postgres client on the machine.
+- **Two front-door manners** ([CR148](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr148-the-front-door-dies-with-a-stack-trace-when-its-stdout-closes-early.md),
+  [CR149](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr149-bind-accepts-a-persona-or-journey-that-does-not-exist.md)).
+  `mirror … | head -1` exits 0 in silence instead of dying of `EPIPE` with a
+  stack trace — on the hook entry too, where exit 1 was the one code it
+  promised never to return. And `mirror ext <id> bind` checks the extension,
+  the capability, and the persona or journey before writing a row, refusing
+  with the fix in the line: `no persona 'engine' (mirror list personas shows
+  this home's)`.
+
+## Where We Started
+
+v0.35.0 closed CV21's runtime set at four — Pi, Claude Code, Codex,
+Antigravity — with Grok Build and user extensions named as what remained.
+Grok had been reading Mirror's skills by accident since DS12, through its
+Claude compatibility, with no hooks and no logging, and DS12.TS4 had left the
+MCP attachment as a contradiction: the server ready with its seven tools in
+Grok's own view, every session created with `mcp_server_count: 0`. User
+extensions reached Claude Code through `expose-claude` and Pi through its
+catalog, and nothing else; DS12.TS5 had measured that and left the exposure
+as a choice among three shapes, deciding none.
+
+Then the product was used. An extension built for a private journey needed a
+TLS mode and a certificate that belonged to the machine, and the only place
+the contract left for them was `~/.zshrc`. A mistyped `tail -` produced a
+Node stack trace from the front door. A mistyped persona was bound without a
+word. Three Change Requests, two days.
+
+## What Changed
+
+**Grok Build, in four stories on one day** (2026-10-18, grok 1.0.62).
+CV21.DS10.US1 measured five install shapes and chose two printed steps:
+`grok plugin install "<pkg>/plugins/mirror-mind" --trust`, and the Operating
+Instructions linked as a rule at `~/.grok/rules/mirror-mind.md` — Grok shows a
+session-start hook's context on screen only, so the rule is how the
+instructions reach the model. US1 also found that the root `plugin.json`
+marker DS7 had added was hiding the plugin's version and MCP server from
+Grok; it now carries both, one server on all four plugin runtimes. TS2
+closed DS12's contradiction: the server attaches, its tools sit behind Grok's
+`search_tool` and `use_tool` meta-tools (as `mirror-mind__list_journeys`), and
+the zero count was a snapshot taken while the server was `pending`. US3
+measured L3 with an ablation — remove the rule and the model loses the
+instructions; the hook canaries never reached it — and the deferred close
+tail finished at the next start, DS4.TS2's design on Grok's bound. TS4 wrote
+it: the contract's Grok reference implementation, README, Getting Started,
+REFERENCE, and the Operating Instructions name Grok Build as the fifth
+runtime with its two steps and its ceiling. Paid on the way, CR143: the
+inject hook returns at once on Grok instead of spending 2–3 s per load on a
+context Grok discards.
+
+**User extensions, chosen then built** (2026-10-19). CV21.DS5.TS1 measured
+the three shapes DS12.TS5 had left — user-level skill roots, a per-home
+generated plugin, MCP prompts — in scratch homes on all four runtimes, each
+cell read by the runtime's own listing and then by one headless turn asking
+for a canary, with every tool call classified so a find reached by searching
+the disk did not count. Only the per-home plugin qualified on all four: the
+skill roots are three roots that no runtime set reads in common, and MCP
+prompts attached everywhere and reached no model. US2 built it.
+`mirror extensions install`, `uninstall`, and `sync` regenerate
+`runtime/plugin/mirror-ext-<user>/` in the canonical plugin's format,
+version `0.1.<generation>`, carrying each extension's `claude` skill as its
+manifest already declares it — no manifest rewritten. The install prints what
+a runtime on the `PATH` still needs: a link for Claude Code, two commands for
+Codex, one for Antigravity, one with `--trust` for Grok (and the line that
+there is nothing for `--trust` to activate). After a change, the three
+runtimes that copy a plugin hold a stale copy until one command each, which
+the verbs print and `runtime diagnose` raises as five `ext_plugin_*` findings,
+each with its repair. Two homes wire beside each other. `runtime status`
+gained `Extensions plugin: mirror-ext-<user> <version> (<n> skills)`.
+
+**The settings file** (CR145). `mirror-cli-v1` handed a subcommand the five
+`MIRROR_*` variables and whatever environment `mirror` had; `mirror-context-v1`
+handed a provider the environment untouched. Now both read
+`extensions/<id>.env` — dotenv, the parser behind Mirror's own `.env` — and
+merge it *under* the process environment: an explicit export still wins, the
+five `MIRROR_*` names can never come from the file, and the result reaches
+that one process. The file sits beside the installed directory, not inside
+it: `install` rewrites the directory, and in a development home the directory
+is a symlink into the extension's own repository. `mirror ext <id>` ends its
+listing with the file's absolute path and one of four states — the variable
+*names* it carries, `no variables`, `not present` with what to do, or
+`unreadable` with the reason — and says when other users can read it. A file
+that exists and cannot be read refuses the subcommand (one line, exit 1,
+nothing spawned) and skips the provider with a `settings_unreadable`
+diagnostic. A full `uninstall` keeps the file and says so. The contract
+reference has the rules in full.
+
+**A closed pipe** (CR148). One listener at each entry — `mirror` and
+`mirror-hook` — on `EPIPE`: exit 0, write nothing. `npm`, `cargo`, and
+`kubectl`'s choice over git's 141, because under `set -o pipefail` 141 fails a
+pipeline a person wrote on purpose. Anything that is not `EPIPE` is rethrown.
+The hook leaves one line in `hooks.log` first, `stdout closed early`, because
+its try/catch could never see a stream's `error` event, and a runtime that
+gives up on a hook closes its pipe. Stop means stop: work after the reader
+closes is abandoned, as `SIGPIPE` abandons git's.
+
+**`bind` checks what it binds** (CR149). Four checks before the one insert,
+outside in: the id against the manifest's grammar, the extension installed,
+the capability declared (the validator first, then the context reader for the
+list), the persona or journey present in the identity rows a load is later
+matched against. Each refusal is one line on stdout at exit 1 and writes no
+row. `unbind` and `bindings` are untouched: removing a row that points at
+nothing is the repair. A deliberate divergence from the Python oracle; the
+bindings golden kept every byte, with its world given what the checks need.
+
+## Upgrading
+
+```bash
+npm install -g mirror-mind@latest    # or: mirror runtime update
+```
+
+No migration. Existing homes, sessions, memories, and bindings are untouched.
+
+**Grok Build:** `mirror init` prints the two steps when it finds `grok` on
+your `PATH`; Getting Started's Grok Build section has them with what they
+cost. If you had wired Claude Code, Grok already read the skills from that
+link; after the plugin install each skill appears twice in Grok's menu, and
+the hooks run once.
+
+**If you have extensions installed:** the per-home plugin is generated by the
+next `extensions` verb, not by the update. Re-install any one extension —
+`mirror extensions install <id> --extensions-root <root>` from its source, or
+from the home's own `~/.mirror-minds/<user>/extensions` — and the report
+prints the one wiring step each runtime on your `PATH` still needs. Pi needs
+nothing; its catalog path is unchanged.
+
+**If an extension of yours reads machine settings from your shell profile:**
+move them to `~/.mirror-minds/<user>/extensions/<id>.env`, `chmod 600` it,
+and `mirror ext <id>` will show the keys it carries. Then delete the exports
+— they reached every other program you run.
+
+## Conscious Exclusions
+
+- **DS5 is not closed.** US3 — `review-copy` invoked live on each runtime
+  from the shipped package, with version, binary, and date — and TS4 — the
+  contract, extension docs, Getting Started, and REFERENCE saying how an
+  extension reaches each runtime — remain. Until TS4, the install's printed
+  steps and the contract's per-home plugin section are the documentation.
+- **DS11**, the contract and docs refresh that folds all five runtimes into
+  one parity matrix, is not this release's.
+- **An extension cannot yet declare the settings it expects** (CR146), so the
+  settings file is written from the extension's README, not from a
+  checklist Mirror prints. **`install` shows `suggested_personas` the home does
+  not have as if it did** (CR150). **Three copies of the extension-id grammar
+  remain, two of them disagreeing** (CR147); CR145 and CR149 used the
+  manifest's. All three captured, none done.
+- **Still open from earlier:** the plugin smoke's negative probe on a machine
+  with a global `mirror-hook` (CR142); the DS7 routes removing agy's credential
+  where 1.3.x kept it (CR144).
+- **141** as the exit on a closed pipe, and `EPIPE` handling inside extension
+  subcommands: not chosen, recorded in CR148.
+
+## What We Learned
+
+Twice in one day a validation route had to be shown failing before it could
+be trusted passing. CR145's first run validated nothing: the `mirror` on the
+Navigator's `PATH` was the published 0.35.0, and the shell wrapped it in the
+very function the CR retires — the workaround, measured where it lived. CR148's
+planned control, `| head -1`, could not fail: a 2 KB listing lands whole in
+the pipe buffer before `head` quits, so there was never an `EPIPE` to handle;
+the reproduction is a reader that closes without reading. A route that names
+the binary by path and a control that has been seen red are now part of what
+a Change Request's validation means.
+
+The three CRs came from using the product, not from reading it: a private
+journey's extension, a typo, another typo. The review that preceded each —
+five lenses on CR145, three on CR148, four on CR149 — changed each plan
+before a line was written, and the things it added (a result type instead of
+a throw, a diagnostic kind instead of a generic failure, a check zero on the
+id grammar) are the parts a future reader will be glad of.
+
+## Next Horizon
+
+DS5.US3 is the recommended pull: the live proof of `review-copy` on all four
+plugin runtimes from the shipped package, through the steps this release
+prints. TS4 writes what US3 measures. DS11 then folds five runtimes into one
+contract and one matrix, and CV21 closes. RS011 — extension contract
+completeness — holds the gaps the contract has, found one extension at a time;
+CR146, a manifest that declares the settings it expects, is its next natural
+candidate.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirror-mind",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "Mirror Mind: a local-first memory and identity framework for agentic AI runtimes (Pi, Claude Code, Codex, Antigravity)",
   "license": "MIT",
   "repository": {

package/plugins/mirror-mind/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "mirror-mind",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "Mirror Mind — local-first memory and identity for agentic runtimes.",
   "author": {
     "name": "Mirror Mind"

package/plugins/mirror-mind/plugin.json

@@ -1,4 +1,14 @@
 {
   "name": "mirror-mind",
-  "description": "Mirror Mind — local-first memory and identity for agentic runtimes."
+  "description": "Mirror Mind — local-first memory and identity for agentic runtimes.",
+  "version": "0.36.0",
+  "mcpServers": {
+    "mirror-mind": {
+      "command": "/bin/sh",
+      "args": [
+        "-c",
+        "mmbin=\"\"; [ -n \"$MIRROR_BIN\" ] && [ -x \"$MIRROR_BIN/mirror\" ] && mmbin=\"$MIRROR_BIN/mirror\"; [ -n \"$mmbin\" ] || mmbin=\"$(command -v mirror 2>/dev/null)\"; for mmdir in \"$HOME/.nvm/current/bin\" /opt/homebrew/bin /usr/local/bin; do [ -n \"$mmbin\" ] && break; [ -x \"$mmdir/mirror\" ] && mmbin=\"$mmdir/mirror\"; done; [ -n \"$mmbin\" ] || { echo \"mirror-mind: mirror not found on PATH; the MCP server cannot start. Install mirror-mind (npm install -g mirror-mind) or set MIRROR_BIN to its bin directory.\" >&2; exit 1; }; mmnode=\"$MIRROR_NODE\"; [ -n \"$mmnode\" ] && [ -x \"$mmnode\" ] || mmnode=\"$(command -v node 2>/dev/null)\"; for mmdir in \"$(dirname \"$mmbin\")\" \"$HOME/.nvm/current/bin\" /opt/homebrew/bin /usr/local/bin; do [ -n \"$mmnode\" ] && break; [ -x \"$mmdir/node\" ] && mmnode=\"$mmdir/node\"; done; [ -n \"$mmnode\" ] || { echo \"mirror-mind: node not found on PATH; the MCP server cannot start. Set MIRROR_NODE.\" >&2; exit 1; }; exec \"$mmnode\" \"$mmbin\" mcp"
+      ]
+    }
+  }
 }

package/plugins/mirror-mind/rules/AGENTS.md

@@ -18,8 +18,8 @@ Applies to all sessions, regardless of project.
 The mirror operates in four modes, chosen automatically based on context:
 Mirror, Builder, Explorer, and Soul.
 
-Each skill below is named three ways: `/mm-<skill>` in Pi, `$mm-<skill>` in
-Codex, `/mm:<skill>` in Claude Code. A **plugin** install prefixes the plugin's
+Each skill below is named three ways: `/mm-<skill>` in Pi and Grok Build,
+`$mm-<skill>` in Codex, `/mm:<skill>` in Claude Code. A **plugin** install prefixes the plugin's
 name — `/mirror-mind:mm:<skill>` in Claude Code's menu and in Antigravity,
 `$mirror-mind:mm:<skill>` in Codex, `mirror-mind:mm-<skill>` as the skill's own
 name — and the forms below refer to the same skill.

package/ts/src/conversation/runtimePolicy.ts

@@ -1,6 +1,7 @@
 // What a runtime's session lifecycle lets Mirror do at its edges, by the label
 // US8 stamps on the session row (`claude_code`, `codex`, `grok_build`). One home
-// for the two policies the close path reads (CV21.DS4.TS2, US4).
+// for the policies the hooks read: the two the close path reads (CV21.DS4.TS2,
+// US4) and the one the inject hook reads (CV21.DS10.TS4, CR143).
 
 /**
  * Whether a runtime's SessionEnd hook has the time to run the LLM tail at exit
@@ -11,8 +12,10 @@
  *   codex        synchronous ("running async SessionEnd hook synchronously",
  *                DS12.TS2 L2), 1 s for a handler with no `timeout` (DS2's live
  *                `/hooks` table, 2026-10-13, Codex 0.162.1).
- *   grok_build   1.5 s for a handler with no `timeout` (DS12.TS4, Grok 1.0.52).
- *                DS10 re-measures it and may flip this entry.
+ *   grok_build   1.5 s for a handler with no `timeout` (DS12.TS4, Grok 1.0.52);
+ *                re-measured on 1.0.62 (CV21.DS10.US3): the guide says a
+ *                plugin's SessionEnd hook gets at most that default whatever
+ *                its own `timeout`, and the close landed 213–259 ms after it.
  *
  * Any other label, and no label, keeps today's behavior: the tail runs.
  */
@@ -57,3 +60,23 @@ export function sessionEndRunsLlmTail(interfaceName: string | null | undefined):
 export function sessionOutlivesTui(interfaceName: string | null | undefined): boolean {
   return interfaceName === "codex" || interfaceName === "antigravity";
 }
+
+/**
+ * Whether a runtime gives the model what a `UserPromptSubmit` hook returns as
+ * `additionalContext` — the channel the inject hook uses (CV21.DS10.TS4, CR143).
+ *
+ *   grok_build   no. Grok shows a SessionStart hook's `systemMessage` on
+ *                screen and discards both events' `additionalContext`
+ *                (DS12.TS4 L2/L3 on 1.0.52; CV21.DS10.US3 on 1.0.62, with a
+ *                random canary the probe hook emitted on every turn and the
+ *                model never quoted). The loads the hook made there held a
+ *                turn 2.3–2.6 s for a context nobody read; the hook returns
+ *                before any of them when this is false.
+ *
+ * Any other label, and no label, reads it: an unlabelled payload is a Claude
+ * Code payload by detection's own rule (`detectHookRuntime`), and a predicate
+ * that failed closed would silence injection on the runtime that needs it.
+ */
+export function runtimeReadsPromptContext(interfaceName: string | null | undefined): boolean {
+  return interfaceName !== "grok_build";
+}

package/ts/src/extensions/bindings.ts

@@ -22,8 +22,10 @@ import { join } from "node:path";
 import type { Database, WritableDatabase } from "#db/database.ts";
 import { PROGRAM } from "#util/program.ts";
 import type { RenderedCommand } from "./catalog.ts";
+import { readDeclaredCapabilityIds } from "./contextRuntime.ts";
 import { extensionNotInstalled, installedExtensionDir } from "./dispatch.ts";
-import { ExtensionError } from "./errors.ts";
+import { ExtensionError, ExtensionValidationError } from "./errors.ts";
+import { loadExtensionManifest, SKILL_ID_RE } from "./manifest.ts";
 import { runMigrations } from "./migrations.ts";
 
 /** Python `datetime.now(timezone.utc).isoformat()`: `+00:00`, microseconds. */
@@ -49,14 +51,50 @@ function label(target: BindingTarget): string {
   return target.id ? `${target.kind}/${target.id}` : target.kind;
 }
 
-/** Port of `_cmd_bind`. */
+/**
+ * `_cmd_bind` checked nothing it bound: a missing extension, an undeclared
+ * capability, and a persona that does not exist all answered `bound`, and the
+ * person learned of the typo when the context they expected never appeared.
+ * CR149 diverges on purpose: four checks, outside in, before the one insert,
+ * each refusing with one line on stdout at exit 1 -- the shape of the
+ * family's other refusals -- and writing no row.
+ *
+ * The id check comes first and is not cosmetic. `installedExtensionDir` does
+ * not normalize (Python's bytes), so `../x` would pass the existence check
+ * when `<home>/x/skill.yaml` exists, and the context runtime later builds a
+ * path from whatever this row holds.
+ */
 export function runBind(
   db: WritableDatabase,
+  mirrorHome: string,
   extensionId: string,
   capabilityId: string,
   target: BindingTarget,
   deps: BindingDeps,
 ): RenderedCommand {
+  if (!SKILL_ID_RE.test(extensionId)) {
+    return out(`'${extensionId}' is not a valid extension id\n`, 1);
+  }
+  const extensionDir = installedExtensionDir(mirrorHome, extensionId);
+  if (!existsSync(extensionDir)) return extensionNotInstalled(mirrorHome, extensionId);
+  // The validator first, as `install` runs it: its message is already the
+  // user-facing one. Then the context runtime's reader for the ids.
+  try {
+    loadExtensionManifest(extensionDir);
+  } catch (error) {
+    if (!(error instanceof ExtensionValidationError)) throw error;
+    return out(`${error.message}\n`, 1);
+  }
+  const declared = readDeclaredCapabilityIds(extensionDir);
+  if (!declared.includes(capabilityId)) {
+    const list = declared.length === 0 ? "declares none" : `declared: ${declared.join(", ")}`;
+    return out(`extension/${extensionId} declares no capability '${capabilityId}' (${list})\n`, 1);
+  }
+  if (target.kind !== "global" && !targetExists(db, target.kind, target.id ?? "")) {
+    // The fix in the line, as `missing target: pass --persona <id>, ...` does.
+    const shows = target.kind === "persona" ? `${PROGRAM} list personas` : `${PROGRAM} journeys`;
+    return out(`no ${target.kind} '${target.id ?? ""}' (${shows} shows this home's)\n`, 1);
+  }
   db.prepare(
     "INSERT OR IGNORE INTO _ext_bindings " +
       "(extension_id, capability_id, target_kind, target_id, created_at) " +
@@ -65,6 +103,19 @@ export function runBind(
   return out(`bound ${extensionId}/${capabilityId} -> ${label(target)}\n`);
 }
 
+/**
+ * The rows a load is later matched against (`selectExtensionBindings`), and
+ * nothing else: `layer = 'journey'`, not `journey_path`; exact key, so
+ * `Engineer` is not `engineer`. What `bind` accepts is what a load can find.
+ */
+function targetExists(db: Database, layer: "persona" | "journey", key: string): boolean {
+  return (
+    db
+      .prepare("SELECT 1 AS found FROM identity WHERE layer = ? AND key = ? LIMIT 1")
+      .get(layer, key) !== undefined
+  );
+}
+
 /** Port of `_cmd_unbind`. `target_id IS ?` is what makes a global unbind work. */
 export function runUnbind(
   db: WritableDatabase,

package/ts/src/extensions/catalogCommands.ts

@@ -17,8 +17,12 @@
 
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import type { WritableDatabase } from "#db/database.ts";
+import {
+  extensionPluginStates,
+  renderExtensionPluginBlock,
+} from "#runtime/extensionPluginWiring.ts";
 import { PROGRAM } from "#util/program.ts";
 import {
   type BindingDeps,
@@ -59,6 +63,8 @@ import {
   renderSubcommandListing,
 } from "./dispatch.ts";
 import { ExtensionValidationError } from "./errors.ts";
+import { regenerateExtensionPlugin } from "./extensionPlugin.ts";
+import { readExtensionSettings } from "./settings.ts";
 
 export class UnsupportedCatalogCommandError extends Error {}
 
@@ -98,6 +104,15 @@ const EXTENSIONS_VERBS = new Set([
 export interface CatalogContext {
   /** The resolved Mirror home; `--mirror-home` has already been applied. */
   readonly mirrorHome: string;
+  /**
+   * The environment the extensions-plugin readers take their homes and PATH
+   * from (CV21.DS5.US2): HOME, CODEX_HOME, GROK_HOME, PATH. A test passes a
+   * stand-in; the route passes the process's. Absent, the readers see no
+   * runtime and the plugin block is its first line alone.
+   */
+  readonly env?: NodeJS.ProcessEnv;
+  /** Whether a PATH candidate is executable; absent, nothing is. */
+  readonly isExecutable?: (path: string) => boolean;
 }
 
 /** The writable half, for the four `ext` verbs that touch the database. */
@@ -201,6 +216,30 @@ function writeContext(context: CatalogContext, command: string): ExtWriteContext
  * the recorded divergence shape -- the same exit code, one line on stderr --
  * and, like Python, writes nothing to stdout.
  */
+/**
+ * CV21.DS5.US2: after a write that changed the home's `claude` catalog, the
+ * home's extensions plugin is regenerated and the lines a person needs are
+ * appended to the report — the runtimes on the PATH that still need a step, or
+ * one line saying the plugin is wired everywhere. New lines at the end, never
+ * changed ones, so a caller parsing the report sees what it saw before.
+ */
+function withExtensionPluginBlock(
+  context: CatalogContext,
+  rendered: RenderedCommand,
+  removed: readonly string[] = [],
+): RenderedCommand {
+  if (rendered.exitCode !== 0) return rendered;
+  const plugin = regenerateExtensionPlugin(context.mirrorHome);
+  if (plugin === null) return rendered;
+  const states = extensionPluginStates(
+    plugin,
+    context.env ?? {},
+    context.isExecutable ?? (() => false),
+  );
+  const block = renderExtensionPluginBlock(plugin, states, removed);
+  return { ...rendered, stdout: `${rendered.stdout}${block.join("\n")}\n` };
+}
+
 function failLoudly(run: () => RenderedCommand): RenderedCommand {
   try {
     return run();
@@ -229,15 +268,18 @@ export function runExtensionsCommand(
     if (options.extensionsRoot === null) return usage("install requires --extensions-root PATH");
     const write = writeContext(context, "install");
     return failLoudly(() =>
-      renderInstallReport(
-        installExtension({
-          extensionId: options.positional[1] as string,
-          sourceRoot: options.extensionsRoot as string,
-          mirrorHome: write.mirrorHome,
-          runtime: options.runtime,
-          db: write.db,
-          deps: write.deps,
-        }),
+      withExtensionPluginBlock(
+        context,
+        renderInstallReport(
+          installExtension({
+            extensionId: options.positional[1] as string,
+            sourceRoot: options.extensionsRoot as string,
+            mirrorHome: write.mirrorHome,
+            runtime: options.runtime,
+            db: write.db,
+            deps: write.deps,
+          }),
+        ),
       ),
     );
   }
@@ -252,15 +294,19 @@ export function runExtensionsCommand(
     // `install` lets the same class escape as a traceback. Same command, two
     // refusal shapes, measured rather than unified.
     try {
-      return renderUninstallReport(
-        uninstallExtension({
-          extensionId: options.positional[1] as string,
-          mirrorHome: write.mirrorHome,
-          runtime: options.runtime,
-          db: write.db,
-          deps: write.deps,
-        }),
-      );
+      const report = uninstallExtension({
+        extensionId: options.positional[1] as string,
+        mirrorHome: write.mirrorHome,
+        runtime: options.runtime,
+        db: write.db,
+        deps: write.deps,
+      });
+      // What the copying runtimes "still have" after the removal: the claude
+      // command names this uninstall took out of the catalog.
+      const removed = report.removed
+        .filter(([runtimeName]) => runtimeName === "claude")
+        .flatMap(([, paths]) => paths.map((path) => basename(path)));
+      return withExtensionPluginBlock(context, renderUninstallReport(report), removed);
     } catch (error) {
       if (!(error instanceof ExtensionValidationError)) throw error;
       return out(`${error.message}\n`, 1);
@@ -337,7 +383,9 @@ export function runExtensionsCommand(
     `${stdout}Synced ${synced.length} extension(s) to ${options.targetRoot}`,
     ...synced.map((item) => `  ${item.command_name} -> ${item.installed_skill_path}`),
   ];
-  return out(`${lines.join("\n")}\n`);
+  // A verb that regenerates the plugin without installing (plan amendment 6):
+  // from the home's own claude catalog, when the home has one.
+  return withExtensionPluginBlock(context, out(`${lines.join("\n")}\n`));
 }
 
 /**
@@ -404,7 +452,7 @@ export function runExtCommand(
   if ("stdout" in parsed) return parsed;
   const target = { kind: parsed.kind, id: parsed.id };
   return verb === "bind"
-    ? runBind(context.db, extensionId, parsed.capabilityId, target, context.deps)
+    ? runBind(context.db, home, extensionId, parsed.capabilityId, target, context.deps)
     : runUnbind(context.db, extensionId, parsed.capabilityId, target);
 }
 
@@ -444,13 +492,24 @@ function dispatchOrNotInstalled(
   if (!existsSync(extensionRoot)) return extensionNotInstalled(mirrorHome, extensionId);
 
   const entries = readSubcommandListing(extensionRoot);
-  if (HELP_FLAGS.has(subcommand)) return out(renderSubcommandListing(extensionId, entries));
+  // The listing says what the settings file holds (CR145) on both paths that
+  // render it -- a help spelling and an unknown subcommand -- by decision, not
+  // by accident: it is the same listing wherever it appears.
+  if (HELP_FLAGS.has(subcommand)) {
+    return out(
+      renderSubcommandListing(extensionId, entries, readExtensionSettings(mirrorHome, extensionId)),
+    );
+  }
 
   const documented = entries.find((entry) => entry.name === subcommand);
   if (documented === undefined) {
     return out(
       `unknown subcommand '${subcommand}' for extension/${extensionId}\n` +
-        renderSubcommandListing(extensionId, entries),
+        renderSubcommandListing(
+          extensionId,
+          entries,
+          readExtensionSettings(mirrorHome, extensionId),
+        ),
       1,
     );
   }