CrackingShells · LittleCoinCoin · Sep 16, 2026 · Sep 15, 2026 · Sep 16, 2026 · Sep 16, 2026
diff --git a/.agents/plugins/marketplace.json b/.agents/plugins/marketplace.json
diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
diff --git a/.claude-plugin/mcp.json b/.claude-plugin/mcp.json
@@ -2,7 +2,9 @@
   "mcpServers": {
     "colgrep": {
       "command": "uvx",
-      "args": ["colgrep-mcp==0.5.1"],
+      "args": [
+        "colgrep-mcp==0.5.1"
+      ],
       "env": {
         "COLGREP_MCP_ROOT": "${CLAUDE_PROJECT_DIR}"
       }

diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
@@ -10,7 +10,13 @@
   "homepage": "https://github.com/CrackingShells/colgrep-mcp",
   "repository": "https://github.com/CrackingShells/colgrep-mcp",
   "license": "AGPL-3.0-or-later",
-  "keywords": ["mcp", "colgrep", "semantic-search", "code-search", "agents"],
+  "keywords": [
+    "mcp",
+    "colgrep",
+    "semantic-search",
+    "code-search",
+    "agents"
+  ],
   "mcpServers": "./.claude-plugin/mcp.json",
   "hooks": "./hooks/worktree-remove.json",
   "skills": "./skills/"

diff --git a/.codex-plugin/mcp.json b/.codex-plugin/mcp.json
diff --git a/.codex-plugin/plugin.json b/.codex-plugin/plugin.json
diff --git a/AGENTS.md b/AGENTS.md
@@ -35,7 +35,7 @@ runs the same roadmap sequentially under the same discipline. Load the
 
 ```bash
 claude --plugin-dir ./dev                            # from a clone
-claude plugin install colgrep-mcp-dev@cracking-shells   # from the repo's marketplace
+claude plugin install colgrep-mcp-dev@cracking-shells   # from CrackingShells/Nest, after `claude plugin marketplace add CrackingShells/Nest`
 ```
 
 `colgrep-mcp-dev` (`dev/`) ships the maintainer skills; the product plugin
@@ -55,7 +55,8 @@ claude plugin install colgrep-mcp-dev@cracking-shells   # from the repo's market
 | `server/colgrep_mcp/` | the server: `server.py` (assembly), `adapter.py` (colgrep subprocess), `tools_search.py`, `tools_index.py`, `resources.py`, `prompts.py`, `errors.py`, `guide.md` (agent guide served as a resource) | implementers |
 | `server/tests/` | pytest suite against `fake_colgrep.py`; `test_manifests.py`, `test_version.py`, `test_changelog.py`, `test_readme.py`, `test_dev_plugin.py` are drift guards; `e2e/run_e2e.py` drives the real binary (not collected by pytest) | implementers |
 | `server/pyproject.toml` | the only version source, dependencies, `[tool.commitizen]`, `[tool.ruff]`, pytest config | `cz bump` for the version; humans/agents for the rest |
-| `plugin.json`, `mcp.json`, `.claude-plugin/`, `.codex-plugin/`, `.agents/` | product plugin manifests for the three ecosystems; each MCP config (`.claude-plugin/mcp.json`, `.codex-plugin/mcp.json`, `mcp.json`) launches `uvx colgrep-mcp==<version>`; `version` fields and the pins are written by `cz bump` only | launcher/packaging changes |
+| `plugin.json`, `mcp.json`, `.claude-plugin/`, `.agents/` | product plugin manifests for the three ecosystems; Codex reads the root `plugin.json` and its `extensions["com.openai"]` block rather than a directory of its own; each MCP config (`.claude-plugin/mcp.json`, `mcp.json`) launches `uvx colgrep-mcp==<version>`; `version` fields and the pins are written by `cz bump` only | launcher/packaging changes |
+| `colgrep-mcp.spec.json` | the spec the manifests above are regenerated from, by the playbook's `spawning-agent-plugins` generator. Declares hub mode (`marketplace.hub` names `CrackingShells/Nest`), so regenerating writes no marketplace file here. Must stay byte-identical to the playbook's `assets/examples/colgrep-mcp.spec.json`: that copy is what the playbook's regeneration guard measures against this repo, so a divergence leaves the guard green while measuring a spec nobody uses | maintainers, in lockstep with the playbook's copy |
 | `skills/colgrep-search/SKILL.md` | the end-user skill that teaches agents when to use the tools | when tool semantics change |
 | `hooks/` | the plugin hooks: `hooks.json` (events every hook-capable harness knows), one `<event>.json` per event not every harness knows (`worktree-remove.json`), `colgrep_policy.py` (one stdlib script serving all events); pinned by `server/tests/test_hooks.py` | when the search policy or the harness wiring changes |
 | `dev/` | the `colgrep-mcp-dev` plugin: `skills/<name>/` (SKILL.md, `references/`, `scripts/`), `evals/<name>-triggers/case.yaml`; versioned by `cz bump` with the product | maintainers, when a cycle learns something |

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -45,7 +45,7 @@ Pushing the tag is the publish decision: `.github/workflows/publish.yml` builds
 distribution, uploads it to PyPI through trusted publishing (no token; the publisher
 registered on PyPI names `publish.yml` and the `pypi` environment) and creates the
 GitHub release from the tag's `CHANGELOG.md` section. The `uvx colgrep-mcp==<version>`
-pin in the three MCP manifests is a `version_files` target, so the bump moves it too.
+pin in the two MCP manifests is a `version_files` target, so the bump moves it too.
 
 ## Gates
 

diff --git a/README.md b/README.md
@@ -25,7 +25,7 @@ The server is the [`colgrep-mcp` package on PyPI](https://pypi.org/project/colgr
 ### Claude Code
 
 ```bash
-claude plugin marketplace add CrackingShells/colgrep-mcp
+claude plugin marketplace add CrackingShells/Nest
 ```
 
 ```bash
@@ -37,14 +37,14 @@ Add `--scope project` to the marketplace command to declare it in the repository
 ### Codex
 
 ```bash
-codex plugin marketplace add CrackingShells/colgrep-mcp
+codex plugin marketplace add CrackingShells/Nest
 ```
 
 ```bash
 codex plugin add colgrep-mcp@cracking-shells
 ```
 
-The Codex manifests are `.agents/plugins/marketplace.json` and `.codex-plugin/plugin.json`.
+The Codex manifest is the root `plugin.json` (Codex extras live under its `extensions["com.openai"]`); this repository carries no marketplace file of its own — see [Migrating from this repository's old marketplace](#migrating-from-this-repositorys-old-marketplace) below.
 
 ### Agent Plugins 1.0 clients (Cursor, GitHub Copilot, VS Code, Kiro)
 
@@ -104,6 +104,20 @@ claude mcp add colgrep -- uv run --quiet --directory /path/to/colgrep-mcp/server
 
 `uvx --from /path/to/colgrep-mcp/server colgrep-mcp` is the one-off equivalent. Note that `claude --plugin-dir /path/to/colgrep-mcp` loads the clone's *skill* but launches the manifest's PyPI pin, not the clone's code — use one of the commands above to test a change.
 
+### Migrating from this repository's old marketplace
+
+This repository used to declare the `cracking-shells` marketplace itself (`.claude-plugin/marketplace.json`, `.agents/plugins/marketplace.json`); that catalogue now lives in [`CrackingShells/Nest`](https://github.com/CrackingShells/Nest), which lists both `colgrep-mcp` and `colgrep-mcp-dev`. A client keeps whichever repository it registered under a marketplace name at add time, so if you already have `cracking-shells` registered as pointing at this repository, adding `CrackingShells/Nest` under the same name does **not** happen automatically — your client will silently keep resolving `cracking-shells` to the old, now-unpublished two-plugin catalogue here, with no error to tell you it's stale. Remove the old registration first:
+
+```bash
+claude plugin marketplace remove cracking-shells
+```
+
+```bash
+codex plugin marketplace remove cracking-shells
+```
+
+Then add `CrackingShells/Nest` as shown above. `colgrep-mcp@cracking-shells` and `colgrep-mcp-dev@cracking-shells` install the same way afterward — only the marketplace's home moved, not its name.
+
 ## What the agent gets
 
 ### Tools
@@ -207,9 +221,11 @@ It refuses to run against this repository, its worktrees or anything under `/pri
 
 The repository root is simultaneously:
 
-- a [Claude Code](https://code.claude.com/docs/en/plugins-reference) plugin (`.claude-plugin/plugin.json`, `.claude-plugin/mcp.json`) and a one-plugin marketplace (`.claude-plugin/marketplace.json`);
+- a [Claude Code](https://code.claude.com/docs/en/plugins-reference) plugin (`.claude-plugin/plugin.json`, `.claude-plugin/mcp.json`);
 - an [Agent Plugins 1.0](https://agent-plugins.org/specification) plugin (`plugin.json`, `mcp.json`);
-- a Codex plugin (`.codex-plugin/plugin.json`, `.codex-plugin/mcp.json`) and marketplace (`.agents/plugins/marketplace.json`).
+- a Codex plugin served by the root `plugin.json`'s `extensions["com.openai"]` block, which Codex parses directly (it auto-wires `skills` to `./skills` and the MCP servers to `mcp.json` by convention).
+
+The `cracking-shells` marketplace catalogue itself — for both Claude Code and Codex — lives in [`CrackingShells/Nest`](https://github.com/CrackingShells/Nest), not in this repository; see [Install](#install).
 
 The Claude Code and Codex plugins share the `hooks/` component ([Hooks](#hooks)); its commands carry the one placeholder both ecosystems expand, `${CLAUDE_PLUGIN_ROOT}`. Every MCP manifest launches the same argv, with no shell script and no root placeholder: `uvx colgrep-mcp==<version>`, where the pin is the plugin's own version — `cz bump` rewrites it with the manifests' `version` fields, so a plugin update always launches its matching server and never a stale cached one. The only placeholder left is `COLGREP_MCP_ROOT=${CLAUDE_PROJECT_DIR}` in the Claude Code manifest's `env`, the one client documented to expand it. `uvx` and `colgrep` must be on `PATH` (see Troubleshooting for GUI clients that start without one). CI runs the suite on Windows as well as macOS and Linux, builds the distribution and checks its metadata on every pull request; pushing a release tag runs `.github/workflows/publish.yml`, which uploads to PyPI through trusted publishing and creates the GitHub release.
 

diff --git a/__roadmap__/nest_migration/README.md b/__roadmap__/nest_migration/README.md
@@ -0,0 +1,58 @@
+# Nest Migration
+
+## Context
+colgrep-mcp currently owns the `cracking-shells` marketplace name in its own repository, listing
+`colgrep-mcp` and the maintainer plugin `colgrep-mcp-dev`. `CrackingShells/Nest` is taking that name
+over as the organisation's single catalogue. This campaign hands the name across and moves this
+repo's manifests to the reshaped generator's output. It is **fully gated** on the
+`agent_plugin_nest` campaign in the playbook: nothing here starts until Nest provably installs
+plugins, because relinquishing a working catalogue before its replacement is proven would leave
+users with neither.
+
+## Reference Documents
+- [R01 Implementation Plan](~/.claude/plans/good-news-overall-it-s-gleaming-wreath.md) — the campaign gate and the Nest entry shape
+- [R02 Traps](https://github.com/CrackingShells/cracking-shells-playbook/blob/main/skills/spawning-agent-plugins/references/traps.md) — marketplace naming and the hooks-duplicate install failure (lives in the playbook repo, not here)
+
+## Goal
+colgrep-mcp ships no marketplace, points users at Nest, and carries manifests in the Agent-Plugins-plus-extensions shape.
+
+## Pre-conditions
+- [ ] `relinquish_marketplace` waits on `agent_plugin_nest/generator/rollout/verify/end_to_end.md` — Nest must install playbook plugins for real before this repo gives up a working catalogue
+- [ ] `regenerate_manifests` waits only on `agent_plugin_nest/generator/generator_reshape.md`, so it can start earlier than its sibling
+- [ ] Nest lists `colgrep-mcp` and `colgrep-mcp-dev`, so nothing is dropped when this repo stops listing them
+- [ ] A playbook checkout containing the reshaped generator is available, and its path is named in the implementer's brief
+
+## Success Gates
+- ✅ Neither `.claude-plugin/marketplace.json` nor `.agents/plugins/marketplace.json` exists [run]
+- ✅ No `.codex-plugin/` directory remains [run]
+- ✅ `check_plugin.py` reports no problems for this repo [run]
+- ✅ README install snippets name `CrackingShells/Nest` and no longer name `CrackingShells/colgrep-mcp` [run]
+- ✅ Installing colgrep-mcp from Nest connects the MCP server and fires the hooks [behavioral]
+
+## Status
+```mermaid
+graph TD
+    relinquish_marketplace[Relinquish Marketplace]:::done
+    regenerate_manifests[Regenerate Manifests]:::done
+    verify[Verification]:::inprogress
+    classDef done       fill:#166534,color:#bbf7d0
+    classDef inprogress fill:#854d0e,color:#fef08a
+    classDef planned    fill:#374151,color:#e5e7eb
+    classDef amendment  fill:#1e3a5f,color:#bfdbfe
+    classDef blocked    fill:#7f1d1d,color:#fecaca
+```
+
+## Nodes
+| Node | Type | Status |
+|:-----|:-----|:-------|
+| `relinquish_marketplace.md` | 📄 Leaf Task | ✅ Done |
+| `regenerate_manifests.md` | 📄 Leaf Task | ✅ Done |
+| `verify/` | 📁 Directory | 🔄 In Progress |
+
+## Amendment Log
+| ID | Date | Source | Nodes Added | Rationale |
+|:---|:-----|:-------|:------------|:----------|
+
+## Progress
+| Node | Branch | Commits | Notes |
+|:-----|:-------|:--------|:------|
diff --git a/__roadmap__/nest_migration/regenerate_manifests.md b/__roadmap__/nest_migration/regenerate_manifests.md
@@ -0,0 +1,47 @@
+# Regenerate Manifests
+
+**Goal**: Move this repository's manifests to the reshaped generator's output — a root Agent-Plugins `plugin.json` carrying `extensions["com.openai"]`, with `.codex-plugin/` gone and no marketplace written back.
+**Pre-conditions**:
+- [ ] `agent_plugin_nest/generator/generator_reshape.md` is merged and its regeneration guard is green on the new baseline
+- [ ] A playbook checkout containing the **reshaped** generator is available; its absolute path is named in the brief
+**Success Gates**:
+- ⬜ No `.codex-plugin/` directory remains [run]
+- ⬜ Root `plugin.json` carries `extensions["com.openai"]` with the full interface block [run]
+- ⬜ Regenerating writes no marketplace file into this repository [run]
+- ⬜ `check_plugin.py` reports no problems [run]
+- ⬜ The version in every manifest is still `0.5.1`; this leaf reshapes, it does not release [run]
+**References**: [R01 §Decisions already settled](~/.claude/plans/good-news-overall-it-s-gleaming-wreath.md) — why the extensions namespace replaces `.codex-plugin/`
+
+## Step 1: Switch the spec to hub mode
+
+**Goal**: Stop the spec from declaring a marketplace, so regeneration cannot resurrect one.
+
+**Implementation Logic**:
+The spec still carries `claude_marketplace` and `codex.marketplace_name`, which is what made this repository the owner of the `cracking-shells` name. Replace them with the generator's hub mode, so `spawn` writes no `.claude-plugin/marketplace.json` and no `.agents/plugins/marketplace.json`.
+
+This step exists because of an ordering hazard, and skipping it is silent: regenerating with the old spec writes both marketplace files back, undoing `relinquish_marketplace` without any error, and leaving two repositories declaring one marketplace name again — the exact condition this whole migration removes. With hub mode set, the two leaves become genuinely order-independent.
+**Deliverables**: the spec consumed by `spawn` (the playbook's `assets/examples/colgrep-mcp.spec.json`, or a repo-local copy if the implementer prefers not to edit the skill's example) — `claude_marketplace` and `codex.marketplace_name` replaced by the hub-mode key
+**Consistency Checks**: `test ! -f .claude-plugin/marketplace.json || echo "marketplace still present - relinquish has not run yet, which is allowed"` (expected: PASS)
+**Commit**: `refactor(plugin): declare hub mode so no marketplace is generated here`
+
+## Step 2: Regenerate with the reshaped generator
+
+**Goal**: Produce the new manifest shape from the spec rather than by hand.
+
+**Implementation Logic**:
+Run the reshaped `spawn_plugin.py --root . spawn --spec <spec> --force` from **the playbook checkout that contains the reshape**. Running the unextended generator would regenerate the old three-manifest shape and appear to succeed; the brief must name the path explicitly, and the implementer should confirm the generator it invoked actually emits `extensions` rather than `.codex-plugin/` before trusting the result.
+
+`--force` is required because the manifests already exist and `put` refuses to overwrite without it. With hub mode set in step 1 there is no `merge_marketplace` call for `--force` to turn destructive, which is the whole reason step 1 comes first. Afterwards delete the `.codex-plugin/` directory: the new generator no longer writes it, but it does not remove what an earlier run left behind.
+**Deliverables**: `plugin.json` — `extensions["com.openai"]` containing the interface block and the Codex hooks path; `.claude-plugin/plugin.json` unchanged in shape; deletion of `.codex-plugin/`
+**Consistency Checks**: `test ! -d .codex-plugin && python3 -c "import json;d=json.load(open('plugin.json'));assert 'com.openai' in d['extensions']"` (expected: PASS)
+**Commit**: `refactor(plugin): express Codex through the com.openai extensions namespace`
+
+## Step 3: Check the tree against itself
+
+**Goal**: Confirm the reshape left a self-consistent plugin, not merely a changed one.
+
+**Implementation Logic**:
+Run `check_plugin.py` and `claude plugin validate .` over the repo. Confirm the version is still `0.5.1` everywhere including the `uvx` pin in the MCP manifests — this leaf changes manifest *shape*, and a version move here would desynchronise the pin from the published artifact and break every launch until a release caught up. Confirm no marketplace file reappeared. Do not point Claude's validator at anything but the Claude manifest and the repo root; it rejects the Codex `interface` block as an unknown field, which is a false alarm rather than a finding.
+**Deliverables**: no new files — validator output recorded in the commit body
+**Consistency Checks**: `python3 -c "import json;d=json.load(open('plugin.json'));assert d['version']=='0.5.1'" && test ! -f .claude-plugin/marketplace.json` (expected: PASS)
+**Commit**: `test(plugin): verify the reshaped manifests are self-consistent`