@cleocode/skills 2026.4.0 → 2026.4.2

package/skills/ct-grade-v2-1/SKILL.md

@@ -4,22 +4,22 @@ description: >-
   CLEO session grading and A/B behavioral analysis with token tracking. Evaluates agent
   session quality via a 5-dimension rubric (S1 session discipline, S2 discovery efficiency,
   S3 task hygiene, S4 error protocol, S5 progressive disclosure). Supports three modes:
-  (1) scenario — run playbook scenarios S1-S5 against MCP or CLI; (2) ab — blind A/B
-  comparison of CLEO MCP gateway vs CLI for same domain operations with token cost
+  (1) scenario — run playbook scenarios S1-S5 via CLI; (2) ab — blind A/B
+  comparison of different CLI configurations for same domain operations with token cost
   measurement; (3) blind — spawn two agents with different configurations, blind-comparator
   picks winner, analyzer produces recommendation. Use when grading agent sessions, running
-  grade playbook scenarios, comparing MCP vs CLI behavioral differences, measuring token
-  usage across interface types, or performing multi-run blind A/B evaluation with statistical
+  grade playbook scenarios, comparing behavioral differences, measuring token
+  usage across configurations, or performing multi-run blind A/B evaluation with statistical
   analysis and comparative report. Triggers on: grade session, evaluate agent behavior,
-  A/B test CLEO interfaces, run grade scenario, token usage analysis, behavioral rubric,
-  protocol compliance scoring, MCP vs CLI comparison.
-argument-hint: "[mode=scenario|ab|blind] [scenario=s1-s5|all] [interface=mcp|cli|both] [runs=N] [session-id=<id>]"
+  A/B test CLEO configurations, run grade scenario, token usage analysis, behavioral rubric,
+  protocol compliance scoring.
+argument-hint: "[mode=scenario|ab|blind] [scenario=s1-s5|all] [runs=N] [session-id=<id>]"
 allowed-tools: ["Bash(python *)", "Bash(cleo-dev *)", "Bash(cleo *)", "Bash(kill *)", "Bash(lsof *)", "Agent", "Read", "Write", "Glob"]
 ---
 
 # ct-grade v2.1 — CLEO Grading and A/B Testing
 
-Session grading and A/B behavioral analysis for CLEO protocol compliance. Three operating modes cover everything from single-session scoring to multi-run blind comparisons between MCP and CLI interfaces.
+Session grading and A/B behavioral analysis for CLEO protocol compliance. Three operating modes cover everything from single-session scoring to multi-run blind comparisons between different CLI configurations.
 
 ## On Every /ct-grade Invocation
 
@@ -48,7 +48,7 @@ echo "Grade viewer stopped."
 | Mode | Purpose | Key Output |
 |---|---|---|
 | `scenario` | Run playbook scenarios S1-S5 as graded sessions | GradeResult per scenario |
-| `ab` | Run same domain operations via MCP AND CLI, compare | comparison.json + token delta |
+| `ab` | Run same domain operations with two configurations, compare | comparison.json + token delta |
 | `blind` | Two agents run same task, blind comparator picks winner | analysis.json + winner |
 
 ## Parameters
@@ -57,7 +57,7 @@ echo "Grade viewer stopped."
 |---|---|---|---|
 | `mode` | `scenario\|ab\|blind` | `scenario` | Operating mode |
 | `scenario` | `s1\|s2\|s3\|s4\|s5\|all` | `all` | Grade playbook scenario(s) to run |
-| `interface` | `mcp\|cli\|both` | `both` | Which interface to exercise |
+| `interface` | `cli` | `cli` | Interface to exercise (CLI only) |
 | `domains` | comma list | `tasks,session` | Domains to test in `ab` mode |
 | `runs` | integer | `3` | Runs per configuration for statistical confidence |
 | `session-id` | string | — | Grade a specific existing session (skips execution) |
@@ -70,12 +70,12 @@ echo "Grade viewer stopped."
 /ct-grade session-id=<id>
 ```
 
-**Run scenario S4 (Full Lifecycle) on MCP:**
+**Run scenario S4 (Full Lifecycle):**
 ```
