@cleocode/skills 2026.3.76 → 2026.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleocode/skills",
-  "version": "2026.3.76",
+  "version": "2026.4.2",
   "description": "CLEO skill definitions - bundled with CLEO monorepo",
   "main": "index.js",
   "types": "index.d.ts",

package/skills/_shared/manifest-operations.md

@@ -393,8 +393,7 @@ cleo research stats
 ### cleo research inject
 
 > **Note**: Not currently implemented in the CLI. The orchestrator generates fully-resolved
-> subagent prompts via `cleo orchestrator spawn <taskId>` or
-> `mutate({ domain: "orchestrate", operation: "spawn", params: { taskId } })`.
+> subagent prompts via `cleo orchestrator spawn <taskId>`.
 
 ---
 

package/skills/_shared/skill-chaining-patterns.md

@@ -40,14 +40,10 @@ The orchestrator delegates work to a subagent via `orchestrate.spawn` with skill
 ### Implementation
 
 ```bash
-# CLI (Primary)
+# Generate fully-resolved spawn prompt
 cleo orchestrator spawn T1234 --json
 
-# MCP (Fallback)
-# 1. Generate fully-resolved spawn prompt
-mutate({ domain: "orchestrate", operation: "spawn", params: { taskId: "T1234" }})
-
-# 2. Provider adapter executes the prompt using its native mechanism
+# Provider adapter executes the prompt using its native mechanism
 #    - Claude Code: Task tool with cleo-subagent type
 #    - OpenCode: config-driven agent spawn
 #    - Codex: SDK agent creation
@@ -217,7 +213,7 @@ TOPIC_SLUG    # URL-safe topic name
 Before spawning subagent:
 - [ ] Identify appropriate skill for task type
 - [ ] Prepare token context (TASK_ID, DATE, TOPIC_SLUG)
-- [ ] CLI: `cleo orchestrator spawn <taskId> --json` or MCP: `orchestrate.spawn`
+- [ ] `cleo orchestrator spawn <taskId> --json`
 - [ ] Verify token resolution is complete (`tokenResolution.fullyResolved`)
 
 Before chaining to another skill:

package/skills/_shared/subagent-protocol-base.cant

@@ -0,0 +1,113 @@
+---
+kind: protocol
+version: 1
+---
+
+# CANT equivalent of subagent-protocol-base.md
+# T198 prototype: Structured protocol definition with typed constraints.
+
+protocol subagent-base:
+  description: "RFC 2119 protocol for all CLEO subagents"
+  version: "1.2.0"
+
+  # --- Required Tokens ---
+
+  tokens:
+    required:
+      TASK_ID: pattern("^T[0-9]+$")
+      DATE: date
+      TOPIC_SLUG: pattern("^[a-z0-9-]+$")
+    optional:
+      EPIC_ID: pattern("^T[0-9]+$") = ""
+      SESSION_ID: string = ""
+      OUTPUT_DIR: path = ".cleo/agent-outputs"
+      MANIFEST_PATH: path = "${OUTPUT_DIR}/MANIFEST.jsonl"
+    computed:
+      OUTPUT_PATH: path = "${OUTPUT_DIR}/${DATE}_${TOPIC_SLUG}.md"
+      RESEARCH_ID: string = "${TOPIC_SLUG}-${DATE}"
+
+  # --- Output Requirements ---
+
+  constraints [output]:
+    OUT-001: MUST write findings to "${OUTPUT_PATH}"
+    OUT-002: MUST append ONE entry to pipeline manifest via pipeline.manifest.append
+    OUT-003: MUST return ONLY one of: "[Type] complete/partial/blocked. See pipeline manifest."
+    OUT-004: MUST NOT return output content in response body
+
+  # --- Lifecycle Requirements ---
+
+  constraints [lifecycle]:
+    LIFE-001: MUST call tasks.start before beginning any work
+    LIFE-002: MUST call tasks.complete after writing output and manifest
+    LIFE-003: MUST NOT call tasks.complete without having written an output file
+
+  # --- Behavior Requirements ---
+
+  constraints [behavior]:
+    BEH-001: MUST NOT fabricate information — use memory.find first
+    BEH-002: MUST check success field on every LAFS response before proceeding
+    BEH-003: SHOULD link memory observations to task via memory.link
+    BEH-004: MUST NOT use deprecated operations (memory.brain.*, tasks.exists)
+
+  # --- Manifest Requirements ---
+
+  constraints [manifest]:
+    MAN-001: MUST write output file before appending manifest entry
+    MAN-002: MUST set manifest status to enum("complete", "partial", "blocked")
+    MAN-003: SHOULD include needs_followup array when status is "partial"
+    MAN-004: MUST use pipeline.manifest.append — MUST NOT write MANIFEST.jsonl directly
+
+  # --- Lifecycle Phases ---
+
+  phase initialize:
+    step 1: "Read task details via tasks.show ${TASK_ID}"
+    step 2: "Start task via tasks.start ${TASK_ID}"
+    LIFE-001: MUST call tasks.start before beginning any work
+
+  phase execute:
+    step 1: "Follow injected skill protocol for current RCASD-IVTR+C stage"
+    step 2: "Write output to ${OUTPUT_PATH}"
+    BEH-001: MUST NOT fabricate information
+
+  phase output:
+    step 1: "Write output file to ${OUTPUT_PATH}"
+    step 2: "Append manifest entry via pipeline.manifest.append"
+    step 3: "Complete task via tasks.complete ${TASK_ID}"
+    MAN-001: MUST write output file before appending manifest entry
+    LIFE-002: MUST call tasks.complete after writing output
+
+  phase return:
+    step 1: "Return one-line summary message only"
+    OUT-003: MUST return "summary message only"
+    OUT-004: MUST NOT return content in response body
+
+  # --- Error Handling ---
+
+  anti_patterns:
+    - pattern: "Returning full content in response"
+      problem: "Bloats orchestrator context window"
+      solution: "Write to output file, return one-line summary"
+    - pattern: "Writing pretty-printed JSON to manifest"
+      problem: "Multiple lines break JSONL parsers"
+      solution: "Use cleo manifest append CLI command"
+    - pattern: "Skipping tasks.start"
+      problem: "Protocol violation — LIFE-001"
+      solution: "Always call tasks.start before beginning work"
+    - pattern: "Using memory.brain.* prefix"
+      problem: "Removed in ADR-021 — returns E_INVALID_OPERATION"
+      solution: "Use memory.find, memory.observe, memory.link"
+    - pattern: "Using tasks.exists"
+      problem: "Removed from registry"
+      solution: "Use tasks.find with exact: true, check results.length"
+    - pattern: "Calling tasks.list without filters"
+      problem: "Returns all tasks with notes — huge token cost"
+      solution: "Use tasks.find for discovery"
+    - pattern: "Appending to MANIFEST.jsonl directly"
+      problem: "Legacy file — migrated to SQLite per ADR-027"
+      solution: "Use pipeline.manifest.append operation"
+    - pattern: "Loading skills via @ at runtime"
+      problem: "Cannot resolve outside orchestrator spawn"
+      solution: "Skills are injected by orchestrator at spawn time"
+    - pattern: "Fabricating data when memory is empty"
+      problem: "Hallucination — violates BEH-001"
+      solution: "Use memory.find first; if truly unknown, state uncertainty"

package/skills/ct-cleo/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ct-cleo
-description: CLEO task management protocol - session, task, and workflow guidance. Use when managing tasks, sessions, or multi-agent workflows with the CLEO MCP protocol.
+description: CLEO task management protocol - session, task, and workflow guidance. Use when managing tasks, sessions, or multi-agent workflows with the CLEO CLI protocol.
 ---
 
 # CLEO Protocol Guide
@@ -11,9 +11,9 @@ CLEO is the task management protocol for AI coding agents. It provides structure
 
 ## CLI-First Workflow
 
-CLI (`cleo` / `ct`) is the **primary** entry point. MCP (`query` / `mutate`) is the fallback when CLI is unavailable.
+CLI (`cleo` / `ct`) is the **only** dispatch method. All operations use `cleo <command>` syntax.
 
-### Tier-0 Read Operations (`query`) — Always Available
+### Tier-0 Read Operations — Always Available
 
 | Domain | Operation | Description |
 |--------|-----------|-------------|
@@ -34,11 +34,11 @@ CLI (`cleo` / `ct`) is the **primary** entry point. MCP (`query` / `mutate`) is
 | `tools` | `provider.list` | List all known LLM/agent providers |
 | `tools` | `provider.detect` | Detect currently active provider |
 
-### Tier-1 Read Operations (`query`) — After Session Init
+### Tier-1 Read Operations — After Session Init
 
 | Domain | Operation | Description |
 |--------|-----------|-------------|
-| `tasks` | `list` | List direct children (`params: { parentId }`) — **requires parentId filter; prefer tasks.find for discovery** |
+| `tasks` | `list` | List direct children (`--parent <id>`) — **requires parent filter; prefer `cleo find` for discovery** |
 | `tasks` | `tree` | Full subtask hierarchy (`params: { taskId }`) |
 | `tasks` | `analyze` | Leverage-sorted task discovery |
 | `tasks` | `blockers` | Tasks blocking a specific task (`params: { taskId }`) |
@@ -76,7 +76,7 @@ CLI (`cleo` / `ct`) is the **primary** entry point. MCP (`query` / `mutate`) is
 | `sticky` | `list` | List sticky notes (`params: { status?, tag? }`) |
 | `sticky` | `show` | Show sticky details (`params: { stickyId }`) |
 
-### Tier-0 Write Operations (`mutate`) — Always Available
+### Tier-0 Write Operations — Always Available
 
 | Domain | Operation | Description |
 |--------|-----------|-------------|
@@ -89,7 +89,7 @@ CLI (`cleo` / `ct`) is the **primary** entry point. MCP (`query` / `mutate`) is
 | `session` | `end` | End session (`params: { note? }`) |
 | `memory` | `observe` | Save observation to brain (`params: { text, title? }`) |
 
-### Tier-1 Write Operations (`mutate`) — After Session Init
+### Tier-1 Write Operations — After Session Init
 
 | Domain | Operation | Description |
 |--------|-----------|-------------|
@@ -142,20 +142,20 @@ Every agent MUST use this tree to select the minimum-cost operation path.
 ```
 Agent starts work
 │
