@squadrules/mcp 5.10.1 → 5.12.0

package/dist/embed-docs/mem/protocol-linking-guide.md

@@ -1,47 +1,44 @@
 ---
-version: "5.10.1"
+version: "5.12.0"
 slug: protocol-linking-guide
-title: Protocol Linking Guide
+title: Adapter Linking Guide
 ---
 
-
-
-# Protocol Linking Guide
+# Adapter Linking Guide
 
 Decision rules for structuring adapter relationships: layers vs chains,
 `activate` vs `forward` + slug, chain-root collapsing, and MCP argument
-validation for deterministic cross-protocol linking.
+validation for deterministic cross-adapter linking.
 
 ## Activation Patterns
 
-**Typically invoked by:** `author-adapter` and
-`critic-loop`.
+**Typically invoked by:** `author-adapter` and `critic-loop`.
 
 **Can be invoked directly when agent needs:**
 - "layers vs chains" / "when to split into multiple adapters"
-- "how to link adapters" / "cross-protocol linking"
+- "how to link adapters" / "cross-adapter linking"
 - "activate vs forward" / "when to use forward with slug"
 - "chain-root collapsing" / "how chain_root works"
 
 **Trigger pattern:** **layers** / **chains** / **linking** / **forward** +
-(slug | adapter | protocol).
+(slug | adapter | workflow).
 
 **Must Never:**
-- Be used as an execution protocol.
+- Be used as an execution adapter.
 - Recommend chaining when layers suffice.
 
 **Must Always:**
-- Be consulted before splitting a protocol into multiple adapters.
+- Be consulted before splitting an adapter into multiple adapters.
 - Be consulted before adding `forward` calls or `chain_root` frontmatter.
 
 **Good trigger examples:**
-- "my protocol is 400 lines, should I split?" → load this
+- "my adapter is 400 lines, should I split?" → load this
 - "how do I link adapter A to adapter B?" → load this
 - "what is chain_root?" → load this
 
 **Bad trigger examples:**
 - "which challenge type for this step?" → use `challenge-type-guide`
-- "create a new protocol" → use `author-adapter`
+- "create a new adapter" → use `author-adapter`
 
 ## Layers vs Chains
 
@@ -55,13 +52,9 @@ cohesive concern.
 - runtime routing to different adapters is needed (Router pattern)
 - a step is reusable across multiple parent adapters (e.g. `critic-loop`)
 
-Chaining is NOT a replacement for layers. A 6-step protocol that fits in 350
+Chaining is NOT a replacement for layers. A 6-step adapter that fits in 350
 lines should stay as one adapter with 6 H2 layers.
 
-```json
-{"contract":{"type":"comment","comment":{"min_length":30},"required":true}}
-```
-
 ## `activate` vs `forward` + slug
 
 | Situation | Use |
@@ -70,15 +63,11 @@ lines should stay as one adapter with 6 H2 layers.
 | Target adapter is known at authoring time | `forward` + slug |
 | Target depends on runtime classification the current adapter cannot resolve | `activate` |
 | Linking to the next adapter in a chain | `forward` + slug |
-| Reusable sub-protocol invoked by multiple parents | `forward` + slug |
+| Reusable sub-adapter invoked by multiple parents | `forward` + slug |
 
 Never call `activate` just to get a slug you already know — it wastes a
 round-trip and introduces non-determinism.
 
-```json
-{"contract":{"type":"comment","comment":{"min_length":30},"required":true}}
-```
-
 ## Chaining Back and Forward
 
 When a family of adapters has a root conductor and smaller domain extensions,
@@ -105,37 +94,24 @@ When the next adapter is known at authoring time or after deterministic runtime
 classification, use `forward` with the target slug. Do not call `activate` just
 to rediscover a slug already known by the current adapter.
 
-Forwarded adapters should receive:
-- current mission brief;
-- safety gates;
-- authorization boundary;
-- evidence requirements;
-- user constraints;
-- reason for forwarding.
+Forwarded adapters should receive: current mission brief, safety gates,
+authorization boundary, evidence requirements, user constraints, and reason for
+forwarding.
 
 Use `activate` only when the next adapter must be discovered from an ambiguous
 runtime need.
 
 ### Multi-layer conductors and extension URIs
 
-When you are executing **`forward`** inside a **multi-layer** adapter (for example
-a root conductor), each continuation follows **`next_call`** for the **same**
+When executing **`forward`** inside a **multi-layer** adapter (for example a root
+conductor), each continuation follows **`next_call`** for the **same**
 `execution_id` until the last layer directs **`reward`**. A layer that mentions
