kodelyth-ecc 1.8.0 → 1.8.2

package/docs/mcp.md

@@ -1,178 +0,0 @@
-# Kodelyth ECC — MCP Server
-
-The Kodelyth ECC MCP (Model Context Protocol) server is the **universal adapter** that lets any MCP-compatible client consume the full ECC stack: 70 agents, 194 skills, 97 commands, 14 rules, 3 power bundles, and the local BM25 self-learning memory.
-
-If you've ever wished LangGraph, AutoGen, CrewAI, OpenAI Agents SDK, Claude Desktop, or any other agent framework could speak ECC natively — this is that bridge.
-
-Local-only, zero telemetry, stdio transport.
-
----
-
-## Quick start
-
-### 1. Run the server
-
-```bash
-# From npm (recommended):
-npx kodelyth-ecc mcp
-
-# From this repo:
-node scripts/mcp/server.js
-```
-
-The server speaks JSON-RPC over **stdio**. It stays alive until stdin closes.
-
-You'll see one stderr banner on boot, e.g.:
-
-```
-[kodelyth-mcp] ready · 1.7.0 · 16 tools · 6 prompts · 365 resources
-```
-
-### 2. Wire it into your MCP client
-
-#### Claude Desktop (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS)
-
-```json
-{
-  "mcpServers": {
-    "kodelyth-ecc": {
-      "command": "npx",
-      "args": ["-y", "kodelyth-ecc", "mcp"]
-    }
-  }
-}
-```
-
-#### Cursor / Windsurf / any MCP-aware IDE
-
-Use the same `command` + `args` pattern under whatever the IDE's MCP server config key is.
-
-#### Programmatic clients (LangGraph, AutoGen, CrewAI, OpenAI Agents SDK, custom)
-
-Spawn the server as a subprocess and connect via the official MCP client SDK for your language. The transport is **stdio JSON-RPC** — every spec-compliant client supports it.
-
----
-
-## What it exposes
-
-### Tools (16)
-
-| Name | Purpose |
-|---|---|
-| `route_intent` | Suggest the best ECC agent for a user message via token-overlap. Pair with the `routing-rule` prompt for full tier-based routing. |
-| `list_agents` | List every ECC agent (name, description, relpath). |
-| `list_skills` | List every ECC skill. |
-| `list_commands` | List every slash command. |
-| `list_rules` | List every rule file in `rules/common/`. |
-| `list_bundles` | List the power bundles (indie-hacker, red-team, enterprise). |
-| `get_agent` | Fetch the full markdown body of one agent. |
-| `get_skill` | Fetch the full markdown body of one skill. |
-| `get_command` | Fetch the full markdown body of one slash command (with or without leading `/`). |
-| `get_rule` | Fetch a rule file body. |
-| `get_bundle` | Fetch a bundle cheat sheet body. |
-| `recall_memory` | BM25 search across the local Kodelyth memory store. |
-| `capture_memory` | Append a new memory entry (problem + approach + tags). |
-| `memory_stats` | Summary of the local memory store. |
-| `catalog_stats` | Summary of how many agents/skills/commands/rules/bundles are loaded. |
-| `audit_skill_match` | Suggest skills whose description/body overlap a task — useful for deciding which skills to attach as context. |
-
-All tool results follow the MCP `{ content: [{ type: 'text', text: ... }], isError? }` shape. Most return JSON-encoded payloads inside the text channel.
-
-### Prompts (6)
-
-Prompts let clients summon canonical ECC context blocks by name, no tool call needed.
-
-| Name | Returns |
-|---|---|
-| `routing-rule` | The full ECC intent routing rule (10-tier priority system). |
-| `agents-overview` | Compact list of all 70 agents with one-line descriptions. |
-| `skills-overview` | Compact list of all 194 skills. |
-| `commands-overview` | Compact list of all 97 slash commands. |
-| `handoff-chains` | The `agent-handoff` skill body — standard multi-agent chains for new feature, bug fix, refactor, incident, etc. |
-| `devil-mode` | The `/devil-mode` parallel command — fires the adversarial red-team crew. |
-
-### Resources (365)
-
-Every agent, skill, command, rule, and bundle is also addressable as an MCP resource:
-
-```
-kodelyth://agents/<name>
-kodelyth://skills/<name>
-kodelyth://commands/<name>
-kodelyth://rules/<name>
-kodelyth://bundles/<name>
-```
-
-All resources are `text/markdown`. Use `resources/list` to discover, `resources/read` to fetch.
-
----
-
-## Example session
-
-```jsonc
-// → client
-{ "jsonrpc": "2.0", "id": 1, "method": "initialize",
-  "params": { "protocolVersion": "2024-11-05", "capabilities": {},
-              "clientInfo": { "name": "my-client", "version": "0.1.0" } } }
-
-// ← server
-{ "jsonrpc": "2.0", "id": 1, "result": {
-  "protocolVersion": "2024-11-05",
-  "capabilities": { "tools": {}, "resources": {}, "prompts": {} },
-  "serverInfo": { "name": "kodelyth-ecc", "version": "1.7.0" } } }
-
-// → client
-{ "jsonrpc": "2.0", "id": 2, "method": "tools/call",
-  "params": { "name": "route_intent",
-              "arguments": { "message": "production is down and i don't know why",
-                             "top_k": 3 } } }
-
-// ← server (paraphrased)
-{ "result": { "content": [{ "type": "text", "text":
-  "{ \"suggestions\": [
-       { \"agent\": \"incident-commander\", ... },
-       { \"agent\": \"debug-detective\",    ... },
-       { \"agent\": \"silent-failure-hunter\", ... }
-     ] }" }] } }
-```
-
----
-
-## Design notes
-
-- **Pure file reads + memory passthrough.** The server adds no LLM calls of its own. It surfaces ECC context; your client's model decides what to do with it.
-- **No telemetry, no network egress.** stdio only. Local memory only. Reads from this repo's checked-in markdown.
-- **Lazy SDK load.** The MCP SDK is an `optionalDependency` so installs work without it; the `mcp` subcommand prints a friendly install hint if missing.
-- **Cached catalog.** Agent/skill/command lists are cached in-process after first read for sub-millisecond subsequent calls.
-- **Memory store is project-aware.** `recall_memory` accepts an optional `project_root` to scope BM25 results to memories captured against that project, falling back to global memories if scoped results are sparse.
-
----
-
-## Privacy & safety
-
-- The server only reads files under this package and the local memory directory (default `~/.kodelyth/memory/`, override via `KODELYTH_MEMORY_DIR`).
-- It writes only when the client invokes `capture_memory`.
-- No network calls. No analytics. No phone-home.
-- The server never executes arbitrary commands or code. Tools that surface code (`get_agent`, etc.) return markdown documentation, not executable instructions.
-
----
-
-## Troubleshooting
-
-**"Kodelyth MCP server requires `@modelcontextprotocol/sdk`"** — run `npm install @modelcontextprotocol/sdk` once, or rerun via `npx -y kodelyth-ecc mcp` to let npm fetch optional deps.
-
-**Empty results from `recall_memory` on a fresh memory store** — BM25 needs a few documents before IDF scores rise above the default `minScore` floor. Capture 2-3 memories first.
-
-**Resources missing in your client UI** — some MCP clients render only tools and prompts. Resources are still queryable via `resources/list`.
-
----
-
-## Roadmap interactions
-
-- **Phase 2.5 — MCP client mode** will add the inverse: ECC agents consuming external MCP servers (Stripe, GitHub, Postgres, Brave, etc.) — making ECC the MCP **hub**, not just a node.
-- **Phase 2.3 — local dashboard** will visualize live MCP traffic so you can see which tools/prompts/resources clients hit, in real time.
-- **Phase 2.10 — prompt-injection guardrail** will sit in front of MCP responses to scrub jailbreak patterns before they reach client models.
-
----
-
-Built into [Kodelyth ECC](../README.md). MIT licensed. PRs welcome.