-├── STEP 1: query session.status
+├── STEP 1: cleo session status
 │   ├── Active session exists
-│   │   └── query session.handoff.show  → resume prior context, then STEP 2
+│   │   └── cleo briefing  → resume prior context, then STEP 2
 │   └── No active session
-│       └── mutate session.start {scope: "task:TXXX" | "epic:TXXX"}
+│       └── cleo session start --scope task:TXXX  (or epic:TXXX)
 │
-├── STEP 2: query admin.dash  → project overview, active epic, blockers
+├── STEP 2: cleo dash  → project overview, active epic, blockers
 │
-├── STEP 3: query tasks.current  → is a task already in progress?
+├── STEP 3: cleo current  → is a task already in progress?
 │   ├── Yes → continue that task (skip STEP 4)
 │   └── No → STEP 4
 │
-└── STEP 4: query tasks.next  → what to work on next
-    └── query tasks.show {taskId}  → full task requirements
+└── STEP 4: cleo next  → what to work on next
+    └── cleo show {taskId}  → full task requirements
 ```
 
 **Anti-pattern blocked**: Never skip `session.status`. Resuming without `handoff.show` loses prior context and causes duplicate work.
@@ -168,28 +168,28 @@ Agent starts work
 I need to find what to work on
 │
 ├── What should I do next (auto-selected)?
-│   └── query tasks.next  [tier 0]
-│       └── query tasks.show {taskId}  [tier 0]  → full details
+│   └── cleo next  [tier 0]
+│       └── cleo show {taskId}  [tier 0]  → full details
 │
 ├── I know keywords — search for a specific task
-│   └── query tasks.find {query: "..."}  [tier 0]
-│       ├── Found one match → query tasks.show {taskId}
+│   └── cleo find "..."  [tier 0]
+│       ├── Found one match → cleo show {taskId}
 │       └── Need to browse children of a known parent
-│           └── query tasks.list {parentId: "TXXX"}  [tier 1]  ← ONLY with parentId filter
-│               ANTI-PATTERN: tasks.list with no parentId = full dump, never do this
+│           └── cleo list --parent TXXX  [tier 1]  ← ONLY with parent filter
+│               ANTI-PATTERN: cleo list with no parent = full dump, never do this
 │
 ├── I need a prioritized planning view (upcoming tasks, blockers, dependencies)
-│   └── query tasks.plan  [tier 0]
+│   └── cleo plan  [tier 0]
 │
 ├── I need the full task hierarchy under a parent
-│   └── (discover via tasks.find first, then)
-│   └── query tasks.tree {taskId}  [tier 1]  → subtask hierarchy
+│   └── (discover via cleo find first, then)
+│   └── cleo tree {taskId}  [tier 1]  → subtask hierarchy
 │
 ├── I need to see what's blocking a task
-│   └── query tasks.blockers {taskId}  [tier 1]
+│   └── cleo blockers {taskId}  [tier 1]
 │
 └── I need leverage-sorted discovery (highest-impact tasks first)
-    └── query tasks.analyze  [tier 1]
+    └── cleo analyze  [tier 1]
 ```
 
 ---