-/ct-grade mode=scenario scenario=s4 interface=mcp
+/ct-grade mode=scenario scenario=s4
 ```
 
-**A/B compare MCP vs CLI for tasks + session domains (3 runs each):**
+**A/B compare two configurations for tasks + session domains (3 runs each):**
 ```
 /ct-grade mode=ab domains=tasks,session runs=3
 ```
@@ -93,10 +93,10 @@ echo "Grade viewer stopped."
 
 1. Set up output dir with `python $CLAUDE_SKILL_DIR/scripts/setup_run.py --mode scenario --scenario <id> --output-dir <dir>`
 2. For each scenario, spawn a `scenario-runner` agent:
-   - Agent start: `mutate session start { "grade": true, "name": "<scenario-id>-<interface>" }`
+   - Agent start: `cleo session start --scope global --name "<scenario-id>" --grade`
    - Agent executes the scenario operations (see [references/playbook-v2.md](references/playbook-v2.md))
-   - Agent end: `mutate session end`
-   - Agent runs: `query admin grade { "sessionId": "<id>" }`
+   - Agent end: `cleo session end`
+   - Agent runs: `ct grade <sessionId>`
    - Agent saves: `GradeResult` to `<output-dir>/<scenario>/grade.json`
 3. Capture `total_tokens` + `duration_ms` from task notification → `timing.json`
 4. Run: `python $CLAUDE_SKILL_DIR/scripts/generate_report.py --run-dir <dir> --mode scenario`
@@ -105,16 +105,16 @@ echo "Grade viewer stopped."
 
 1. Set up run dir with `python $CLAUDE_SKILL_DIR/scripts/setup_run.py --mode ab --output-dir <dir>`
 2. For each target domain, spawn TWO agents in the SAME turn:
-   - **Arm A** (MCP): `agents/scenario-runner.md` with `INTERFACE=mcp`
-   - **Arm B** (CLI): `agents/scenario-runner.md` with `INTERFACE=cli`
+   - **Arm A**: `agents/scenario-runner.md` with configuration A
+   - **Arm B**: `agents/scenario-runner.md` with configuration B
    - Capture tokens from both task notifications immediately
-3. Pass both outputs to `agents/blind-comparator.md` (does NOT know which is MCP vs CLI)
+3. Pass both outputs to `agents/blind-comparator.md` (does NOT know which configuration is which)
 4. Comparator writes `comparison.json`
 5. Run `python $CLAUDE_SKILL_DIR/scripts/generate_report.py --run-dir <dir> --mode ab`
 
 ### Mode: blind
 
-Same as `ab` but configurations may differ beyond MCP/CLI (e.g., different session scopes, different agent prompts). The comparator is always blind to configuration identity.
+Same as `ab` but configurations may differ (e.g., different session scopes, different agent prompts). The comparator is always blind to configuration identity.
 
 ---
 
@@ -127,7 +127,7 @@ timing = {
   "total_tokens": task.total_tokens,     # from task notification — EPHEMERAL
   "duration_ms": task.duration_ms,       # from task notification
   "arm": "arm-A",
-  "interface": "mcp",
+  "interface": "cli",
   "scenario": "s4",
   "run": 1,
   "executor_start": start_iso,
@@ -154,11 +154,9 @@ If running without task notifications (no total_tokens available):
 | S2 Discovery Efficiency | 20 | `find:list` ratio ≥80% (+15), `tasks.show` used (+5) |
 | S3 Task Hygiene | 20 | Starts 20, -5 per add without description, -3 if subtask no exists check |
 | S4 Error Protocol | 20 | Starts 20, -5 per unrecovered E_NOT_FOUND, -5 if duplicates |
-| S5 Progressive Disclosure | 20 | `admin.help`/skill lookup (+10), MCP `query` gateway used (+10) |
+| S5 Progressive Disclosure | 20 | `admin.help`/skill lookup (+10), progressive disclosure used (+10) |
 
-**Grade letters:** A≥90, B≥75, C≥60, D≥45, F<45
-
-**Note:** CLI-only sessions always score 0 on S5 — `metadata.gateway` is not set by the CLI adapter. MCP earns +10 automatically.
+**Grade letters:** A>=90, B>=75, C>=60, D>=45, F<45
 
 ---
 
@@ -227,11 +225,11 @@ Shows historical grades from GRADES.jsonl, A/B summaries from any workspace subd
 
 ---
 
-## MCP Grade Operations
+## CLI Grade Operations
 
-| Gateway | Domain | Operation | Params |
-|---|---|---|---|
-| `query` | `admin` | `grade` | `{ "sessionId": "<id>" }` |
-| `query` | `admin` | `grade.list` | — |
-| `mutate` | `session` | `start` | `{ "grade": true, "name": "<n>", "scope": "global" }` |
-| `mutate` | `session` | `end` | — |
+| Command | Description |
+|---------|-------------|
+| `ct grade <sessionId>` | Grade a specific session |
+| `ct grade --list` | List past grade results |
+| `ct session start --scope global --name "<n>" --grade` | Start graded session |
+| `ct session end` | End session |

package/skills/ct-grade-v2-1/agents/scenario-runner.md

@@ -1,12 +1,11 @@
 # Scenario Runner Agent
 
-You are a CLEO grade scenario executor. Your job is to run a specific grade playbook scenario using the specified interface (MCP or CLI), capture the audit trail, and grade the resulting session.
+You are a CLEO grade scenario executor. Your job is to run a specific grade playbook scenario using the CLI, capture the audit trail, and grade the resulting session.
 
 ## Inputs
 
 You will receive:
 - `SCENARIO`: Which scenario to run (s1|s2|s3|s4|s5|s6|s7|s8|s9|s10)
-- `INTERFACE`: Which interface to use (mcp|cli)
 - `OUTPUT_DIR`: Where to write results
 - `PROJECT_DIR`: Path to the CLEO project (for cleo-dev --cwd)
 - `RUN_NUMBER`: Integer (1, 2, 3...) for repeated runs
@@ -17,30 +16,24 @@ You will receive:
 
 Note the ISO timestamp before any operations.
 
-### Step 2: Start a graded session via MCP (always use MCP for session lifecycle)
+### Step 2: Start a graded session
 
-```
-mutate session start { "grade": true, "name": "grade-<SCENARIO>-<INTERFACE>-run<RUN>", "scope": "global" }
+```bash
+cleo-dev --cwd <PROJECT_DIR> session start --grade --name "grade-<SCENARIO>-run<RUN>" --scope global
 ```
 
 Save the returned `sessionId`.
 
 If this fails (DB migration error, ENOENT, or non-zero exit):
 - Write `grade.json: { "error": "DB_UNAVAILABLE", "totalScore": null }`
