@cleocode/skills 2026.5.61 → 2026.5.62

package/package.json

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

package/skills/ct-cleo/SKILL.md

@@ -5,611 +5,27 @@ description: CLEO task management protocol - session, task, and workflow guidanc
 
 # CLEO Protocol Guide
 
-CLEO is the task management protocol for AI coding agents. It provides structured task tracking, session management, and multi-agent coordination with anti-hallucination validation.
-
-**Operation set**: 164 operations (97 query + 67 mutate) across 10 canonical domains.
-
-## Canonical Decision Tree
-
-Every agent MUST use this tree to select the minimum-cost operation path.
-
-### Entry Point: Session Start (MANDATORY)
-
-```
-Agent starts work
-│
-├── STEP 1: cleo session status
-│   ├── Active session exists
-│   │   └── cleo briefing  → resume prior context, then STEP 2
-│   └── No active session
-│       └── cleo session start --scope task:TXXX  (or epic:TXXX)
-│
-├── STEP 2: cleo dash  → project overview, active epic, blockers
-│
-├── STEP 3: cleo current  → is a task already in progress?
-│   ├── Yes → continue that task (skip STEP 4)
-│   └── No → STEP 4
-│
-└── 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.
-
----
-
-### Phase Mapping (RCASD-IVTR+C)
-
-Each task lives in a lifecycle phase. Match your tooling to the current phase:
-
-| Phase | When | Key Commands |
-|-------|------|--------------|
-| `research` | Gathering information, reading docs, exploring codebase | `cleo memory find`, `cleo docs add`, `cleo show` |
-| `implement` | Writing code, making changes, building features | `cleo start`, `cleo verify`, code tools |
-| `validate` | Verifying correctness, running acceptance criteria | `cleo verify <id> --run`, `cleo check gate.status` |
-| `test` | Running test suites, asserting coverage | `pnpm run test`, `cleo check test` |
-| `release` | Versioning, changelog, publishing | `cleo release ship`, `cleo pipeline stage.record` |
-
-**Check current phase**: `cleo show <id>` → `pipelineStage` field.
-
----
-
-### Goal: Discover Work
-
-```
-I need to find what to work on
-│
-├── What should I do next (auto-selected)?
-│   └── cleo next  [tier 0]
-│       └── cleo show {taskId}  [tier 0]  → full details
-│
-├── I know keywords — search for a specific task
-│   └── cleo find "..."  [tier 0]
-│       ├── Found one match → cleo show {taskId}
-│       └── Need to browse children of a known parent
-│           └── 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)
-│   └── cleo plan  [tier 0]
-│
-├── I need the full task hierarchy under a parent
-│   └── (discover via cleo find first, then)
-│   └── cleo tree {taskId}  [tier 1]  → subtask hierarchy
-│
-├── I need to see what's blocking a task
-│   └── cleo blockers {taskId}  [tier 1]
-│
-└── I need leverage-sorted discovery (highest-impact tasks first)
-    └── cleo analyze  [tier 1]
-```
-
----
-
-### Goal: Memory Operations
-
-```
-I need to save or recall information across sessions
-│
-├── Save an observation right now (free-form)
-│   └── cleo memory observe "text" --title "title"  [tier 0]
-│
-├── Search for something I or a prior agent observed
-│   └── 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)
-│   └── cleo memory decision store "decision" --rationale "..." --task TXXX  [tier 1]
-│       └── Recall: cleo memory decision find "query"  [tier 1]
-│
-├── Look up an architectural decision (D0xx or other ID)
-│   └── STEP 1: cleo memory decision-find --query <id> --json  [tier 1]
-│       ├── Found → verify source document and outcome status
-│       └── NOT FOUND → STEP 2
-│   └── STEP 2: cleo memory find <id> --json  [tier 1]
-│       ├── Found as observation/pattern → note O-* ID and context
-│       └── NOT FOUND → STEP 3
-│   └── STEP 3: grep -r "<id>" docs/adr/  [tier 1]
-│       ├── Found in ADR → read full ADR for canonical definition
-│       │   └── Check superseded-by / supersedes relationships
-│       └── NOT FOUND → STEP 4
-│   └── STEP 4: grep -r "<id>" .cleo/agent-outputs/  [tier 1]
-│       ├── Found in planning doc → note session scope and migration impact
-│       └── NOT FOUND → decision may not be recorded; flag to owner
-│   ⚠️ ID OVERLOAD: Same ID can exist in multiple docs with different meanings.
-│      Always cite the source document, not just the ID.
-│
-└── Associate a memory entry with a task (research linking protocol)
-    └── 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).
-
----
-
-### Goal: Track Session Context
-
-```
-I need to manage session lifecycle or read session state
-│
-├── Check whether a session is active
-│   └── cleo session status  [tier 0]  ← FIRST, always
-│
-├── Resume prior context after a restart
-│   └── cleo briefing  [tier 0]
-│
-├── Get a composite cold-start briefing (combines status + handoff)
-│   └── cleo briefing  [tier 0]
-│
-├── Start a new session
-│   └── 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)
-│   └── cleo session end  [tier 0]
-│
-└── Browse past sessions
-    └── cleo session find "..."  [tier 1]  ← NOT session list unfiltered
-        └── Full session record: cleo session show {sessionId}  [tier 1]
-```
-
----
-
-### Goal: Discover Available Skills
-
-```
-I need to know what skills or providers are available
-│
-├── List all installed skills (cold-start safe)
-│   └── cleo skill list  [tier 0]
-│       └── Detail on a specific skill: cleo skill show {skillId}  [tier 1]
-│
-└── Detect active provider
-    └── cleo provider detect  [tier 0]
-```
-
----
-
-### Goal: System Information
-
-```
-I need system or configuration info
-│
-├── What is the overall project state?
-│   └── cleo dash  [tier 0]  ← mandatory efficiency sequence step 2
-│
-├── What operations are available at this tier?
-│   └── cleo help  [tier 0]  → tier 0 + tier 1 ops
-│       └── cleo help --tier 2  → reveals tier-2 ops + escalation hints
-│
-└── Inspect configuration
-    └── cleo config show  [tier 1]
-```
-
----
-
-## Pre-Complete Gate Ritual (ADR-051 — evidence required)
-
-MANDATORY before every `cleo complete <id>`.  Every verification gate MUST be
-backed by programmatic evidence. CLEO validates commits against the git
-history, file sha256 against disk, tool exit codes against real runs, and
-vitest JSON against the reporter output. No evidence → no gate pass.
-
-### Capture evidence per gate
-
-```bash
-# implemented gate: commit + file list
-cleo verify T### --gate implemented \
-  --evidence "commit:$(git rev-parse HEAD);files:packages/a/src/b.ts,packages/a/src/c.ts"
-
-# testsPassed gate: run tests and capture
-cleo verify T### --gate testsPassed --evidence "tool:pnpm-test"
-
-# qaPassed gate: biome + tsc both exit 0
-cleo verify T### --gate qaPassed --evidence "tool:biome;tool:tsc"
-
-# documented gate: docs/spec file
-cleo verify T### --gate documented --evidence "files:docs/specs/T###-spec.md"
-
-# cleanupDone gate: summary note
-cleo verify T### --gate cleanupDone --evidence "note:removed old helpers"
-
-# securityPassed gate: scan or waiver
-cleo verify T### --gate securityPassed --evidence "tool:security-scan"
-
-# Then complete — evidence is RE-VALIDATED at this step
-cleo memory observe "..." --title "..."
-cleo complete T###
-```
-
-### Anti-patterns (ADR-051)
-
-- ❌ `cleo verify --all` without `--evidence` — returns `E_EVIDENCE_MISSING`
-- ❌ `cleo complete --force` — flag REMOVED
-- ❌ Modifying source files between `verify` and `complete` — caught by
-     staleness check (`E_EVIDENCE_STALE`)
-- ❌ Passing `note:` as evidence for `implemented` or `testsPassed` —
-     fails `E_EVIDENCE_INSUFFICIENT`
-- ❌ Self-attesting without programmatic proof
-
-### Emergency override (audited)
-
-```bash
-CLEO_OWNER_OVERRIDE=1 CLEO_OWNER_OVERRIDE_REASON="<reason>" \
-  cleo verify T### --gate implemented --evidence "note:<justification>"
-```
-
-Writes to `.cleo/audit/force-bypass.jsonl` with PID, command, and reason. Do not
-normalize.
-
----
-
-## Multi-Agent Coordination
-
-FIRST: do I have >= 5 tasks under one epic?
-
-```
-Do I have an epic with >= 5 tasks?
-│
-├── YES → cleo orchestrate start <epicId>  (auto-inits LOOM) — MANDATORY before touching any child task
-│   │
-│   └── For each wave:
-│       cleo orchestrate ready --epic <id>  → get parallel-safe task set
-│       │
-│       └── For each task in wave:
-│           cleo orchestrate spawn <taskId>  → get resolved prompt
-│           Dispatch subagent via Agent tool
-│           On return: cleo manifest show <id>  → read key_findings
-│
-└── NO → continue as solo executor
-    └── proceed through standard work loop (cleo next → cleo show → implement → cleo complete)
-```
-
-**Gate-failure loop (IVTR)**:
-
-```
-Task returns blocked
-│
-├── Read failure in manifest (cleo manifest show <id>)
-│
-└── cleo orchestrate ivtr <id> --loop-back --phase implement --reason "..."  → re-spawn
-    ├── Max 2 retries → escalate to HITL
-    └── Document blocker in manifest before escalating
-```
-
----
-
-## Greenfield Bootstrap (new project)
-
-Copy-paste sequence:
-
-```bash
-cd /path/to/new-project
-cleo init                                # creates .cleo/, tasks.db, brain.db
-cleo session start --scope global
-cleo add "Epic: <your goal>" --type epic --lifecycle auto \
-  --description "..." \
-  --acceptance "REQ-1|REQ-2|REQ-3|REQ-4|REQ-5"
-EPIC_ID=$(cleo current | jq -r '.data.currentTask.id')
-
-# Attach research/spec documents
-cleo docs add $EPIC_ID ./spec.md --desc "initial spec" --labels spec
-
-# Decompose into atomic tasks with typed gates
-cleo add "Task A" --type task --parent $EPIC_ID
-cleo req add <taskA-id> IMPL-01 --gate '{"kind":"test","command":"npm test","expect":"pass","description":"..."}'
-
-# Start orchestrator — auto-inits LOOM
-cleo orchestrate start $EPIC_ID
-
-# Drive IVTR on first task
-cleo orchestrate ivtr <taskA-id> --start  # begins Implement phase
-```
-
----
-
-## Reference
-
-### CLI-First Workflow
-
-CLI (`cleo` / `ct`) is the **only** dispatch method. All operations use `cleo <command>` syntax.
-
-#### Tier-0 Read Operations — Always Available
-
-| Domain | Operation | Description |
-|--------|-----------|-------------|
-| `tasks` | `show` | Get task details (`params: { taskId }`) |
-| `tasks` | `find` | Search tasks (`params: { query }` or `{ id }`) |
-| `tasks` | `next` | Auto-select highest-priority next task |
-| `tasks` | `plan` | Composite planning view: upcoming tasks, blockers, dependencies |
-| `tasks` | `current` | Show currently active (started) task |
-| `session` | `status` | Current session state — **mandatory first call** |
-| `session` | `handoff.show` | Resume prior context from last session |
-| `session` | `briefing.show` | Composite cold-start briefing (status + handoff combined) |
-| `memory` | `find` | Search brain for past observations, decisions, patterns (`params: { query }`) |
-| `admin` | `version` | CLEO version number |
-| `admin` | `health` | Installation health check |
-| `admin` | `dash` | Project dashboard — mandatory efficiency sequence step 2 |
-| `admin` | `help` | Discover available operations; use `{tier:2}` to reveal advanced ops |
-| `tools` | `skill.list` | List all installed agent skills |
-| `tools` | `provider.list` | List all known LLM/agent providers |
-| `tools` | `provider.detect` | Detect currently active provider |
-
-#### Tier-1 Read Operations — After Session Init
-
-| Domain | Operation | Description |
-|--------|-----------|-------------|
-| `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 }`) |
-| `tasks` | `depends` | Full dependency graph for a task (`params: { taskId }`) |
-| `session` | `list` | List sessions (prefer `session.find` for discovery) |
-| `session` | `decision.log` | Recorded decisions for the current session |
-| `session` | `find` | Search sessions (`params: { query }`) |
-| `session` | `show` | Full session record (`params: { sessionId }`) |
-| `session` | `context.drift` | Inspect context drift during long sessions |
-| `memory` | `timeline` | Context around an anchor entry (`params: { anchorId }`) |
-| `memory` | `fetch` | Batch-fetch brain entries (`params: { ids: [...] }`) |
-| `memory` | `decision.find` | Search stored decisions (`params: { query, taskId? }`) |
-| `memory` | `pattern.find` | Search stored patterns (`params: { query, type? }`) |
-| `memory` | `learning.find` | Search stored learnings (`params: { query, minConfidence? }`) |
-| `orchestrate` | `analyze` | Dependency wave analysis (`params: { epicId }`) |
-| `orchestrate` | `ready` | Tasks ready to spawn (`params: { epicId }`) |
-| `orchestrate` | `next` | Next task suggestion (`params: { epicId }`) |
-| `orchestrate` | `status` | Current orchestration state |
-| `check` | `schema` | Validate task data schema integrity |
-| `check` | `protocol` | Protocol compliance for a task (`params: { taskId, protocolType? }`) |
-| `check` | `task` | Validate task fields (`params: { taskId }`) |
-| `check` | `compliance.summary` | Overall compliance summary |
-| `check` | `test` | Test status or coverage (`params: { format: "status" | "coverage" }`) |
-| `check` | `gate.status` | Lifecycle gate status |
-| `pipeline` | `stage.status` | Pipeline stage for epic (`params: { epicId }`) |
-| `pipeline` | `stage.validate` | Validate gate before advancing |
-| `pipeline` | `manifest.show` | Read manifest entry (`params: { id }`) |
-| `pipeline` | `manifest.list` | List manifest entries (`params: { filter?: "pending" }`) |
-| `pipeline` | `manifest.find` | Search manifest entries (`params: { query }`) |
-| `nexus` | `status` | Check if nexus is initialized |
-| `nexus` | `list` | List registered projects |
-| `admin` | `config.show` | Inspect current configuration |
-| `admin` | `adr.find` | Search architecture decision records |
-| `tools` | `skill.show` | Skill details (`params: { skillId }`) |
-| `sticky` | `list` | List sticky notes (`params: { status?, tag? }`) |
-| `sticky` | `show` | Show sticky details (`params: { stickyId }`) |
-
-#### Tier-0 Write Operations — Always Available
-
-| Domain | Operation | Description |
-|--------|-----------|-------------|
-| `tasks` | `add` | Create task (`params: { title, description, parentId?, status? }`) |
-| `tasks` | `update` | Update task (`params: { taskId, title?, status?, notes? }`) |
-| `tasks` | `complete` | Mark task done (`params: { taskId }`) |
-| `tasks` | `start` | Start working on a task (`params: { taskId }`) |
-| `tasks` | `stop` | Stop working on current task |
-| `session` | `start` | Start session (`params: { scope }`) — scope is **required** |
-| `session` | `end` | End session (`params: { note? }`) |
-| `memory` | `observe` | Save observation to brain (`params: { text, title? }`) |
-
-#### Tier-1 Write Operations — After Session Init
-
-| Domain | Operation | Description |
-|--------|-----------|-------------|
-| `tasks` | `cancel` | Cancel task (`params: { taskId }`) |
-| `tasks` | `archive` | Archive completed task (`params: { taskId }`) |
-| `tasks` | `restore` | Restore from done/archive (`params: { taskId, from: "done" \| "archive" }`) |
-| `tasks` | `delete` | Hard delete — irreversible (`params: { taskId }`) |
-| `tasks` | `reparent` | Move to different parent (`params: { taskId, newParentId }`) |
-| `tasks` | `reorder` | Reorder tasks within their parent (`params: { taskId, position }`) |
-| `session` | `resume` | Resume a prior session (`params: { sessionId }`) |
-| `session` | `suspend` | Pause session without ending it |
-| `session` | `record.decision` | Record a session decision (`params: { text, rationale }`) |
-| `session` | `record.assumption` | Record a session assumption (`params: { text }`) |
-| `admin` | `context.inject` | Inject protocol content into context (`params: { protocolType }`) — **moved from session domain** |
-| `memory` | `link` | Link memory entry to task (`params: { memoryId, taskId }`) |
-| `memory` | `decision.store` | Store structured decision (`params: { decision, rationale, taskId, alternatives? }`) |
-| `memory` | `pattern.store` | Store recurring pattern (`params: { name, type, impact, success, antiPattern? }`) |
-| `memory` | `learning.store` | Store a learning (`params: { text, confidence, taskId? }`) |
-| `orchestrate` | `start` | Start orchestrating an epic (`params: { epicId }`) |
-| `orchestrate` | `spawn` | Spawn prep for a task (`params: { taskId, skillIds? }`) |
-| `orchestrate` | `spawn.execute` | Execute spawn via adapter registry (`params: { taskId }`) |
-| `orchestrate` | `handoff` | Hand off context to subagent (`params: { taskId, context }`) |
-| `orchestrate` | `validate` | Pre-spawn gate check (`params: { taskId }`) |
-| `orchestrate` | `parallel` | Run parallel agent wave (`params: { action: "start" \| "end", waveId? }`) |
-| `check` | `test.run` | Run tests |
-| `check` | `gate.set` | Set or reset a lifecycle gate |
-| `pipeline` | `stage.record` | Record pipeline stage progress |
-| `pipeline` | `stage.gate.pass` | Pass a pipeline gate (`params: { stageId, gateId }`) |
-| `pipeline` | `stage.gate.fail` | Fail a gate with reason (`params: { stageId, gateId, reason }`) |
-| `pipeline` | `manifest.append` | Append manifest entry (`params: { entry }`) — **MANDATORY per BASE protocol** |
-| `pipeline` | `phase.set` | Set pipeline phase (`params: { phaseId, action: "start" \| "complete" }`) |
-| `pipeline` | `release.ship` | Ship a release (`params: { step? }`) |
-| `admin` | `config.set` | Update configuration (`params: { key, value }`) |
-| `tools` | `skill.install` | Install a skill (`params: { skillId }`) |
-| `tools` | `skill.uninstall` | Uninstall a skill (`params: { skillId }`) |
-| `tools` | `skill.refresh` | Bulk update all installed skills |
-| `sticky` | `add` | Create sticky note (`params: { content, tags?, color?, priority? }`) |
-| `sticky` | `convert` | Convert to task/memory (`params: { stickyId, targetType }`) |
-| `sticky` | `archive` | Archive sticky (`params: { stickyId }`) |
-| `sticky` | `purge` | Permanently delete sticky notes (`params: { stickyId }`) |
-
----
-
-### CLI Reference (Primary)
-
-Use `ct` (alias for `cleo`) as the interface. CLI is the only dispatch method.
-
-```bash
-ct find "query"            # Search (99% less context than list)
-ct find --id T1234         # Search by ID
-ct show T1234              # Full task details
-ct add "Task title"        # Create task
-ct complete T1234          # Complete task
-ct start T1234             # Start working on task
-ct dash                    # Project overview (admin.dash equivalent)
-
-ct sticky add "Quick note"     # Create sticky note
-ct sticky list                 # List active stickies
-ct sticky show SN-001          # Show sticky details
-```
-
----
-
-### Task Discovery (Context Efficiency)
-
-**MUST** use efficient commands — `find` for discovery, `show` for details:
-
-- `list` includes full notes arrays (huge context cost)
-- `find` returns minimal fields only (99% less context)
-- Use `show` only when you need full details for a specific task
-
-#### Context Bloat Anti-Patterns
-
-| Anti-Pattern | Token Cost | Efficient Alternative | Savings |
-|-------------|-----------|----------------------|---------|
-| `tasks.list` (no parentId filter) | 2000-5000 | `tasks.find {query: "..."}` | 80-90% |
-| `admin.help {tier:2}` first call | 2000+ | `admin.help` (tier 0 default) | 60-75% |
-| `tasks.show` for every task | 400 x N | `tasks.find` then `show` for 1-2 | 70-90% |
-| `memory.fetch` without `memory.find` | large | `memory.find` → filter → `memory.fetch` | 80% |
-| `session.list` unfiltered | 300 x N | `session.status` first, then `session.find` if needed | 90% |
-| Reading full epic tree | 1000-3000 | `tasks.next` for suggestions | 80% |
-
----
-
-### Anti-Pattern Reference
-
-| Bad Pattern | Correct Pattern | Why |
-|-------------|----------------|-----|
-| `research.list` | `pipeline.manifest.list` | research domain is defunct |
-| `research.show` | `pipeline.manifest.show` | 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 |
-| `skills.show` | `tools.skill.show` | skills domain is defunct |
-| `tasks.list` (no filter) | `tasks.find {query: "..."}` | list returns ALL tasks + notes |
-| `tasks.reopen` | `tasks.restore {from: "done"}` | reopen is deprecated verb |
-| `tasks.unarchive` | `tasks.restore {from: "archive"}` | unarchive is deprecated verb |
-| `tasks.promote` | `tasks.reparent {newParentId: null}` | promote is deprecated verb |
-| `memory.brain.search` | `memory.find` | old operation name (cutover T5241) |
-| `memory.brain.observe` | `memory.observe` | old operation name (cutover T5241) |
-| `session.context.inject` | `admin.context.inject` | operation moved domains (reads filesystem, is an admin/bootstrap op) |
-| `memory.fetch` without `memory.find` | `memory.find` → filter → `memory.fetch` | fetch without filter returns everything |
-| Completing task without manifest append | `pipeline.manifest.append` then `tasks.complete` | BASE protocol violation (exit 62) |
-| Skipping `session.status` at start | Always check `session.status` first | loses prior context, causes duplicate work |
-| `cleo observe` | `cleo memory observe` | observe is not a top-level command |
-
----
-
-### Progressive Disclosure
-
-Load only what you need. Escalate tiers when the task demands it:
-
-**Stay at Tier 0** (default — 80% of work):
-- Single task execution (implement, fix, test)
-- Task discovery and status updates
-- Session start/end
-
-**Escalate to Tier 1** when:
-- Managing pipeline stages or manifest entries
-- Running validation/compliance checks
-- Working with memory (timeline, fetch, decisions, patterns)
-- Orchestrating multi-agent workflows
-
-**Escalate to Tier 2** when (via `admin.help {tier:2}` first):
-- WarpChain pipeline operations (`pipeline.chain.*`)
-- Behavioral grading (`check.grade`)
-- Cross-project nexus deep queries (`nexus.resolve`, `nexus.graph`)
-- Data export/import (`admin.export`, `admin.import`)
-
----
-
-### Session Protocol
-
-Sessions track work context across agent interactions.
-
-#### Quick Start
-
-```bash
-# 1. CHECK session state first (always)
-ct session status
-
-# 2. RESUME or START
-ct session resume <id>
-# OR (only if no suitable session):
-ct session start --scope epic:T001
-
-# 3. WORK
-ct current / ct next / ct complete T005 / ct start T006
-
-# 4. END (ALWAYS when stopping)
-ct complete <id>
-ct session end
-```
-
----
-
-### Error Handling
-
-**CRITICAL: NEVER ignore exit codes. Failed commands = tasks NOT created/updated.**
-
-After EVERY command:
-1. Exit code `0` = success, `1-22` = error, `100+` = special (not error)
-2. JSON `"success": false` = operation failed
-3. Execute `error.fix` — copy-paste-ready fix command
-
-| Exit | Code | Fix |
-|:----:|------|-----|
-| 4 | `E_NOT_FOUND` | Use `cleo find` to verify |
-| 6 | `E_VALIDATION_*` | Check field lengths, escape `$` as `\$` |
-| 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` |
-
----
-
-### RCASD-IVTR+C Lifecycle (LOOM)
-
-**LOOM** (Logical Order of Operations Methodology) is the systematic framework for how CLEO processes project threads through the RCASD-IVTR+C pipeline. See `docs/concepts/CLEO-VISION.md` for the complete LOOM framework.
-
-**Lifecycle**: See `references/loom-lifecycle.md` for gate enforcement and subagent architecture.
-
-### Pipeline Awareness
-
-Epics follow the RCASD-IVTR+C lifecycle managed through pipeline stages. Use `pipeline.stage.status` to check where an epic is in its lifecycle:
-
-| Stage | Purpose |
-|-------|---------|
-| `research` | Information gathering and analysis |
-| `consensus` | Validate claims and decisions |
-| `architecture_decision` | ADR and specification |
-| `specification` | Formal requirements |
-| `decomposition` | Task breakdown |
-| `implementation` | Build functionality |
-| `validation` | Verify against criteria |
-| `testing` | Test coverage |
-| `release` | Version and publish |
-| `contribution` | Multi-agent consensus tracking |
-
----
-
-### Time Estimates Prohibited
-
-- **MUST NOT** estimate hours, days, weeks, or temporal duration
-- **MUST** use relative sizing: `small` / `medium` / `large`
-- **SHOULD** describe scope, complexity, dependencies when asked
-
----
-
-### Further Reading
-
-For detailed guidance on specific topics, see:
-
-- **Session Protocol**: `references/session-protocol.md`
-- **LOOM Lifecycle**: `references/loom-lifecycle.md`
-- **Anti-Patterns**: `references/anti-patterns.md`
-- **Operation Constitution**: `docs/specs/CLEO-OPERATION-CONSTITUTION.md`
-- **Verb Standards**: `docs/specs/VERB-STANDARDS.md`
-- **Decision Tree source**: `.cleo/agent-outputs/T5610-decision-tree.md`
+<!-- thin-pointer: full protocol is in CLEO-INJECTION.md (T9148) -->
+Full protocol content lives in `~/.cleo/templates/CLEO-INJECTION.md`.
+Emit any section with: `cleo briefing inject --section <name>`
+
+Supported sections: `session-start` · `work-loop` · `triggers` · `task-creation`
+· `task-discovery` · `session-commands` · `memory` · `nexus` · `orchestration`
+· `playbooks` · `documents` · `error-handling` · `pre-complete-gate`
+· `spawn-tiers` · `rules` · `memory-jit` · `escalation`
+
+## Quick Reference
+
+| Need | Command |
+|------|---------|
+| Start session | `cleo session status` → `cleo briefing` |
+| Find work | `cleo next` → `cleo show <id>` |
+| Search tasks | `cleo find "query"` |
+| Complete task | `cleo verify T### --gate ... --evidence "..."` → `cleo complete T###` |
+| Save memory | `cleo memory observe "..." --title "..."` |
+| Spawn subagent | `cleo orchestrate spawn <taskId> --tier 2` |
+
+## Skill-Specific Extensions
+
+(No extensions beyond CLEO-INJECTION.md canonical content as of T9148.)
+For full decision trees and operation reference tables, emit sections above.