@@ -200,20 +200,20 @@ I need to find what to work on
 I need to save or recall information across sessions
 │
 ├── Save an observation right now (free-form)
-│   └── mutate memory.observe {text, title?}  [tier 0]
+│   └── cleo observe "text" --title "title"  [tier 0]
 │
 ├── Search for something I or a prior agent observed
-│   └── query memory.find {query: "..."}  [tier 0]  ← ALWAYS start here (cheap)
-│       └── Found interesting IDs → query memory.timeline {anchorId}  [tier 1]
-│           └── Need full content → query memory.fetch {ids: [...]}  [tier 1]
+│   └── cleo memory find "..."  [tier 0]  ← ALWAYS start here (cheap)
+│       └── Found interesting IDs → cleo memory timeline {anchorId}  [tier 1]
+│           └── Need full content → cleo memory fetch {ids}  [tier 1]
 │       3-LAYER PATTERN: find → timeline → fetch (never skip to fetch directly)
 │
 ├── Save a structured decision (with rationale, alternatives, taskId)
-│   └── mutate memory.decision.store {decision, rationale, taskId, alternatives?}  [tier 1]
-│       └── Recall: query memory.decision.find {query, taskId?}  [tier 1]
+│   └── cleo memory decision store "decision" --rationale "..." --task TXXX  [tier 1]
+│       └── Recall: cleo memory decision find "query"  [tier 1]
 │
 └── Associate a memory entry with a task (research linking protocol)