-another adapter URI only as routing guidance — for example
-`squadrules://adapter/e2e-coding-pr-delivery` — does **not** cause the server to
-switch executions: the next **`forward`** in that run still advances the
-**current** adapter’s next layer.
+another adapter URI only as routing guidance does **not** cause the server to
+switch executions.
 
 To run an extension adapter, call **`forward`** with
 `squadrules://adapter/<slug>` as a **new** first call (adapter URI; omit
-`solution`). That starts a **separate** execution with its own layers. Common
-pattern: complete the conductor with **`reward`**, then **`forward`** to the
-extension slug when coding or PR-shaped work should run under that adapter’s
-contracts.
-
-```json
-{"contract":{"type":"comment","comment":{"min_length":30},"required":true}}
-```
+`solution`). That starts a **separate** execution with its own layers.
 
 ## System adapters vs user adapters
 
@@ -149,19 +125,10 @@ call forward with squadrules://adapter/implement-terraform ...
 Slugs are globally unique (enforced by `train`), so resolution is
 deterministic — no scoring, no ambiguity.
 
-```json
-{"contract":{"type":"comment","comment":{"min_length":30},"required":true}}
-```
-
-## MCP argument validation for chain links
-
-A bare `mcp` contract checks only the tool name:
+## MCP forward-link contracts for chain links
 
-```json
-{"contract":{"type":"mcp","mcp":{"tool_name":"forward"},"required":true}}
-```
-
-An `mcp` contract **with `arguments`** verifies the exact target:
+All `mcp` contracts MUST be forward-links with `tool_name: "forward"` and
+`arguments.uri` pointing to the target adapter slug:
 
 ```json
 {"contract":{"type":"mcp","mcp":{"tool_name":"forward","arguments":{"uri":"squadrules://adapter/code-review-policy"}},"required":true}}
@@ -171,18 +138,14 @@ The server validates that `solution.mcp.arguments` is a superset of the
 contract's `mcp.arguments` (subset/deep matching). This proves the agent
 called `forward` with the correct slug, not just any `forward` call.
 
-Use the `arguments` form whenever a step's purpose is to invoke a specific
-known adapter.
-
-```json
-{"contract":{"type":"comment","comment":{"min_length":30},"required":true}}
-```
+Bare `mcp` contracts that check only a tool name (without `arguments.uri`)
+are **not valid** — every mcp contract must specify the forward target.
 
 ## Chain-root collapsing
 
 When a chain has multiple adapters, `activate` might match a mid-chain adapter
 directly. Without protection, the agent would start at the wrong step, missing
-prerequisite context gathered by earlier phases.
+prerequisite context gathered by earlier steps.
 
 **`chain_root` frontmatter field** solves this at the server level. Add it to
 every mid-chain adapter:
@@ -198,14 +161,11 @@ chain_root: implement
 **Server behaviour:** When `activate` returns a match that has `chain_root`,
 the server resolves the slug to the root adapter's URI and replaces the
 choice's `uri` and `next_action` to point there. Multiple mid-chain matches
-from the same chain are deduplicated to a single entry. The agent always
-starts at the chain entry point.
+from the same chain are deduplicated to a single entry.
 
-**Defense in depth — protocol-level safeguards:** Each mid-chain adapter
-should include a **Prerequisites** paragraph in its Activation Patterns
-listing inputs required from earlier phases and directing the agent to start
-from the chain root if those inputs are missing. This catches direct `forward`
-calls that bypass `activate`.
+**Defense in depth:** Each mid-chain adapter should include a **Prerequisites**
+paragraph in its Activation Patterns listing inputs required from earlier steps
+and directing the agent to start from the chain root if those inputs are missing.
 
 **Rules:**
 - The chain root adapter must NOT have `chain_root` in its frontmatter.
@@ -213,10 +173,6 @@ calls that bypass `activate`.
 - `forward` calls within a chain are unaffected — `chain_root` only changes
   `activate` output routing.
 
-```json
-{"contract":{"type":"comment","comment":{"min_length":30},"required":true}}
-```
-
 ## Personal vs System Adapter Linking
 
 | Adapter type | Can `forward` to | Can be `forward`'d from |
@@ -224,11 +180,10 @@ calls that bypass `activate`.
 | System adapter (bundled) | Other system adapters (slug guaranteed to exist) | System or personal adapters |
 | Personal adapter (MCP database) | **Nothing** — must be self-contained | Only via `activate` (runtime discovery) |
 
-Personal adapters use `comment` contracts to describe what the agent should do
-next (e.g. "activate a TDD execution adapter"), not `mcp forward` contracts to
-other personal adapters. A personal adapter that chains to
-`squadrules://adapter/some-personal-slug` will fail at runtime when that slug
-does not exist in the caller's MCP database.
+Personal adapters use `subagent` or `comment` contracts to describe what the
+agent should do next, not `mcp forward` contracts to other personal adapters.
+A personal adapter that chains to `squadrules://adapter/some-personal-slug`
+will fail at runtime when that slug does not exist in the caller's MCP database.
 
 ```json
 {"contract":{"type":"comment","comment":{"min_length":30},"required":true}}
@@ -242,7 +197,7 @@ The agent can now:
 1. decide when to use layers vs chains
 2. choose `activate` vs `forward` + slug correctly
 3. use slug-based linking for all adapters (system and user)
-4. apply MCP argument validation for deterministic chain links
+4. write valid mcp forward-link contracts with arguments
 5. implement `chain_root` collapsing with defense-in-depth safeguards
 6. document chaining back (`chain_root` + prerequisites) and chaining forward
    (`forward` with known slugs) for root + extension families

package/dist/embed-docs/mem/refine-search.md

@@ -1,19 +1,17 @@
 ---
-version: "5.10.1"
+version: "5.12.0"
 slug: refine-search
 title: Get help refining your search
 ---
 
-
-
 # Get help refining your search
 
 **You are an AI agent.** You ran `activate` and got no solid match, or only weak
 / ambiguous matches. This adapter helps you turn a vague request into a better
 query so the next `activate` can find the right adapter.
 
-SQUADRULES principle: before acting, understand the user better. The goal is not to
-repeat the failed phrase with minor edits. The goal is to recover the user's
+SQUADRULES principle: before acting, understand the user better. The goal is not
+to repeat the failed phrase with minor edits. The goal is to recover the user's
 real intent.
 
 ## Activation Patterns
@@ -33,17 +31,17 @@ real intent.
 - Infer the real goal, context, and missing constraints from the user's request.
 - Build a more specific query than the one that failed.
 - Run at most once per user request; if the second activation still fails, stop
-  and offer clarification or protocol creation.
+  and offer clarification or adapter creation.
 
 **Good trigger examples:**
 - activate returned only "refine" / weak matches → run this adapter
-- "No protocol matched 'do the thing'" → run this adapter
+- "No adapter matched 'do the thing'" → run this adapter
 
 **Bad trigger examples:**
 - activate returned a strong match → use that match instead
 - user asked "what adapters exist?" → use `activate` / `spaces`, not this
 
-## Step 1: Extract what the user actually wants
+## Extract User Intent
 
 From the user's original message, identify:
 - the real goal
@@ -51,38 +49,17 @@ From the user's original message, identify:
 - missing constraints
 - likely wording that would help SQUADRULES find the right adapter
 
-Write your analysis as the solution.
-
-```json
-{
-  "contract": {
-    "type": "comment",
-    "comment": { "min_length": 60 },
-    "required": true
-  }
-}
-```
-
-## Step 2: Build and run a refined activate query
-
-Using Step 1, construct one refined query with 3–8 specific words. Do not reuse
-the vague phrase that already failed.
-
-Call `activate` with it.
+Write your analysis, then construct one refined query with 3–8 specific words.
+Do not reuse the vague phrase that already failed.
 
+Call `activate` with the refined query as your next action:
 - **Strong match (score >= 0.5):** pick that choice and `forward`.
 - **Weak matches only:** ask the user to clarify or offer the create path.
 
 Do not loop more than once.
 
 ```json
