@cleocode/cleo 2026.3.12 → 2026.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleocode/cleo",
-  "version": "2026.3.12",
+  "version": "2026.3.14",
   "description": "CLEO V2 - TypeScript task management CLI for AI coding agents",
   "mcpName": "io.github.kryptobaseddev/cleo-mcp-server",
   "type": "module",
@@ -31,7 +31,6 @@
     "prepare": "npm run build",
     "prepack": "npm run build",
     "postinstall": "node bin/postinstall.js",
-    "migrate:todos": "node dist/scripts/migrate-todo-to-tasks.js",
     "cleo:update-status": "node dist/scripts/update-task-status.js",
     "adr:validate": "tsx dev/validate-adrs.ts",
     "adr:manifest": "tsx dev/generate-adr-manifest.ts",
@@ -56,6 +55,7 @@
   "files": [
     "dist",
     "drizzle",
+    "drizzle-brain",
     "packages/ct-skills",
     "schemas",
     "templates",
@@ -65,7 +65,7 @@
     "bin"
   ],
   "dependencies": {
-    "@cleocode/caamp": "^1.5.2",
+    "@cleocode/caamp": "^1.6.0",
     "@cleocode/lafs-protocol": "^1.6.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ajv": "^8.18.0",

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

@@ -37,7 +37,7 @@ The orchestrator delegates work to a subagent via `orchestrate.spawn` with skill
 
 ```
 # 1. Generate fully-resolved spawn prompt via MCP
-cleo_mutate({ domain: "orchestrate", operation: "spawn", params: { taskId: "T1234" }})
+mutate({ domain: "orchestrate", operation: "spawn", params: { taskId: "T1234" }})
 
 # 2. Provider adapter executes the prompt using its native mechanism
 #    - Claude Code: Task tool with cleo-subagent type

package/packages/ct-skills/skills/_shared/subagent-protocol-base.md

@@ -95,7 +95,7 @@ See the reference above for:
 
 ## Task Lifecycle Integration (LOOM)
 
-All work follows the **LOOM** (Logical Order of Operations Methodology) framework through the RCASD-IVTR+C pipeline stages. See `docs/concepts/vision.md` for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.
+All work follows the **LOOM** (Logical Order of Operations Methodology) framework through the RCASD-IVTR+C pipeline stages. See `docs/concepts/CLEO-VISION.md` for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.
 
 Reference: @skills/_shared/task-system-integration.md
 

package/packages/ct-skills/skills/ct-cleo/SKILL.md

@@ -19,9 +19,9 @@ CLEO is the task management protocol for AI coding agents. It provides structure
 
 ## MCP-First Workflow
 
-MCP is the **primary** entry point. Use `cleo_query` for reads and `cleo_mutate` for writes.
+MCP is the **primary** entry point. Use `query` for reads and `mutate` for writes.
 
-### Key Read Operations (`cleo_query`)
+### Key Read Operations (`query`)
 
 | Domain | Operation | Description |
 |--------|-----------|-------------|
@@ -42,8 +42,10 @@ MCP is the **primary** entry point. Use `cleo_query` for reads and `cleo_mutate`
 | `skills` | `show` | Skill details (`params: { name }`) |
 | `pipeline` | `stage.status` | Pipeline stage for epic (`params: { epicId }`) |
 | `pipeline` | `stage.validate` | Validate gate before advancing (`params: { epicId, stage }`) |
+| `sticky` | `list` | List sticky notes (`params: { status?, tag? }`) |
+| `sticky` | `show` | Show sticky details (`params: { stickyId }`) |
 
-### Key Write Operations (`cleo_mutate`)
+### Key Write Operations (`mutate`)
 
 | Domain | Operation | Description |
 |--------|-----------|-------------|
@@ -58,6 +60,9 @@ MCP is the **primary** entry point. Use `cleo_query` for reads and `cleo_mutate`
 | `orchestrate` | `spawn` | Generate spawn prompt for subagent (`params: { taskId }`) |
 | `pipeline` | `stage.record` | Record pipeline stage progress (`params: { epicId, stage, status }`) |
 | `pipeline` | `stage.gate.pass` | Advance pipeline to next stage (`params: { epicId, stage }`) |
+| `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 }`) |
 
 ## CLI Fallback
 
@@ -71,6 +76,10 @@ ct add "Task title"        # Create task
 ct complete T1234          # Complete task
 ct start T1234             # Start working on task
 ct dash                    # Project overview
+
+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)
@@ -157,10 +166,10 @@ ct session end --note "Progress"
 ### MCP Session Operations
 
 ```