-    └── mutate memory.link {memoryId, taskId}  [tier 1]
+    └── cleo memory link {memoryId} {taskId}  [tier 1]
 ```
 
 **Anti-pattern blocked**: Never call `memory.fetch` without first calling `memory.find`. Fetching without filtering returns all entries (expensive).
@@ -226,16 +226,16 @@ I need to save or recall information across sessions
 I need to coordinate agent work (orchestrator role)
 │
 ├── I am the orchestrator — start coordinating an epic
-│   └── mutate orchestrate.start {epicId}  [tier 1]
-│       └── query orchestrate.status  [tier 1]  → current orchestration state
+│   └── cleo orchestrator start --epic {epicId}  [tier 1]
+│       └── cleo orchestrator status  [tier 1]  → current orchestration state
 │
 ├── Spawn a subagent for a task
-│   └── (1) mutate orchestrate.validate {taskId}  [tier 1]  → pre-spawn gate check
-│       (2) mutate orchestrate.spawn {taskId, skillIds?}  [tier 1]  → spawn prep
+│   └── (1) cleo orchestrator validate {taskId}  [tier 1]  → pre-spawn gate check
+│       (2) cleo orchestrator spawn {taskId}  [tier 1]  → spawn prep
 │
 └── I am a subagent — complete my work and report
-    └── mutate pipeline.manifest.append {entry}  [tier 1]  ← MANDATORY per BASE protocol
-        mutate tasks.complete {taskId}  [tier 0]
+    └── cleo manifest append {entry}  [tier 1]  ← MANDATORY per BASE protocol
+        cleo complete {taskId}  [tier 0]
 ```
 
 **Subagent BASE protocol**: Every subagent MUST append one entry to MANIFEST.jsonl via `pipeline.manifest.append` BEFORE calling `tasks.complete`. Omitting this is a protocol violation (exit code 62).
@@ -248,24 +248,24 @@ I need to coordinate agent work (orchestrator role)
 I need to manage session lifecycle or read session state
 │
 ├── Check whether a session is active
-│   └── query session.status  [tier 0]  ← FIRST, always
+│   └── cleo session status  [tier 0]  ← FIRST, always
 │
 ├── Resume prior context after a restart
-│   └── query session.handoff.show  [tier 0]
+│   └── cleo briefing  [tier 0]
 │
 ├── Get a composite cold-start briefing (combines status + handoff)