-{
-  "contract": {
-    "type": "mcp",
-    "mcp": { "tool_name": "activate" },
-    "required": true
-  }
-}
+{"contract":{"type":"comment","comment":{"min_length":60},"required":true}}
 ```
 
 ## Reward Signal

package/dist/resources/embedded-mcp-resources.d.ts

@@ -27,14 +27,10 @@ export declare const mcpResources: {
         "author-adapter": string;
         "bulk-insert-adapters-via-cli": string;
         "challenge-type-guide": string;
-        "create-new-protocol": string;
         "critic-loop-guide": string;
         "critic-loop": string;
-        "phase-critic-guide": string;
-        "phase-critic": string;
         "protocol-linking-guide": string;
         "refine-search": string;
-        "skill-format-guide": string;
     };
 };
 /**

package/dist/resources/embedded-mcp-resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embedded-mcp-resources.d.ts","sourceRoot":"","sources":["../../src/resources/embedded-mcp-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BxB,CAAC;AAEF;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAEhD;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAElD;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAElD;AAED;;GAEG;AACH,wBAAgB,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAE9C;AAED;;GAEG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAE5C;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAE7C;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,GAAG,SAAS,CAgBjE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG1D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAmB3D"}
+{"version":3,"file":"embedded-mcp-resources.d.ts","sourceRoot":"","sources":["../../src/resources/embedded-mcp-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEF;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAEhD;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAElD;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAElD;AAED;;GAEG;AACH,wBAAgB,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAE9C;AAED;;GAEG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAE5C;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAE7C;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,GAAG,SAAS,CAgBjE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG1D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAmB3D"}