-- Write `timing.json: { "error": "DB_UNAVAILABLE", "total_tokens": null, "duration_ms": null, "arm": "<INTERFACE>", "scenario": "<SCENARIO>", "run": <RUN_NUMBER>, "interface": "<INTERFACE>", "executor_start": "<ISO>", "executor_end": "<ISO>" }`
+- Write `timing.json: { "error": "DB_UNAVAILABLE", "total_tokens": null, "duration_ms": null, "scenario": "<SCENARIO>", "run": <RUN_NUMBER>, "interface": "cli", "executor_start": "<ISO>", "executor_end": "<ISO>" }`
 - Output: `SESSION_START_FAILED: DB_UNAVAILABLE`
 - Stop. Do NOT abort silently.
 
 ### Step 3: Execute scenario operations
 
-Follow the exact operation sequence from the scenario playbook. Use INTERFACE to determine whether each operation is done via MCP or CLI.
-
-**MCP operations** use the query/mutate gateway:
-```
-query tasks find { "status": "active" }
-```
+Follow the exact operation sequence from the scenario playbook. All operations use the CLI.
 
-**CLI operations** use cleo-dev (prefer) or cleo, with PROJECT_DIR as cwd if provided:
 ```bash
 cleo-dev --cwd <PROJECT_DIR> find --status active
 ```