-│   └── query session.briefing.show  [tier 0]
+│   └── cleo briefing  [tier 0]
 │
 ├── Start a new session
-│   └── mutate session.start {scope: "task:TXXX" | "epic:TXXX"}  [tier 0]
+│   └── cleo session start --scope task:TXXX  (or epic:TXXX)  [tier 0]
 │       RULE: scope is required — no unscoped sessions
 │
 ├── End the current session (triggers debrief + handoff generation)
-│   └── mutate session.end  [tier 0]
+│   └── cleo session end  [tier 0]
 │
 └── Browse past sessions
-    └── query session.find {query: "..."}  [tier 1]  ← NOT session.list unfiltered
-        └── Full session record: query session.show {sessionId}  [tier 1]
+    └── cleo session find "..."  [tier 1]  ← NOT session list unfiltered
+        └── Full session record: cleo session show {sessionId}  [tier 1]
 ```
 
 ---
@@ -276,11 +276,11 @@ I need to manage session lifecycle or read session state
 I need to know what skills or providers are available
 │
 ├── List all installed skills (cold-start safe)
-│   └── query tools.skill.list  [tier 0]
-│       └── Detail on a specific skill: query tools.skill.show {skillId}  [tier 1]
+│   └── cleo skill list  [tier 0]
+│       └── Detail on a specific skill: cleo skill show {skillId}  [tier 1]
 │
 └── Detect active provider
-    └── query tools.provider.detect  [tier 0]
+    └── cleo provider detect  [tier 0]
 ```
 
 ---
@@ -291,21 +291,21 @@ I need to know what skills or providers are available
 I need system or configuration info
 │
 ├── What is the overall project state?
-│   └── query admin.dash  [tier 0]  ← mandatory efficiency sequence step 2
+│   └── cleo dash  [tier 0]  ← mandatory efficiency sequence step 2
 │
 ├── What operations are available at this tier?
-│   └── query admin.help  [tier 0]  → tier 0 + tier 1 ops
-│       └── query admin.help {tier:2}  → reveals tier-2 ops + escalation hints
+│   └── cleo help  [tier 0]  → tier 0 + tier 1 ops
+│       └── cleo help --tier 2  → reveals tier-2 ops + escalation hints
 │
 └── Inspect configuration
-    └── query admin.config.show  [tier 1]
+    └── cleo config show  [tier 1]
 ```
 
 ---
 
 ## CLI Reference (Primary)
 
-Use `ct` (alias for `cleo`) as the primary interface. MCP (`query` / `mutate`) is the fallback when CLI is unavailable.
+Use `ct` (alias for `cleo`) as the interface. CLI is the only dispatch method.
 
 ```bash
 ct find "query"            # Search (99% less context than list)
@@ -350,7 +350,7 @@ ct sticky show SN-001          # Show sticky details
 |-------------|----------------|-----|
 | `research.list` | `pipeline.manifest.list` | research domain is defunct |
 | `research.show` | `pipeline.manifest.show` | research domain is defunct |
-| `research.link` / `cleo research link` | `memory.link` (MCP) | research domain is defunct |
+| `research.link` | `cleo memory link` | research domain is defunct |
 | `system.dash` | `admin.dash` | system domain is defunct |
 | `system.context` | `admin.context` | system domain is defunct |
 | `skills.list` | `tools.skill.list` | skills domain is defunct |
@@ -414,15 +414,6 @@ ct complete <id>
 ct session end
 ```
 
-### MCP Session Operations (Fallback)
-
-```javascript
-query({ domain: "session", operation: "status" })
-query({ domain: "session", operation: "handoff.show" })
-mutate({ domain: "session", operation: "start", params: { scope: "epic:T001" }})
-mutate({ domain: "session", operation: "end", params: { note: "Progress" }})
-```
-
 ---
 
 ## Error Handling
@@ -436,9 +427,9 @@ After EVERY command:
 
 | Exit | Code | Fix |
 |:----:|------|-----|
-| 4 | `E_NOT_FOUND` | Use `ct find` to verify |
+| 4 | `E_NOT_FOUND` | Use `cleo find` to verify |
 | 6 | `E_VALIDATION_*` | Check field lengths, escape `$` as `\$` |
-| 10 | `E_PARENT_NOT_FOUND` | Verify with `ct find <parent-id>` |
+| 10 | `E_PARENT_NOT_FOUND` | Verify with `cleo find <parent-id>` |
 | 11 | `E_DEPTH_EXCEEDED` | Max depth 3 (epic->task->subtask) |
 | 12 | `E_SIBLING_LIMIT` | Max 7 siblings per parent |
 | 62 | `MANIFEST_ENTRY_MISSING` | Subagent must call `pipeline.manifest.append` before `tasks.complete` |

package/skills/ct-cleo/references/orchestrator-constraints.md

@@ -15,19 +15,6 @@
 
 ## Spawn Pipeline
 
-### MCP Spawn Operations
-
-```
-# Analyze dependency waves
-query({ domain: "orchestrate", operation: "analyze", params: { epicId: "T001" }})
-
-# Get ready tasks
-query({ domain: "orchestrate", operation: "ready", params: { epicId: "T001" }})
-
-# Get next task suggestion
-query({ domain: "orchestrate", operation: "next", params: { epicId: "T001" }})
-```
-
 ### CLI Spawn Operations
 
 ```bash