package/docs/replay.md

@@ -1,244 +0,0 @@
-# Kodelyth ECC — Session Replay
-
-Bundle, share, and re-run swarm sessions for regression testing, reproducible bug reports, and A/B testing across harnesses, agents, and base refs.
-
-> **Phase 2.8 of the [Devil Roadmap](../README.md).** Companion to the swarm orchestrator (Phase 2.7) — every swarm coordination dir is portable, replayable, and diff-friendly.
-
----
-
-## Why replay
-
-Three concrete wins:
-
-1. **Reproducible bug reports.** Bundle a buggy swarm into a single JSON file, ship to maintainers. They `replay --execute` locally and see the same agent behavior.
-2. **Regression testing.** Save a known-good baseline. After an agent prompt rev, replay against the new agent and diff handoffs. Did quality regress?
-3. **Model A/B testing.** Same task, two harnesses. Side-by-side handoff comparison reveals which model handles the swarm better for your codebase.
-
----
-
-## CLI
-
-| Command | Purpose |
-|---|---|
-| `kodelyth-ecc session-export <session> [flags]` | Bundle a coordination dir to JSON. |
-| `kodelyth-ecc session-import <bundle.json> [flags]` | Restore a bundle to a coordination dir. |
-| `kodelyth-ecc replay <bundle\|session> [flags]` | Re-run a session with variations. |
-
-### `session-export`
-
-```bash
-kodelyth-ecc session-export <session> \
-  [--out file.json] \
-  [--task "..."] [--agents a,b,c] [--harness claude] [--base-ref HEAD] \
-  [--coord-root <dir>]
-```
-
-| Flag | Description |
-|---|---|
-| `<session>` | Required. Directory name under `.orchestration/`. |
-| `--out` | Output JSON path. Default: `.orchestration/<session>.bundle.json`. |
-| `--task "..."` | Enrich `meta.task` for cleaner replays. |
-| `--agents a,b,c` | Enrich `meta.agents`. |
-| `--harness <h>` | Enrich `meta.harness`. |
-| `--base-ref <ref>` | Enrich `meta.base_ref`. |
-| `--coord-root` | Where to look for coordination dirs (default: `<repo>/.orchestration`). |
-
-### `session-import`
-
-```bash
-kodelyth-ecc session-import <bundle.json> \
-  [--target <dir>] [--overwrite] \
-  [--coord-root <dir>]
-```
-
-| Flag | Description |
-|---|---|
-| `<bundle.json>` | Required. Bundle to restore. |
-| `--target` | Output directory. Default: `.orchestration/<session-from-bundle>`. |
-| `--overwrite` | Replace any existing target dir. |
-
-### `replay`
-
-```bash
-kodelyth-ecc replay <bundle.json|session-name> \
-  [--harness h] [--agents a,b,c] [--base-ref ref] [--session NAME] [--replace] \
-  [--execute|--write-only|--json]
-```
-
-| Flag | Description |
-|---|---|
-| `<target>` | Required. Bundle file (ends in `.json`) or session name in `.orchestration/`. |
-| `--harness` | Override launcher harness. |
-| `--agents` | Replace the agent list. |
-| `--base-ref` | Branch base for replay worktrees. |
-| `--session` | Override auto-generated `-replay-N` name. |
-| `--replace` | Tear down any existing session/worktrees with the same names. |
-| `--execute` | Actually spawn worktrees + tmux + agents. |
-| `--write-only` | Just materialize coordination files. |
-| `--json` | Print plan + planConfig. |
-
-Default mode is **dry-run**. Always inspect first.
-
----
-
-## Bundle format
-
-Stable schema `kodelyth.session-bundle/v1`. Single JSON file:
-
-```json
-{
-  "schema":      "kodelyth.session-bundle/v1",
-  "session":     "swarm-2026-05-10-4a",
-  "exported_at": "2026-05-10T17:30:00Z",
-  "exported_by": "kodelyth-ecc@1.7.0",
-  "meta": {
-    "task":     "audit oauth flow",
-    "agents":   ["security-reviewer", "code-reviewer", "pair-programmer", "tdd-guide"],
-    "harness":  "claude",
-    "base_ref": "HEAD"
-  },
-  "workers": [
-    { "slug": "code-reviewer",     "task": "...", "handoff": "...", "status": "..." },
-    { "slug": "pair-programmer",   "task": "...", "handoff": "...", "status": "..." },
-    { "slug": "security-reviewer", "task": "...", "handoff": "...", "status": "..." },
-    { "slug": "tdd-guide",         "task": "...", "handoff": "...", "status": "..." }
-  ]
-}
-```
-
-Pure JSON. No archives, no binaries. Diff-friendly for `git diff` review of regression bundles.
-
----
-
-## How replay reconstructs the task
-
-1. **Prefer `meta.task`** if the bundle was exported with `--task "..."`.
-2. **Fallback: parse the first worker's `task.md`** for the `## Shared Task` section (the agent-shaped header from `scripts/swarm/build-plan.js`).
-3. **Final fallback: parse the orchestrator's own `## Objective` block** (works for hand-written tasks).
-
-This means replay works even on bundles that pre-date the `--task` flag — the heuristic recovers the shared task from the first worker.
-
----
-
-## Replay variations
-
-| Want to test | Flags |
-|---|---|
-| Same task, different model | `--harness claude` vs `--harness codex` (or vary `KODELYTH_ROUTER_*`) |
-| Same task, different agents | `--agents new1,new2,new3` |
-| Same task, new code | `--base-ref refactor-branch` |
-| Custom session name | `--session my-replay-1` |
-| Inspect plan only | (default — dry-run) |
-| Just write coordination files | `--write-only` |
-| Full execute | `--execute` |
-
----
-
-## Hard rules
-
-1. **Never `--execute` without inspecting the dry-run.** Worktrees mutate disk.
-2. **Replays are auto-named** (`-replay-N`) to avoid collisions. Don't manually reuse the origin name.
-3. **Bundles are public artifacts** — strip secrets before sharing externally. Use `opensource-sanitizer` if needed.
-4. **A/B comparisons require human review.** Never auto-pick a "winner" between two replays.
-5. **Don't replay across incompatible base refs.** A swarm built against `main` may break if replayed against `feature-branch` with conflicting changes.
-
----
-
-## Pairing with the rest of ECC
-
-| Pairs with | How |
-|---|---|
-| **2.7 swarm orchestrator** | Replay only works on swarm coordination dirs. The two ship together. |
-| **2.4 cost router** | Vary `KODELYTH_ROUTER_*` env vars across replays for A/B model tests. |
-| **2.10 token-budget hook** | Replays open new sessions with fresh budgets — no spillover from the origin. |
-| **2.5 MCP client mode** | Replays inherit the same MCP registry, so tool calls reproduce. |
-| **opensource-sanitizer** | Run on a bundle before sharing externally. |
-
----
-
-## Examples
-
-### Reproducible bug report
-
-```bash
-# 1. Capture the buggy run
-npx kodelyth-ecc swarm --task "..." --execute
-
-# 2. After it finishes, export with rich meta
-npx kodelyth-ecc session-export swarm-2026-05-10-4a \
-  --task "..." --agents code-reviewer,security-reviewer --harness claude \
-  --out bug-report.bundle.json
-
-# 3. Strip secrets if needed
-# (manually edit bug-report.bundle.json)
-
-# 4. Ship to maintainers
-gh issue create --body "Reproducer attached: bug-report.bundle.json"
-```
-
-### Model A/B test
-
-```bash
-# Run with claude
-npx kodelyth-ecc swarm --task "refactor payments module" --agents 4 --harness claude --execute
-npx kodelyth-ecc session-export swarm-...               --out claude-run.bundle.json
-
-# Replay with codex against the same task
-npx kodelyth-ecc replay claude-run.bundle.json --harness codex --execute
-npx kodelyth-ecc session-export swarm-...-replay-1      --out codex-run.bundle.json
-
-# Compare handoffs
-diff <(jq -r '.workers[] | "\(.slug):\n\(.handoff)"' claude-run.bundle.json) \
-     <(jq -r '.workers[] | "\(.slug):\n\(.handoff)"' codex-run.bundle.json)
-```
-
-### Regression check after agent rev
-
-```bash
-# 1. Save a baseline.
-npx kodelyth-ecc session-export swarm-baseline --out baseline.bundle.json
-
-# 2. After updating an agent prompt, replay.
-npx kodelyth-ecc replay baseline.bundle.json --execute
-npx kodelyth-ecc session-export swarm-baseline-replay-1 --out replay.bundle.json
-
-# 3. Inspect the diff manually — has quality regressed?
-diff <(jq -r '.workers[] | "\(.slug)\n\(.handoff)"' baseline.bundle.json) \
-     <(jq -r '.workers[] | "\(.slug)\n\(.handoff)"' replay.bundle.json)
-```
-
----
-
-## Programmatic use
-
-```js
-const bundleLib = require('kodelyth-ecc/scripts/replay/bundle.js');
-const replayLib = require('kodelyth-ecc/scripts/replay/replay.js');
-const { buildOrchestrationPlan, executePlan } = require('kodelyth-ecc/scripts/lib/tmux-worktree-orchestrator.js');
-
-// Read a bundle
-const bundle = bundleLib.readBundle('./oauth-audit.bundle.json');
-
-// Build a replay plan with overrides
-const planConfig = replayLib.buildReplayPlanConfig(bundle, {
-  harness: 'codex',
-  baseRef: 'main',
-});
-
-// Execute
-const plan = buildOrchestrationPlan(planConfig);
-const result = executePlan(plan);
-console.log(`replay started: ${result.sessionName}`);
-```
-
----
-
-## Roadmap interactions
-
-- **Phase 2.3 — local dashboard** will surface replay history and side-by-side handoff diffs for the same task across runs.
-- **Phase 2.6 — sandbox layer** will isolate replay execution in Docker so re-running an external bundle doesn't trust the source.
-- **Phase 2.2 — SWE-Bench harness** will use bundle replay as its evaluation primitive.
-
----
-
-Built into [Kodelyth ECC](../README.md). MIT licensed.