package/skills/ct-cleo/__tests__/ct-cleo-skill.test.ts

@@ -4,12 +4,9 @@
  * Asserts that all required protocol markers are present in the skill file,
  * protecting against content drift as the file evolves.
  *
- * Checks:
- * - Required section markers exist: Decision Tree, Pre-Complete Gate Ritual,
- *   Multi-Agent Coordination, Greenfield Bootstrap
- * - `cleo memory observe` is used (not the deprecated bare `cleo observe`)
- * - `cleo orchestrate ivtr` is referenced at least once
- * - At least 4 distinct `cleo <verb>` command patterns exist
+ * After T9148 (ct-cleo thin-pointer collapse), the SKILL.md became a ~31-line
+ * pointer to CLEO-INJECTION.md rather than a 615-line embedded protocol.
+ * These tests validate the thin-pointer structure's required elements.
  *
  * @task T808
  * @skill-version SKILL-14
@@ -36,32 +33,20 @@ const skillPath = join(skillRoot, 'SKILL.md');
 const skillContent = readFileSync(skillPath, 'utf-8');
 
 // ---------------------------------------------------------------------------
-// Required section markers (SKILL-10 through SKILL-13)
+// Required structural elements (post-T9148 thin-pointer design)
 // ---------------------------------------------------------------------------
 