package/skills/ct-cleo/references/session-protocol.md

@@ -11,15 +11,6 @@ ct session start --scope epic:T001 --auto-focus --name "Name"
 #                ^^^^^^^^^^^^^^^^^ REQUIRED     ^^^^^^^^^^^^^ REQUIRED
 ```
 
-## MCP Session Operations
-
-```
-mutate({ domain: "session", operation: "start",
-  params: { scope: "epic:T001", name: "Work", autoStart: true }})
-query({ domain: "session", operation: "status" })
-mutate({ domain: "session", operation: "end", params: { note: "Progress" }})
-```
-
 ## CLI Session Protocol
 
 ### START (ALWAYS first)
@@ -121,9 +112,9 @@ Skills are **context injections, NOT agents**. The orchestrator selects and inje
 
 ### Discovery
 
-```
-query({ domain: "tools", operation: "skill.list" })
-query({ domain: "tools", operation: "skill.show", params: { name: "ct-orchestrator" }})
+```bash
+cleo skill list
+cleo skill show ct-orchestrator
 ```
 
 ### Key Skills

package/skills/ct-codebase-mapper/SKILL.md

@@ -36,31 +36,31 @@ Structured codebase analysis for autonomous agent understanding.
 
 ### Tier 0: Quick Analysis
 
-```
-query admin map
+```bash
+cleo map
 ```
 
 Returns structured `CodebaseMapResult` with stack, architecture, structure, conventions, testing, integrations, and concerns.
 
 ### Tier 1: Store to Brain
 
-```
-mutate admin map
+```bash
+cleo map --store
 ```
 
 Same analysis, but stores patterns, learnings, and observations to brain.db. Tagged with `source: 'codebase-map'` for filtering.
 
 ### Tier 2: Focused Analysis
 
-```
-query admin map {focus: "concerns"}
+```bash
+cleo map --focus concerns
 ```
 
 Focus areas: `stack`, `architecture`, `structure`, `conventions`, `testing`, `integrations`, `concerns`.
 
 ## When to Use
 
-- **New project onboarding**: Run `mutate admin map` to build brain.db context
+- **New project onboarding**: Run `cleo map --store` to build brain.db context
 - **Brownfield init**: `cleo init --map-codebase` runs analysis during initialization
 - **Before epic planning**: Understand project structure before decomposing work
 - **Tech debt assessment**: `query admin map {focus: "concerns"}` for TODOs and large files

package/skills/ct-grade/SKILL.md

@@ -39,14 +39,7 @@ Grading requires audit data. Sessions must be started with the `--grade` flag to
 ct session start --scope epic:T001 --name "Feature work" --grade
 
 # The --grade flag enables detailed audit logging
-# All MCP and CLI operations are recorded for later analysis
-```
-
-### MCP
-
-```
-mutate({ domain: "session", operation: "start",
-  params: { scope: "epic:T001", name: "Feature work", grade: true }})
+# All CLI operations are recorded for later analysis
 ```
 
 ## Running Scenarios
@@ -63,10 +56,10 @@ Tests whether task creation follows protocol: descriptions provided, parent exis
 Tests whether the agent handles errors correctly: follows up `E_NOT_FOUND` with recovery lookups (`tasks.find`), avoids duplicate creates after failures.
 
 ### 4. Full Lifecycle
-Tests session discipline end-to-end: session listed before task ops, session properly ended, MCP-first usage patterns.
+Tests session discipline end-to-end: session listed before task ops, session properly ended, CLI usage patterns.
 
 ### 5. Multi-Domain Analysis