@@ -49,14 +42,14 @@ Scenario sequences are in [../references/playbook-v2.md](../references/playbook-
 
 ### Step 4: End the session
 
-```
-mutate session end
+```bash
+cleo-dev --cwd <PROJECT_DIR> session end
 ```
 
 ### Step 5: Grade the session
 
-```
-query admin grade { "sessionId": "<saved-id>" }
+```bash
+cleo-dev --cwd <PROJECT_DIR> check grade --session "<saved-id>"
 ```
 
 Save the full GradeResult JSON.
@@ -65,7 +58,7 @@ Save the full GradeResult JSON.
 
 Record every operation you executed as a JSONL file. Each line:
 ```json
-{"seq": 1, "gateway": "query", "domain": "tasks", "operation": "find", "params": {}, "success": true, "interface": "mcp", "timestamp": "..."}
+{"seq": 1, "domain": "tasks", "operation": "find", "params": {}, "success": true, "interface": "cli", "timestamp": "..."}
 ```
 
 ### Step 7: Write output files
@@ -89,10 +82,9 @@ Write to `<OUTPUT_DIR>/<SCENARIO>/arm-<INTERFACE>/`:
 **timing.json** — Fill in what you can; orchestrator fills `total_tokens` and `duration_ms`:
 ```json
 {
-  "arm": "<INTERFACE>",
   "scenario": "<SCENARIO>",
   "run": <RUN_NUMBER>,
-  "interface": "<INTERFACE>",
+  "interface": "cli",
   "session_id": "<session-id>",
   "executor_start": "<ISO>",
   "executor_end": "<ISO>",
@@ -109,19 +101,8 @@ Note: `total_tokens` and `duration_ms` are filled by the orchestrator from the t
 
 After receiving the grade result, record the exchange to persist token measurements:
 
-```
-mutate admin token {
-  "action": "record",
-  "sessionId": "<session-id>",
-  "transport": "mcp",
-  "domain": "admin",
-  "operation": "grade",
-  "metadata": {
-    "scenario": "<SCENARIO>",
-    "interface": "<INTERFACE>",
-    "run": <RUN_NUMBER>
-  }
-}
+```bash
+cleo-dev --cwd <PROJECT_DIR> admin token record --session "<session-id>" --domain admin --operation grade --metadata '{"scenario":"<SCENARIO>","run":<RUN_NUMBER>}'
 ```
 
 Save the returned `id` as `token_usage_id` in timing.json.
@@ -170,7 +151,6 @@ Do NOT do these during scenario execution — they will lower the grade intentio
 When complete, summarize:
 ```
 SCENARIO: <id>
-INTERFACE: <interface>
 RUN: <n>
 SESSION_ID: <id>
 TOTAL_SCORE: <n>/100

package/skills/ct-grade-v2-1/grade-viewer/eval-report.md

@@ -3,9 +3,12 @@
 **Generated:** 2026-03-07 23:47 UTC  
 **Source:** `/tmp/ct-grade-eval`
 
+> **DEPRECATED**: This report was generated when MCP was still supported. MCP has been removed.
+> All operations now use the CLI exclusively. These results are retained for historical reference only.
+
 ---
 
-## MCP vs CLI Blind A/B Results
+## Historical: MCP vs CLI Blind A/B Results
 
 **Overall winner: MCP**  
 

package/skills/ct-grade-v2-1/references/ab-testing.md

@@ -1,18 +1,21 @@
 # Blind A/B Testing Protocol
 
-Methodology for blind comparison of MCP vs CLI interface usage in CLEO.
+Methodology for blind comparison of grade scenario results in CLEO.
+
+> **Note**: MCP support was removed. All operations now use the CLI exclusively.
+> This protocol compares different CLI configurations, binary versions, or parameter sets.
 
 ---
 
 ## Agent-Based Execution (Canonical)
 
-The canonical A/B approach uses Claude Code Agents to run scenarios end-to-end via the live MCP/CLI interfaces. This avoids subprocess initialization issues and captures real token data from task notifications.
+The canonical A/B approach uses Claude Code Agents to run scenarios end-to-end via the CLI. This captures real token data from task notifications.
 
 ### Execution Flow
 
 1. Run `python scripts/setup_run.py` to create run structure and print the execution plan
-2. Follow the plan: spawn scenario-runner agents in parallel (arm-A MCP, arm-B CLI)
-3. Immediately capture `total_tokens` from each task notification → `timing.json`
+2. Follow the plan: spawn scenario-runner agents in parallel (arm-A, arm-B with different configurations)
+3. Immediately capture `total_tokens` from each task notification to `timing.json`
 4. Spawn blind-comparator agent after both arms complete
 5. Run `python scripts/token_tracker.py --run-dir <dir>` to aggregate tokens
 6. Run `python scripts/generate_report.py --run-dir <dir>` for final report
@@ -22,10 +25,10 @@ The canonical A/B approach uses Claude Code Agents to run scenarios end-to-end v
 ```python
 # After EACH agent task completes, fill timing.json immediately:
 timing = {
-  "total_tokens": task.total_tokens,   # EPHEMERAL — capture now or lose it
+  "total_tokens": task.total_tokens,   # EPHEMERAL -- capture now or lose it
   "duration_ms": task.duration_ms,
   "arm": "arm-A",
-  "interface": "mcp",
+  "interface": "cli",
   "scenario": "s4",
   "run": 1,
 }
@@ -35,30 +38,7 @@ Token data priority:
 1. `total_tokens` from Claude Code Agent task notification (canonical)
 2. OTel `claude_code.token.usage` (when `CLAUDE_CODE_ENABLE_TELEMETRY=1`)
 3. `output_chars / 3.5` (JSON response estimate)
-4. `entryCount × 150` (coarse proxy from GRADES.jsonl)
-
----
-
-## Subprocess-Based Execution (Fallback)
-
-For automated testing without agent delegation, use `run_ab_test.py`. This invokes CLEO via subprocess and requires a migrated `tasks.db`.
-
----
-
-## What We're Testing
-
-| Side | Interface | Mechanism |
-|------|-----------|-----------|
-| **A** (MCP) | JSON-RPC via stdio to CLEO MCP server | `node dist/mcp/index.js` with JSON-RPC messages |
-| **B** (CLI) | Shell commands via subprocess | `cleo-dev <domain> <operation> [params]` |
-
-Both sides call the same underlying `src/dispatch/` layer. The A/B test isolates:
-- **Output format differences** — MCP returns structured JSON envelopes; CLI may add ANSI/formatting
-- **Response size** — character counts as token proxy
-- **Latency** — wall-clock time per operation
-- **Data equivalence** — do they return the same logical data?
-
-Blind assignment means the comparator does not know which result came from MCP vs CLI when producing the quality verdict.
+4. `entryCount x 150` (coarse proxy from GRADES.jsonl)
 
 ---
 
@@ -89,11 +69,11 @@ ab-results/
 ## Blind Assignment
 
 The `run_ab_test.py` script randomly shuffles which side gets labeled "A" vs "B" for each run. The comparator agent sees only:
-- Output labeled "A" (could be MCP or CLI)
-- Output labeled "B" (could be MCP or CLI)
+- Output labeled "A"
+- Output labeled "B"
 - The original request prompt
 
-The `meta.json` records the true identity (`a_is_mcp: true|false`) per run. `generate_report.py` de-blinds after all comparisons are done.
+The `meta.json` records the true identity per run. `generate_report.py` de-blinds after all comparisons are done.
 
 ---
 
@@ -104,7 +84,7 @@ The `meta.json` records the true identity (`a_is_mcp: true|false`) per run. `gen
 | `output_chars` | `len(response_json_str)` |
 | `estimated_tokens` | `output_chars / 4` (approximation) |
 | `duration_ms` | wall clock from subprocess start to end |
-| `success` | `response.success === true` (MCP) or exit code 0 (CLI) |
+| `success` | exit code 0 |
 | `data_equivalent` | compare key fields between A and B response |
 
 ---
@@ -136,17 +116,17 @@ After N runs, `generate_report.py` computes:
 
 ```json
 {
-  "wins": { "mcp": 0, "cli": 0, "tie": 0 },
-  "win_rate": { "mcp": 0.0, "cli": 0.0 },
+  "wins": { "arm_a": 0, "arm_b": 0, "tie": 0 },
+  "win_rate": { "arm_a": 0.0, "arm_b": 0.0 },
   "token_delta": {
-    "mean_mcp_chars": 0,
-    "mean_cli_chars": 0,
+    "mean_a_chars": 0,
+    "mean_b_chars": 0,
     "delta_chars": 0,
     "delta_pct": "+0%"
   },
   "latency_delta": {
-    "mean_mcp_ms": 0,
-    "mean_cli_ms": 0,
+    "mean_a_ms": 0,
+    "mean_b_ms": 0,
     "delta_ms": 0
   },
   "data_equivalence_rate": 1.0,
@@ -167,48 +147,18 @@ The blind comparator evaluates each side on:
 | **Completeness** | Does the response contain all expected fields? |
 | **Structure** | Is the response well-formed JSON? Clean envelope? |
 | **Usability** | Can an agent consume this without post-processing? |
-| **Verbosity** | Lower is better — same data, fewer chars = more efficient |
+| **Verbosity** | Lower is better -- same data, fewer chars = more efficient |
 
-Rubric scores are 1–5 per criterion. Winner is the side with higher weighted total.
+Rubric scores are 1-5 per criterion. Winner is the side with higher weighted total.
 
 ---
 
-## MCP Server Invocation Details
+## CLI Invocation
 
-The `run_ab_test.py` script calls the CLEO MCP server via stdio JSON-RPC:
+All operations use the CLI:
 
-```python
-# Protocol sequence
-# 1. Send initialize
-# 2. Send tools/call (query or mutate)
-# 3. Read response lines until tool result found
-# 4. Terminate process
-
-MCP_INIT = {
-  "jsonrpc": "2.0", "id": 0, "method": "initialize",
-  "params": {
-    "protocolVersion": "2024-11-05",
-    "capabilities": {},
-    "clientInfo": {"name": "ct-grade-ab-test", "version": "2.1.0"}
-  }
-}
-
-MCP_CALL = {
-  "jsonrpc": "2.0", "id": 1, "method": "tools/call",
-  "params": {
-    "name": "query",  # or "mutate"
-    "arguments": {
-      "domain": "<domain>",
-      "operation": "<operation>",
-      "params": {}
-    }
-  }
-}
-```
-
-**CLI equivalent:**
 ```bash
-cleo-dev <domain> <operation> [args] --json
+cleo-dev <command> [args] --json
 ```
 
 ---
@@ -217,17 +167,7 @@ cleo-dev <domain> <operation> [args] --json
 
 | Outcome | Meaning | Action |
 |---------|---------|--------|
-| MCP wins consistently | MCP output is cleaner/more complete | Recommend MCP-first in agent protocols |
-| CLI wins consistently | CLI output is more complete or parseable | Investigate MCP envelope overhead |
+| Arm A wins consistently | Configuration A output is cleaner/more complete | Investigate differences |
+| Arm B wins consistently | Configuration B output is more complete or parseable | Investigate differences |
 | Tie | Both equivalent | Focus on latency and token cost |
-| MCP tokens > CLI tokens | MCP envelope adds overhead | Quantify and document in CLEO-GRADE-SPEC |
-| Data divergence detected | MCP and CLI returning different data | File bug — should be dispatch-level consistent |
-
----
-
-## Parity Scenarios
-
-The P1-P3 parity scenarios (see playbook-v2.md) run a curated set of operations specifically chosen to stress:
-- **P1**: tasks domain — high-frequency agent operations
-- **P2**: session domain — lifecycle operations agents use at start/end
-- **P3**: admin domain — help, dash, health (first calls in any session)
+| Data divergence detected | Arms returning different data | File bug -- should be consistent |

package/skills/ct-grade-v2-1/references/grade-spec-v2.md

@@ -82,16 +82,16 @@ Measures whether the agent recovers from `E_NOT_FOUND` (exit code 4) and avoids
 
 ### S5: Progressive Disclosure Use (20 pts)
 
-Measures whether the agent uses CLEO's progressive disclosure system and the MCP query gateway.
+Measures whether the agent uses CLEO's progressive disclosure system.
 
 | Points | Condition | Evidence string |
 |--------|-----------|-----------------|
 | +10 | At least one help/skill call: `admin.help`, `tools.skill.show`, `tools.skill.list`, `tools.skill.find` | `Progressive disclosure used (Nx)` |
-| +10 | At least one MCP query gateway call (`metadata.gateway === "query"`) | `query (MCP) used Nx` |
+| +10 | Progressive disclosure used for efficient access | `Progressive disclosure active` |
 
 **Flags:**
 - `No admin.help or skill lookup calls (load ct-cleo for guidance)`
-- `No MCP query calls (prefer query over CLI for programmatic access)`
+- `No progressive disclosure calls (use admin.help or skill lookups)`
 
 **Scoring:** Starts at 0. Range: 0–20.
 
@@ -123,7 +123,7 @@ Grade results in v2.1 carry optional token metadata alongside the standard Grade
       "session": 600,
       "admin": 400
     },
-    "mcpQueryTokens": 2100,
+    "queryTokens": 2100,
     "cliTokens": 1100,
     "auditEntries": 47
   }
@@ -164,4 +164,4 @@ The rubric recognizes all 10 canonical domains in audit entries. Key domain-to-d
 | `nexus` | S5 (gateway tracking only) |
 | `sticky` | S5 (gateway tracking only) |
 
-All 10 domains contribute to `mcpQueryCalls` count in S5 — any MCP query gateway call regardless of domain earns the +10.
+All 10 domains contribute to the progressive disclosure count in S5 — any help or skill lookup call regardless of domain earns the +10.