-describe('ct-cleo SKILL.md — required section markers', () => {
-  it('contains "Decision Tree" section', () => {
-    expect(skillContent).toContain('Decision Tree');
+describe('ct-cleo SKILL.md — thin-pointer structure (post-T9148)', () => {
+  it('has a Quick Reference table or section', () => {
+    expect(skillContent).toContain('Quick Reference');
   });
 
-  it('contains "Pre-Complete Gate Ritual" section', () => {
-    expect(skillContent).toContain('Pre-Complete Gate Ritual');
+  it('points to CLEO-INJECTION.md canonical source', () => {
+    expect(skillContent).toContain('CLEO-INJECTION.md');
   });
 
-  it('contains "Multi-Agent Coordination" section', () => {
-    expect(skillContent).toContain('Multi-Agent Coordination');
-  });
-
-  it('contains "Greenfield Bootstrap" section', () => {
-    expect(skillContent).toContain('Greenfield Bootstrap');
-  });
-
-  it('Decision Tree is the first H2 heading', () => {
-    // Find the position of the first H2 (## ...) after the frontmatter
-    const afterFrontmatter = skillContent.replace(/^---[\s\S]*?---\n/, '');
-    const firstH2Match = /^## (.+)$/m.exec(afterFrontmatter);
-    expect(firstH2Match).not.toBeNull();
-    expect(firstH2Match![1]).toContain('Decision Tree');
+  it('lists supported sections or emit command', () => {
+    expect(skillContent).toContain('cleo briefing');
   });
 });
 
@@ -76,19 +61,16 @@ describe('ct-cleo SKILL.md — command correctness', () => {
 
     // The bare `cleo observe` form should only appear as a deprecated anti-pattern
     // in a table row (prefixed with `| `), never as an instruction to execute.
-    // Count bare `cleo observe` occurrences that are NOT inside table pipe columns.
     const lines = skillContent.split('\n');
     const badLines = lines.filter((line) => {
-      // Skip table rows — those document deprecated patterns intentionally
       if (/^\s*\|/.test(line)) return false;
-      // Skip comment-style lines and code-block lines showing anti-patterns
       return /\bcleo observe\b/.test(line);
     });
     expect(badLines).toHaveLength(0);
   });
 
-  it('references "cleo orchestrate ivtr" at least once', () => {
-    expect(skillContent).toMatch(/cleo orchestrate ivtr/);
+  it('references cleo orchestrate spawn (the canonical spawn command)', () => {
+    expect(skillContent).toContain('cleo orchestrate spawn');
   });
 });
 
@@ -98,7 +80,6 @@ describe('ct-cleo SKILL.md — command correctness', () => {
 
 describe('ct-cleo SKILL.md — command diversity', () => {
   it('contains at least 4 distinct "cleo <verb>" command patterns', () => {
-    // Extract all `cleo <word>` patterns (first word after cleo)
     const verbs = new Set<string>();
     const pattern = /\bcleo\s+([a-z][a-z0-9-]*)/g;
     let match: RegExpExecArray | null;
@@ -113,27 +94,27 @@ describe('ct-cleo SKILL.md — command diversity', () => {
 });
 
 // ---------------------------------------------------------------------------
-// Phase mapping (SKILL-10 enhancement)
+// Phase coverage — section names are emittable (post-T9148 pointer design)
 // ---------------------------------------------------------------------------
 
-describe('ct-cleo SKILL.md — phase mapping', () => {
-  it('includes phase mapping for research phase', () => {
-    expect(skillContent).toContain('research');
+describe('ct-cleo SKILL.md — phase coverage via emittable sections', () => {
+  it('mentions pre-complete gate section (emittable via cleo briefing inject)', () => {
+    expect(skillContent).toContain('pre-complete-gate');
   });
 
-  it('includes phase mapping for implement phase', () => {
-    expect(skillContent).toMatch(/implement/i);
+  it('mentions session-start section (research phase entry point)', () => {
+    expect(skillContent).toContain('session-start');
   });
 
-  it('includes phase mapping for validate phase', () => {
-    expect(skillContent).toMatch(/validate|validation/i);
+  it('mentions orchestration section (orchestrate commands)', () => {
+    expect(skillContent).toContain('orchestration');
   });
 
-  it('includes phase mapping for test phase', () => {
-    expect(skillContent).toMatch(/\btest\b/i);
+  it('mentions task-creation section (task creation guidance)', () => {
+    expect(skillContent).toContain('task-creation');
   });
 
-  it('includes phase mapping for release phase', () => {
-    expect(skillContent).toContain('release');
+  it('mentions work-loop section (core workflow loop)', () => {
+    expect(skillContent).toContain('work-loop');
   });
 });