-Tests progressive disclosure: use of `admin.help` or skill lookups, preference for `query` (MCP) over CLI for programmatic access.
+Tests progressive disclosure: use of `admin.help` or skill lookups, use of progressive disclosure for programmatic access.
 
 ## Evaluating Results
 
@@ -80,22 +73,6 @@ ct grade <sessionId>
 ct grade --list
 ```
 
-### MCP
-
-```
-# Grade a session
-# Canonical registry surface (preferred)
-query({ domain: "check", operation: "grade",
-  params: { sessionId: "abc-123" }})
-
-# List past grades
-query({ domain: "check", operation: "grade.list" })
-
-# Use canonical surface (check domain)
-query({ domain: "check", operation: "grade",
-  params: { sessionId: "abc-123" }})
-```
-
 ## Understanding the 5 Dimensions
 
 Each dimension scores 0-20 points, totaling 0-100.
@@ -145,9 +122,9 @@ Starts at 20 and deducts for violations:
 | Points | Criteria |
 |--------|----------|
 | 10 | `admin.help` or skill lookup calls made |
-| 10 | `query` (MCP gateway) used for programmatic access |
+| 10 | Progressive disclosure used for programmatic access |
 
-**What it measures**: Does the agent use progressive disclosure (help/skills) and prefer MCP over CLI?
+**What it measures**: Does the agent use progressive disclosure (help/skills) for efficient protocol access?
 
 ## Interpreting Scores
 
@@ -182,7 +159,7 @@ Flags are actionable diagnostic messages. Each flag identifies a specific behavi
 - `Subtasks created without parent existence check` -- Verify parent exists first
 - `E_NOT_FOUND not followed by recovery lookup` -- Follow errors with `tasks.find`
 - `No admin.help or skill lookup calls` -- Load `ct-cleo` for protocol guidance
-- `No MCP query calls` -- Prefer `query` over CLI
+- `No progressive disclosure calls` -- Use `admin.help` or skill lookups
 
 ## Common Anti-patterns
 
@@ -195,7 +172,7 @@ Flags are actionable diagnostic messages. Each flag identifies a specific behavi
 | Ignoring `E_NOT_FOUND` errors | -5 each S4 | Follow up with `tasks.find` or `tasks.exists` |
 | Creating duplicate tasks | -5 S4 | Check for existing tasks before creating new ones |
 | Never using `admin.help` | -10 S5 | Use progressive disclosure for protocol guidance |
-| CLI-only usage (no MCP) | -10 S5 | Prefer `query`/`mutate` for programmatic access |
+| No progressive disclosure calls | -10 S5 | Use `admin.help` or skill lookups for protocol guidance |
 
 ## Grade Result Schema
 
@@ -211,20 +188,9 @@ Grade results are stored in `.cleo/metrics/GRADES.jsonl` as append-only JSONL. E
 - `entryCount` (number) -- Audit entries analyzed
 - `evaluator` (`auto` | `manual`) -- How the grade was computed
 
-## MCP Operations
-
-| Gateway | Domain | Operation | Description |
-|---------|--------|-----------|-------------|
-| `query` | `check` | `grade` | Canonical grade read (`params: { sessionId }`) |
-| `query` | `check` | `grade.list` | Canonical grade history read |
-| `query` | `check` | `grade` | Canonical grade read (preferred) |
-| `query` | `check` | `grade.list` | Canonical grade history read (preferred) |
-| `query` | `admin` | `token` | Canonical token telemetry read (`action=summary|list|show`) |
-
-
-## API Update Notes
+## CLI Grade Operations
 
-- Prefer the canonical registry surface from `docs/specs/CLEO-API.md`: `check.grade`, `check.grade.list`, and `admin.token` with an `action` param.
-- Use `check.grade` and `check.grade.list` as the canonical surface; legacy handlers may still appear in existing automation.
-- Browser clients should target `POST /api/query` and `POST /api/mutate`; LAFS metadata is carried in `X-Cleo-*` headers by default.
-- Treat persisted token transport values `api` and `http` as equivalent during the compatibility window described in `docs/specs/CLEO-WEB-API.md`.
+| Command | Description |
+|---------|-------------|
+| `ct grade <sessionId>` | Grade a specific session |
+| `ct grade --list` | List past grade results |