-cleo_mutate({ domain: "session", operation: "start",
+mutate({ domain: "session", operation: "start",
   params: { scope: "epic:T001", name: "Work", autoStart: true }})
-cleo_query({ domain: "session", operation: "status" })
-cleo_mutate({ domain: "session", operation: "end", params: { note: "Progress" }})
+query({ domain: "session", operation: "status" })
+mutate({ domain: "session", operation: "end", params: { note: "Progress" }})
 ```
 
 ## Error Handling
@@ -182,7 +191,7 @@ After EVERY command:
 
 ## RCSD-IVTR 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/vision.md` for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.
+**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, neural hierarchy model, and brain metaphor mapping.
 
 **Lifecycle**: See CLEO-INJECTION.md standard tier for full RCASD-IVTR+C pipeline details, or `references/loom-lifecycle.md` for gate enforcement and subagent architecture.
 

package/packages/ct-skills/skills/ct-cleo/references/loom-lifecycle.md

@@ -2,7 +2,7 @@
 
 **LOOM** (Logical Order of Operations Methodology) is the systematic framework for how CLEO processes project threads through the RCASD-IVTR+C pipeline. This document details the lifecycle stages and gate enforcement.
 
-See `docs/concepts/vision.md` for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.
+See `docs/concepts/CLEO-VISION.md` for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.
 
 ## Pipeline Stages
 

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

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

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

@@ -14,10 +14,10 @@ ct session start --scope epic:T001 --auto-focus --name "Name"
 ## MCP Session Operations
 
 ```
-cleo_mutate({ domain: "session", operation: "start",
+mutate({ domain: "session", operation: "start",
   params: { scope: "epic:T001", name: "Work", autoStart: true }})
-cleo_query({ domain: "session", operation: "status" })
-cleo_mutate({ domain: "session", operation: "end", params: { note: "Progress" }})
+query({ domain: "session", operation: "status" })
+mutate({ domain: "session", operation: "end", params: { note: "Progress" }})
 ```
 
 ## CLI Session Protocol
@@ -122,8 +122,8 @@ Skills are **context injections, NOT agents**. The orchestrator selects and inje
 ### Discovery
 
 ```
-cleo_query({ domain: "skills", operation: "list" })
-cleo_query({ domain: "skills", operation: "show", params: { name: "ct-orchestrator" }})
+query({ domain: "skills", operation: "list" })
+query({ domain: "skills", operation: "show", params: { name: "ct-orchestrator" }})
 ```
 
 ### Key Skills

package/packages/ct-skills/skills/ct-epic-architect/references/patterns.md

@@ -273,7 +273,7 @@ For code modernization, architectural improvements, and tech debt reduction:
 - "Auth stuff"
 - "Part 1"
 - "Fix things"
-- "TODO"
+- "TBD item"
 
 ### Numbered Sequences
 

package/packages/ct-skills/skills/ct-grade/SKILL.md

@@ -45,7 +45,7 @@ ct session start --scope epic:T001 --name "Feature work" --grade
 ### MCP
 
 ```
-cleo_mutate({ domain: "session", operation: "start",
+mutate({ domain: "session", operation: "start",
   params: { scope: "epic:T001", name: "Feature work", grade: true }})
 ```
 
@@ -66,7 +66,7 @@ Tests whether the agent handles errors correctly: follows up `E_NOT_FOUND` with
 Tests session discipline end-to-end: session listed before task ops, session properly ended, MCP-first usage patterns.
 
 ### 5. Multi-Domain Analysis
-Tests progressive disclosure: use of `admin.help` or skill lookups, preference for `cleo_query` (MCP) over CLI for programmatic access.
+Tests progressive disclosure: use of `admin.help` or skill lookups, preference for `query` (MCP) over CLI for programmatic access.
 
 ## Evaluating Results
 
@@ -84,11 +84,11 @@ ct grade --list
 
 ```
 # Grade a session
-cleo_query({ domain: "admin", operation: "grade",
+query({ domain: "admin", operation: "grade",
   params: { sessionId: "abc-123" }})
 
 # List past grades
-cleo_query({ domain: "admin", operation: "grade.list" })
+query({ domain: "admin", operation: "grade.list" })
 ```
 
 ## Understanding the 5 Dimensions
@@ -140,7 +140,7 @@ Starts at 20 and deducts for violations:
 | Points | Criteria |
 |--------|----------|
 | 10 | `admin.help` or skill lookup calls made |
-| 10 | `cleo_query` (MCP gateway) used for programmatic access |
+| 10 | `query` (MCP gateway) used for programmatic access |
 
 **What it measures**: Does the agent use progressive disclosure (help/skills) and prefer MCP over CLI?
 
@@ -177,7 +177,7 @@ Flags are actionable diagnostic messages. Each flag identifies a specific behavi
 - `Subtasks created without tasks.exists parent check` -- Verify parent exists first
 - `E_NOT_FOUND not followed by recovery lookup` -- Follow errors with `tasks.find` or `tasks.exists`
 - `No admin.help or skill lookup calls` -- Load `ct-cleo` for protocol guidance
-- `No MCP query calls` -- Prefer `cleo_query` over CLI
+- `No MCP query calls` -- Prefer `query` over CLI
 
 ## Common Anti-patterns
 
@@ -190,7 +190,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 `cleo_query`/`cleo_mutate` for programmatic access |
+| CLI-only usage (no MCP) | -10 S5 | Prefer `query`/`mutate` for programmatic access |
 
 ## Grade Result Schema
 
@@ -210,5 +210,5 @@ Grade results are stored in `.cleo/metrics/GRADES.jsonl` as append-only JSONL. E
 
 | Gateway | Domain | Operation | Description |
 |---------|--------|-----------|-------------|
-| `cleo_query` | `admin` | `grade` | Grade a session (`params: { sessionId }`) |
-| `cleo_query` | `admin` | `grade.list` | List all past grade results |
+| `query` | `admin` | `grade` | Grade a session (`params: { sessionId }`) |
+| `query` | `admin` | `grade.list` | List all past grade results |

package/packages/ct-skills/skills/ct-orchestrator/SKILL.md

@@ -61,7 +61,7 @@ The orchestrator manages epic-level pipeline progression through the **LOOM** (L
 
 **LOOM Pipeline Flow**: Research -> Consensus -> Architecture Decision -> Specification -> Decomposition -> Implementation -> Validation -> Testing -> Release -> Contribution
 
-See `docs/concepts/vision.md` for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.
+See `docs/concepts/CLEO-VISION.md` for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.
 
 ### Pipeline Decision Matrix
 
@@ -120,7 +120,7 @@ This separation means the orchestrator protocol works identically regardless of
 ### Quick Start — MCP (Recommended)
 
 ```
-cleo_mutate({ domain: "orchestrate", operation: "start", params: { epicId: "T1575" }})
+mutate({ domain: "orchestrate", operation: "start", params: { epicId: "T1575" }})
 ```
 
 **Returns**: Session state, context budget, next task, pipeline stage, and recommended action in one call.
@@ -135,18 +135,18 @@ cleo orchestrator start --epic T1575
 
 ```
 # 1. Check for existing work
-cleo_query({ domain: "session", operation: "list" })
-cleo_query({ domain: "research", operation: "pending" })
-cleo_query({ domain: "session", operation: "status" })
+query({ domain: "session", operation: "list" })
+query({ domain: "research", operation: "pending" })
+query({ domain: "session", operation: "status" })
 
 # 2. Get epic overview and pipeline state
-cleo_query({ domain: "system", operation: "dash" })
-cleo_query({ domain: "pipeline", operation: "stage.status", params: { epicId: "T1575" }})
+query({ domain: "system", operation: "dash" })
+query({ domain: "pipeline", operation: "stage.status", params: { epicId: "T1575" }})
 
 # 3. Resume or start
-cleo_mutate({ domain: "session", operation: "resume", params: { sessionId: "<id>" }})
+mutate({ domain: "session", operation: "resume", params: { sessionId: "<id>" }})
 # OR
-cleo_mutate({ domain: "session", operation: "start",
+mutate({ domain: "session", operation: "start",
   params: { scope: "epic:T1575", name: "Work", autoStart: true }})
 ```
 
@@ -164,12 +164,12 @@ cleo_mutate({ domain: "session", operation: "start",
 
 | MCP (Primary) | CLI (Fallback) | Purpose |
 |----------------|----------------|---------|
-| `cleo_query({ domain: "session", operation: "list" })` | `cleo session list` | Show all sessions |
-| `cleo_mutate({ domain: "session", operation: "resume", params: { sessionId } })` | `cleo session resume <id>` | Continue existing |
-| `cleo_mutate({ domain: "session", operation: "start", params: { scope, name, autoStart } })` | `cleo session start --scope epic:T1575 --auto-start` | Begin new |
-| `cleo_mutate({ domain: "session", operation: "end", params: { note } })` | `cleo session end` | Close session |
-| `cleo_query({ domain: "session", operation: "status" })` | `cleo current` | Current task |
-| `cleo_mutate({ domain: "tasks", operation: "start", params: { taskId } })` | `cleo start T1586` | Start working on task |
+| `query({ domain: "session", operation: "list" })` | `cleo session list` | Show all sessions |
+| `mutate({ domain: "session", operation: "resume", params: { sessionId } })` | `cleo session resume <id>` | Continue existing |
+| `mutate({ domain: "session", operation: "start", params: { scope, name, autoStart } })` | `cleo session start --scope epic:T1575 --auto-start` | Begin new |
+| `mutate({ domain: "session", operation: "end", params: { note } })` | `cleo session end` | Close session |
+| `query({ domain: "session", operation: "status" })` | `cleo current` | Current task |
+| `mutate({ domain: "tasks", operation: "start", params: { taskId } })` | `cleo start T1586` | Start working on task |
 
 ## Skill Dispatch (Universal Subagent Architecture)
 
@@ -205,10 +205,10 @@ Gate check: epic tasks must complete prior RCSD stages before later stages can s
 
 ```
 # 1. Check pipeline stage is appropriate for this task type
-cleo_query({ domain: "pipeline", operation: "stage.status", params: { epicId: "T1575" }})
+query({ domain: "pipeline", operation: "stage.status", params: { epicId: "T1575" }})
 
 # 2. Generate fully-resolved spawn prompt
-cleo_mutate({ domain: "orchestrate", operation: "spawn", params: { taskId: "T1586" }})
+mutate({ domain: "orchestrate", operation: "spawn", params: { taskId: "T1586" }})
 
 # 3. Delegate via the provider's native mechanism
 #    orchestrate.spawn returns a fully-resolved prompt
@@ -232,9 +232,9 @@ The spawn prompt combines the **Base Protocol** (`agents/cleo-subagent/AGENT.md`
 ### Phase 1: Discovery
 
 ```
-cleo_mutate({ domain: "orchestrate", operation: "start", params: { epicId: "T1575" }})
-cleo_query({ domain: "research", operation: "pending" })
-cleo_query({ domain: "pipeline", operation: "stage.status", params: { epicId: "T1575" }})
+mutate({ domain: "orchestrate", operation: "start", params: { epicId: "T1575" }})
+query({ domain: "research", operation: "pending" })
+query({ domain: "pipeline", operation: "stage.status", params: { epicId: "T1575" }})
 ```
 
 Check MANIFEST.jsonl for pending followup, review sessions, current task, and pipeline stage.
@@ -242,8 +242,8 @@ Check MANIFEST.jsonl for pending followup, review sessions, current task, and pi
 ### Phase 2: Planning
 
 ```
-cleo_query({ domain: "orchestrate", operation: "analyze", params: { epicId: "T1575" }})
-cleo_query({ domain: "orchestrate", operation: "ready", params: { epicId: "T1575" }})
+query({ domain: "orchestrate", operation: "analyze", params: { epicId: "T1575" }})
+query({ domain: "orchestrate", operation: "ready", params: { epicId: "T1575" }})
 ```
 
 Decompose work into subagent-sized chunks with clear completion criteria. Ensure planned tasks match the current pipeline stage.
@@ -251,8 +251,8 @@ Decompose work into subagent-sized chunks with clear completion criteria. Ensure
 ### Phase 3: Execution
 
 ```
-cleo_query({ domain: "orchestrate", operation: "next", params: { epicId: "T1575" }})
-cleo_mutate({ domain: "orchestrate", operation: "spawn", params: { taskId: "T1586" }})
+query({ domain: "orchestrate", operation: "next", params: { epicId: "T1575" }})
+mutate({ domain: "orchestrate", operation: "spawn", params: { taskId: "T1586" }})
 ```
 
 Spawn subagent via `orchestrate.spawn`. The provider's adapter handles execution. Wait for manifest entry before proceeding.
@@ -260,9 +260,9 @@ Spawn subagent via `orchestrate.spawn`. The provider's adapter handles execution
 ### Phase 4: Verification & Pipeline Advancement
 
 ```
-cleo_query({ domain: "system", operation: "context" })
-cleo_mutate({ domain: "pipeline", operation: "stage.record", params: { epicId: "T1575", stage: "research", status: "done" }})
-cleo_mutate({ domain: "pipeline", operation: "stage.gate.pass", params: { epicId: "T1575", stage: "research" }})
+query({ domain: "system", operation: "context" })
+mutate({ domain: "pipeline", operation: "stage.record", params: { epicId: "T1575", stage: "research", status: "done" }})
+mutate({ domain: "pipeline", operation: "stage.gate.pass", params: { epicId: "T1575", stage: "research" }})
 ```
 
 Verify all subagent outputs in manifest. Update CLEO task status. Record pipeline progress. Advance to next stage when all stage tasks complete.
@@ -273,37 +273,37 @@ Verify all subagent outputs in manifest. Update CLEO task status. Record pipelin
 
 | MCP (Primary) | CLI (Fallback) | Purpose |
 |----------------|----------------|---------|
-| `cleo_query({ domain: "tasks", operation: "find", params: { query } })` | `cleo find "query"` | Fuzzy search |
-| `cleo_query({ domain: "tasks", operation: "show", params: { taskId } })` | `cleo show T1234` | Full task details |
-| `cleo_query({ domain: "system", operation: "dash" })` | `cleo dash --compact` | Project overview |
-| `cleo_query({ domain: "orchestrate", operation: "ready", params: { epicId } })` | `cleo orchestrator ready --epic T1575` | Parallel-safe tasks |
-| `cleo_query({ domain: "orchestrate", operation: "next", params: { epicId } })` | `cleo orchestrator next --epic T1575` | Suggest next task |
+| `query({ domain: "tasks", operation: "find", params: { query } })` | `cleo find "query"` | Fuzzy search |
+| `query({ domain: "tasks", operation: "show", params: { taskId } })` | `cleo show T1234` | Full task details |
+| `query({ domain: "system", operation: "dash" })` | `cleo dash --compact` | Project overview |
+| `query({ domain: "orchestrate", operation: "ready", params: { epicId } })` | `cleo orchestrator ready --epic T1575` | Parallel-safe tasks |
+| `query({ domain: "orchestrate", operation: "next", params: { epicId } })` | `cleo orchestrator next --epic T1575` | Suggest next task |
 
 ### Task Coordination
 
 | MCP (Primary) | CLI (Fallback) | Purpose |
 |----------------|----------------|---------|
-| `cleo_mutate({ domain: "tasks", operation: "add", params: { title, parent } })` | `cleo add "Task" --parent T1575` | Create child task |
-| `cleo_mutate({ domain: "tasks", operation: "start", params: { taskId } })` | `cleo start T1586` | Start working on task |
-| `cleo_mutate({ domain: "tasks", operation: "complete", params: { taskId } })` | `cleo complete T1586` | Mark task done |
+| `mutate({ domain: "tasks", operation: "add", params: { title, parent } })` | `cleo add "Task" --parent T1575` | Create child task |
+| `mutate({ domain: "tasks", operation: "start", params: { taskId } })` | `cleo start T1586` | Start working on task |
+| `mutate({ domain: "tasks", operation: "complete", params: { taskId } })` | `cleo complete T1586` | Mark task done |
 
 ### Manifest & Research
 
 | MCP (Primary) | CLI (Fallback) | Purpose |
 |----------------|----------------|---------|
-| `cleo_query({ domain: "research", operation: "list" })` | `cleo research list` | List entries |
-| `cleo_query({ domain: "research", operation: "show", params: { entryId } })` | `cleo research show <id>` | Entry summary (~500 tokens) |
-| `cleo_query({ domain: "research", operation: "pending" })` | `cleo research pending` | Followup items |
-| `cleo_mutate({ domain: "research", operation: "link", params: { taskId, entryId } })` | `cleo research link T1586 <id>` | Link research to task |
+| `query({ domain: "research", operation: "list" })` | `cleo research list` | List entries |
+| `query({ domain: "research", operation: "show", params: { entryId } })` | `cleo research show <id>` | Entry summary (~500 tokens) |
+| `query({ domain: "research", operation: "pending" })` | `cleo research pending` | Followup items |
+| `mutate({ domain: "research", operation: "link", params: { taskId, entryId } })` | `cleo research link T1586 <id>` | Link research to task |
 
 ### Pipeline Operations
 
 | MCP (Primary) | CLI (Fallback) | Purpose |
 |----------------|----------------|---------|
-| `cleo_query({ domain: "pipeline", operation: "stage.status", params: { epicId } })` | `cleo pipeline status --epic T1575` | Current pipeline stage |
-| `cleo_mutate({ domain: "pipeline", operation: "stage.record", params: { epicId, stage, status } })` | `cleo pipeline record T1575 research done` | Record stage progress |
-| `cleo_query({ domain: "pipeline", operation: "stage.validate", params: { epicId, stage } })` | `cleo pipeline validate T1575 implementation` | Check gate before spawn |
-| `cleo_mutate({ domain: "pipeline", operation: "stage.gate.pass", params: { epicId, stage } })` | `cleo pipeline gate-pass T1575 research` | Advance pipeline stage |
+| `query({ domain: "pipeline", operation: "stage.status", params: { epicId } })` | `cleo pipeline status --epic T1575` | Current pipeline stage |
+| `mutate({ domain: "pipeline", operation: "stage.record", params: { epicId, stage, status } })` | `cleo pipeline record T1575 research done` | Record stage progress |
+| `query({ domain: "pipeline", operation: "stage.validate", params: { epicId, stage } })` | `cleo pipeline validate T1575 implementation` | Check gate before spawn |
+| `mutate({ domain: "pipeline", operation: "stage.gate.pass", params: { epicId, stage } })` | `cleo pipeline gate-pass T1575 research` | Advance pipeline stage |
 
 **Context Budget Rule**: Stay under 10K tokens. Use `cleo research list` over reading full files.
 

package/packages/ct-skills/skills/ct-skill-creator/SKILL.md

@@ -282,7 +282,7 @@ scripts/init_skill.py <skill-name> --path <output-directory>
 The script:
 
 - Creates the skill directory at the specified path
-- Generates a SKILL.md template with proper frontmatter and TODO placeholders
+- Generates a SKILL.md template with proper frontmatter and required placeholder guidance
 - Creates example resource directories: `scripts/`, `references/`, and `assets/`
 - Adds example files in each directory that can be customized or deleted
 

package/packages/ct-skills/skills/ct-skill-creator/scripts/init_skill.py

@@ -17,18 +17,18 @@ from pathlib import Path
 
 SKILL_TEMPLATE = """---
 name: {skill_name}
-description: [TODO: Complete and informative explanation of what the skill does and when to use it. Include WHEN to use this skill - specific scenarios, file types, or tasks that trigger it.]
+description: [Required: complete and informative explanation of what this skill does and when to use it. Include concrete trigger scenarios, file types, or task patterns.]
 ---
 
 # {skill_title}
 
 ## Overview
 
-[TODO: 1-2 sentences explaining what this skill enables]
+[Required: 1-2 sentences explaining what this skill enables]
 
 ## Structuring This Skill
 
-[TODO: Choose the structure that best fits this skill's purpose. Common patterns:
+[Choose the structure that best fits this skill's purpose. Common patterns:
 
 **1. Workflow-Based** (best for sequential processes)
 - Works well when there are clear step-by-step procedures
@@ -52,11 +52,11 @@ description: [TODO: Complete and informative explanation of what the skill does
 
 Patterns can be mixed and matched as needed. Most skills combine patterns (e.g., start with task-based, add workflow for complex operations).
 
-Delete this entire "Structuring This Skill" section when done - it's just guidance.]
+Delete this entire "Structuring This Skill" section when done - it is guidance only.]
 
-## [TODO: Replace with the first main section based on chosen structure]
+## [Replace with the first main section based on chosen structure]
 
-[TODO: Add content here. See examples in existing skills:
+[Add content here. See examples in existing skills:
 - Code samples for technical skills
 - Decision trees for complex workflows
 - Concrete examples with realistic user requests
@@ -116,7 +116,7 @@ Example real scripts from other skills:
 
 def main():
     print("This is an example script for {skill_name}")
-    # TODO: Add actual script logic here
+    # Add actual script logic here before production use.
     # This could be data processing, file conversion, API calls, etc.
 
 if __name__ == "__main__":
@@ -220,7 +220,9 @@ def init_skill(skill_name, path):
 
     # Create SKILL.md from template
     skill_title = title_case_skill_name(skill_name)
-    skill_content = SKILL_TEMPLATE.format(skill_name=skill_name, skill_title=skill_title)
+    skill_content = SKILL_TEMPLATE.format(
+        skill_name=skill_name, skill_title=skill_title
+    )
 
     skill_md_path = skill_dir / "SKILL.md"
     try:
@@ -260,8 +262,12 @@ def init_skill(skill_name, path):
     # Print next steps
     print(f"\n✅ Skill '{skill_name}' initialized successfully at {skill_dir}")
     print("\nNext steps:")
-    print("1. Edit SKILL.md to complete the TODO items and update the description")
-    print("2. Customize or delete the example files in scripts/, references/, and assets/")
+    print(
+        "1. Edit SKILL.md to complete all required placeholder text and update the description"
+    )
+    print(
+        "2. Customize or delete the example files in scripts/, references/, and assets/"
+    )
     print("3. Run the validator when ready to check the skill structure")
 
     return skill_dir

package/packages/ct-skills/skills/ct-stickynote/README.md

@@ -0,0 +1,14 @@
+# ct-stickynote
+
+Enhanced sticky note workflows for CLEO.
+
+## Features
+
+- Templates for common note types
+- Visual board view
+- Batch operations
+- Weekly digest
+
+## Usage
+
+See SKILL.md for full documentation.

package/packages/ct-skills/skills/ct-stickynote/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: ct-stickynote
+description: Quick ephemeral sticky notes for project-wide capture before formal classification
+version: 1.0.0
+category: productivity
+tier: 0
+protocol: null
+tags: [sticky, notes, capture, quick, ephemeral]
+triggers: [note, sticky, jot, capture]
+compatibility: [claude-code, gemini-cli, codex-cli, opencode]
+dependencies: []
+sharedResources: []
+license: MIT
+---
+
+# Sticky Notes Skill
+
+Quick capture ephemeral notes that fill the gap between session notes and formal tasks.
+
+## When to Use
+
+Use sticky notes for:
+- Quick thoughts that don't fit a formal task yet
+- Temporary reminders
+- Ideas that need refinement before becoming tasks
+- Notes that span multiple sessions
+
+## Operations
+
+| Operation | Usage | Example |
+|-----------|-------|---------|
+| `sticky.add` | Create sticky | `cleo sticky add "Refactor auth middleware" --tag bug --color red` |
+| `sticky.list` | List active | `cleo sticky list --tag bug` |
+| `sticky.show` | Show details | `cleo sticky show SN-001` |
+| `sticky.convert` | Promote to task/memory | `cleo sticky convert SN-001 --to-task` |
+| `sticky.archive` | Archive | `cleo sticky archive SN-001` |
+
+## Installation
+
+```bash
+cleo skill install library:ct-stickynote
+```
+
+## Auto-Archive
+
+Stickies auto-archive after 30 days if not converted.

package/packages/ct-skills/skills.json

@@ -244,9 +244,9 @@
     },
     {
       "name": "loom",
-      "description": "LOOM (Logical Order of Operations Methodology) - the systematic framework for how CLEO processes project threads through the RCASD-IVTR+C pipeline. LOOM encompasses the full lifecycle methodology that transforms raw ideas into delivered artifacts, from Research through Release with the Contribution protocol (+C) running across all stages. References docs/concepts/vision.md for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.",
+      "description": "LOOM (Logical Order of Operations Methodology) - the systematic framework for how CLEO processes project threads through the RCASD-IVTR+C pipeline. LOOM encompasses the full lifecycle methodology that transforms raw ideas into delivered artifacts, from Research through Release with the Contribution protocol (+C) running across all stages. References docs/concepts/CLEO-VISION.md for the complete LOOM framework, neural hierarchy model, and brain metaphor mapping.",
       "version": "1.0.0",
-      "path": "docs/concepts/vision.md",
+      "path": "docs/concepts/CLEO-VISION.md",
       "references": [".cleo/adrs/ADR-007-domain-consolidation.md", ".cleo/adrs/ADR-009-BRAIN-cognitive-architecture.md"],
       "core": false,
       "category": "core",
@@ -258,7 +258,7 @@
       "license": "MIT",
       "metadata": {
         "concepts": ["LOOM", "RCASD-IVTR+C", "lifecycle pipeline", "neural hierarchy", "brain metaphor"],
-        "domains": ["tasks", "session", "memory", "check", "pipeline", "orchestrate", "tools", "admin", "nexus", "sharing"]
+        "domains": ["tasks", "session", "memory", "check", "pipeline", "orchestrate", "tools", "admin", "nexus", "sticky"]
       }
     }
   ]

package/schemas/nexus-registry.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://cleo-dev.com/schemas/v1/nexus-registry.schema.json",
   "title": "CLEO Nexus Registry Schema (DEPRECATED)",
-  "description": "DEPRECATED: This schema is superseded by projects-registry.schema.json (v2.0.0). The unified registry at ~/.cleo/projects-registry.json now serves both global project management and Nexus cross-project coordination. This file is retained for reference only.",
+  "description": "DEPRECATED: This schema is no longer used. nexus.db (SQLite) is the live backend as of 2026.3. Legacy JSON (projects-registry.json) is auto-migrated on first nexus init. Retained for historical reference only.",
   "type": "object",
   "required": ["version", "lastUpdated", "projects"],
   "additionalProperties": false,