package/docs/supply-chain.md

@@ -1,207 +0,0 @@
-# Supply chain — SBOM, manifest, SLSA provenance
-
-> Phase 2.9 of the Devil Roadmap. Every kodelyth-ecc release ships with three independent supply-chain artifacts so any consumer (audit team, downstream agent, security tool) can answer "where does this code come from, can I trust it, and has it been tampered" without trusting kodelyth-ecc.
-
----
-
-## What ships with every release
-
-| Artifact | Format | Where to find it | Issued by |
-|---|---|---|---|
-| **SLSA build provenance** | sigstore-signed npm provenance | npmjs.com/package/kodelyth-ecc → "Provenance" tab | npm + GitHub OIDC (`npm publish --provenance`) |
-| **CycloneDX SBOM** | CycloneDX 1.5 JSON | GitHub release page → `kodelyth-ecc-sbom.cdx.json` | `kodelyth-ecc sbom` |
-| **Content manifest** | sha256 manifest JSON | GitHub release page → `kodelyth-ecc-manifest.json` | `kodelyth-ecc manifest` |
-
-All three are emitted by `.github/workflows/publish.yml` on every tagged release.
-
----
-
-## CLI
-
-### `kodelyth-ecc sbom`
-
-```
-kodelyth-ecc sbom [--root DIR] [--out FILE] [--json]
-```
-
-Generates a CycloneDX 1.5 software bill of materials.
-
-| Field | Source | Notes |
-|---|---|---|
-| `metadata.component` | `package.json` | The kodelyth-ecc package itself |
-| `components[]` | `package-lock.json` v3 | One entry per locked dependency, including dev + transitive |
-| `purl` | `pkg:npm/<name>@<version>` | scoped packages keep the leading `@` |
-| `licenses` | lockfile `license` | normalized to CycloneDX shape |
-| `hashes` | npm SRI (`integrity`) | base64 → hex, algo mapped to `SHA-256/384/512` |
-| `dependencies[]` | root entry's `dependencies` + `optionalDependencies` | Direct edges only |
-| `serialNumber` | `urn:uuid:<sha256("name@version|timestamp")>` | Stable for same inputs |
-
-**Pure function. No network. No exec.**
-
-### `kodelyth-ecc manifest`
-
-```
-kodelyth-ecc manifest [--root DIR] [--out FILE] [--json]
-```
-
-Generates a sha256 content manifest of every shipped asset.
-
-```json
-{
-  "schema": "kodelyth.content-manifest/v1",
-  "package": "kodelyth-ecc",
-  "pkg_version": "1.7.0",
-  "generated_at": "2026-05-10T17:00:00Z",
-  "file_count": 730,
-  "digest": "20813125…",
-  "files": [
-    { "path": "agents/code-reviewer.md", "size": 4521, "sha256": "…" }
-  ]
-}
-```
-
-Walks: `agents/`, `skills/`, `commands/`, `rules/`, `hooks/`, `scripts/`, `bin/`, `parallel-commands/`, `bundles/`, plus root files (`package.json`, `README.md`, `CHANGELOG.md`, `VERSION`, `install.sh`, `install.ps1`).
-
-Skips: `node_modules/`, `.git/`, `.DS_Store`, `__pycache__/`, `*.pyc`.
-
-The top-level `digest` is the sha256 over the deterministic JSON of `files[]`. Two runs against the same source state produce the same digest.
-
-### `kodelyth-ecc verify`
-
-```
-kodelyth-ecc verify [--root DIR] [--manifest FILE] [--json]
-```
-
-Compares disk against the manifest:
-
-| Category | Means | Fails verify? |
-|---|---|---|
-| `ok` | sha256 matches | No |
-| `modified` | hash differs | **Yes** |
-| `missing` | not on disk | **Yes** |
-| `extra` | on disk but not in manifest | No (advisory) |
-
-Exits `0` on `ok=true`, `1` otherwise. With `--json`, prints the full report:
-
-```json
-{
-  "ok": false,
-  "summary": { "total_in_manifest": 730, "ok": 729, "modified": 1, "missing": 0, "extra": 0 },
-  "details": {
-    "ok": ["agents/api-guardian.md", …],
-    "modified": [{ "path": "agents/code-reviewer.md", "expected_sha256": "…", "actual_sha256": "…" }],
-    "missing": [],
-    "extra": []
-  }
-}
-```
-
----
-
-## Verifying a downstream install
-
-```bash
-# 1) Download the manifest from the GitHub release that matches your installed version.
-gh release download v1.7.3 -p kodelyth-ecc-manifest.json -O /tmp/manifest.json
-
-# 2) Run verify against your installed copy.
-npx kodelyth-ecc verify --root "$(npm root -g)/kodelyth-ecc" --manifest /tmp/manifest.json
-```
-
-Or, if you cloned the repo:
-
-```bash
-cd ~/path/to/kodelyth-ecc
-node bin/kodelyth-ecc.js verify --manifest /tmp/manifest.json
-```
-
-A successful run looks like:
-
-```
-Kodelyth ECC supply-chain verify
-  package:           kodelyth-ecc@1.7.0
-  manifest digest:   20813125baad127bb578e4cbad6b72e2c4721d71cd236b6c039e7c155cd322ef
-  files in manifest: 730
-    ✓ ok:       730
-    ✗ modified: 0
-    ✗ missing:  0
-    ⚠ extra:    0 (advisory)
-
-✓ verify OK
-```
-
----
-
-## SLSA provenance
-
-`.github/workflows/publish.yml` runs `npm publish --provenance --access public`. This requires `id-token: write` (set on the job) and uses GitHub's OIDC token to sign a sigstore-backed provenance statement that:
-
-1. Pins the workflow file SHA + commit SHA that produced the build.
-2. Pins the GitHub repo + ref.
-3. Pins the npm package name + version.
-
-Result: **SLSA Level 3** by npm's published criteria (hosted build platform, signed provenance, verifiable from npm registry metadata).
-
-To verify a downloaded tarball matches the npm-published provenance:
-
-```bash
-npm audit signatures kodelyth-ecc
-# or
-npm view kodelyth-ecc --json | jq .dist.signatures
-```
-
----
-
-## Programmatic API
-
-```js
-const { generateSBOM }          = require('kodelyth-ecc/scripts/supply-chain/sbom.js');
-const { generateManifest }      = require('kodelyth-ecc/scripts/supply-chain/manifest.js');
-const { verifyAgainstManifest } = require('kodelyth-ecc/scripts/supply-chain/verify.js');
-
-const bom      = generateSBOM({ rootDir });
-const manifest = generateManifest({ rootDir });
-const report   = verifyAgainstManifest({ rootDir, manifest });
-```
-
-All three are pure functions. Safe to call from a CI step, an MCP tool, or any external automation. They never spawn subprocesses, never make network calls, and never write to disk.
-
----
-
-## When to call which surface
-
-| Situation | Use |
-|---|---|
-| Compliance team wants an SBOM for Dependency-Track / Snyk ingestion | `sbom --out` |
-| Need to ship a tamper-detection seal with a release artifact | `manifest --out` |
-| Validating a downstream install hasn't been edited | `verify` |
-| CI gate that should fail on tamper | `verify --json` + script that checks `.ok` |
-| Reproducibility check between two release archives | `manifest` on both, diff `digest` |
-
----
-
-## Composition with other phases
-
-| Pair | Effect |
-|---|---|
-| **2.7 swarm + verify** | Run `verify` as a pre-flight before spawning workers. Refuse to spawn from a tampered toolkit. |
-| **2.8 replay + manifest** | Embed the manifest digest of the producing toolkit into a session bundle. Replays then verify they're being run by the same toolkit version. |
-| **2.10 safety hooks + verify** | The token-budget hook can read the manifest digest at session start to surface a "you're running tampered tooling" warning. |
-| **2.1 MCP server + verify** | Expose `verify` as an MCP tool. Downstream agents can call it before trusting any other ECC tool's output. |
-
----
-
-## Hard rules
-
-1. Treat the manifest published with a release as authoritative. **Do not** regenerate locally and pretend it's the same.
-2. **Do not** suppress a non-zero exit from `verify` in CI. Modified or missing files mean a tamper or a partial install — both are blocking.
-3. **Do not** include `node_modules/` or `.git/` in the manifest. The skip list is in `scripts/supply-chain/manifest.js`; extend deliberately if needed.
-4. **Do not** store secrets in any file under the shipped directory list. Anything that's manifested gets its sha256 published.
-
----
-
-## See also
-
-- `skills/supply-chain-verification/SKILL.md` — explicit-invocation skill
-- `commands/verify-supply-chain.md` — `/verify-supply-chain` slash command
-- `.github/workflows/publish.yml` — release pipeline (npm provenance + SBOM + manifest upload)