General implementation task execution for completing assigned CLEO tasks by following instructions and producing concrete deliverables. Handles coding, configuration, documentation work with quality verification against acceptance criteria and progress reporting. Use when executing implementation tasks, completing assigned work, or producing task deliverables. Triggers on implementation tasks, general execution needs, or task completion work.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
General implementation task execution for completing assigned CLEO tasks by following instructions and producing concrete deliverables. Handles coding, configuration, documentation work with quality verification against acceptance criteria and progress reporting. Use when executing implementation tasks, completing assigned work, or producing task deliverables. Triggers on implementation tasks, general execution needs, or task completion work.
Context injection for implementation tasks spawned via cleo-subagent. Provides domain expertise for completing assigned CLEO tasks by following their instructions and deliverables to produce concrete outputs.
Capabilities
Implementation - Execute coding, configuration, and documentation tasks
Deliverable Production - Create files, code, and artifacts as specified
Quality Verification - Validate work against acceptance criteria
Progress Reporting - Document completion via subagent protocol
Parameters (Orchestrator-Provided)
Parameter
Description
Required
{{TASK_ID}}
Current task identifier
Yes
{{TASK_NAME}}
Human-readable task name
Yes
{{TASK_INSTRUCTIONS}}
Specific execution instructions
Yes
{{DELIVERABLES_LIST}}
Expected outputs/artifacts
Yes
{{ACCEPTANCE_CRITERIA}}
Completion verification criteria
Yes
{{TOPIC_SLUG}}
URL-safe topic name for output
Yes
{{DATE}}
Current date (YYYY-MM-DD)
Yes
{{EPIC_ID}}
Parent epic identifier
No
{{SESSION_ID}}
Session identifier
No
{{DEPENDS_LIST}}
Dependencies completed
No
{{MANIFEST_SUMMARIES}}
Context from previous agents
No
{{TOPICS_JSON}}
JSON array of categorization tags
Yes
Task System Integration
@skills/_shared/task-system-integration.md
Execution Sequence
Read task: {{TASK_SHOW_CMD}} {{TASK_ID}}
Focus already set by orchestrator (set if working standalone)
When you operate inside an agent-spawned worktree (e.g. under
~/.local/share/cleo/worktrees/<hash>/<task>/), cleo docs add and
cleo changeset add automatically route their SSoT writes back to the
canonical project root. You can pass file paths relative to the
worktree cwd — the verb pre-resolves them against the worktree before
dispatching to the canonical-root-anchored sanitizer.
Both verbs detect a stray .cleo/tasks.db inside the worktree and
abort with E_STRAY_WORKTREE_DB + a clear remediation
(rm -rf <worktree>/.cleo). If you see E_PATH_TRAVERSAL,
E_FILE_ERROR: Cannot read file, or E_WT_DB_ISOLATION_VIOLATION,
update to a recent CLEO build that carries the fix-pack closing T10353
/ T10354 / T10294 / T10365.
The routing prints a one-line info message to stderr (suppress with
CLEO_QUIET=1):
[T10389] routing SSoT write from worktree cwd <cwd> → canonical project root <root>
Subagent Protocol
@skills/_shared/subagent-protocol-base.md
Output Requirements
MUST write findings to: {{OUTPUT_DIR}}/{{DATE}}_{{TOPIC_SLUG}}.md
MUST append ONE line to: {{MANIFEST_PATH}}
MUST return ONLY: "Implementation complete. Manifest appended to pipeline_manifest."
MUST NOT return implementation details in response
Output File Format
Write to {{OUTPUT_DIR}}/{{DATE}}_{{TOPIC_SLUG}}.md:
# {{TASK_NAME}}
## Summary
{{2-3 sentence overview of what was accomplished}}
## Deliverables
### {{Deliverable 1}}
{{Description of what was created/modified}}
**Files affected:**
- {{file path 1}}
- {{file path 2}}
### {{Deliverable 2}}
{{Description of what was created/modified}}
## Acceptance Criteria Verification
| Criterion | Status | Notes |
|-----------|--------|-------|
| {{Criterion 1}} | PASS/FAIL | {{Verification notes}} |
| {{Criterion 2}} | PASS/FAIL | {{Verification notes}} |
## Implementation Notes
{{Technical details, decisions made, edge cases handled}}
## Linked Tasks
- Epic: {{EPIC_ID}}- Task: {{TASK_ID}}
- Dependencies: {{DEPENDS_LIST}}
Manifest Entry Format
Append ONE entry via cleo manifest append <json> (writes to pipeline_manifest table per ADR-027):
3-7 items: deliverables completed, key decisions made
actionable
false if task complete, true if followup needed
needs_followup
Task IDs for dependent work identified during execution
topics
2-5 categorization tags matching task labels
Completion Checklist
Task details read via {{TASK_SHOW_CMD}}
Task started (if not pre-set by orchestrator)
All instructions executed
All deliverables produced
Acceptance criteria verified
Output file written to {{OUTPUT_DIR}}/
Manifest entry appended (single line, valid JSON)
Task completed via {{TASK_COMPLETE_CMD}}
Session ended with summary note (if executor owns session)
Response is ONLY the summary message
Error Handling
Partial Completion
If all deliverables cannot be produced:
Complete what is possible
Document partial progress in output file
Set manifest "status": "partial"
Add blocking items to needs_followup
Complete task (partial work is progress)
Return: "Implementation partial. Manifest appended to pipeline_manifest."
Blocked Execution
If work cannot proceed (missing dependencies, access issues, unclear requirements):
Document blocking reason in output file
Set manifest "status": "blocked"
Add blocker details to needs_followup
Do NOT complete task
Return: "Implementation blocked. Manifest appended to pipeline_manifest."
Acceptance Criteria Failure
If deliverables don't pass acceptance criteria:
Document what failed and why
Set manifest "status": "partial" or "blocked"
Add remediation suggestions to needs_followup
Complete task only if failure is documented and understood
Return appropriate status message
Session Management
Session Lifecycle
Task executor sessions support long-running work with a 72-hour timeout. Sessions persist across Claude conversations, allowing work to resume seamlessly.
MUST end sessions properly when completing work:
# After completing task work
cleo session end --note "Task {{TASK_ID}} completed: {{summary}}"
Session Cleanup
If session accumulation occurs (stale sessions from crashed agents or incomplete work):
# List all sessions including stale ones
cleo session list --all
# Clean up stale sessions (72h+ inactive)
cleo session gc
# Force cleanup including active sessions (use cautiously)
cleo session gc --include-active
Best Practices
Practice
Rationale
Always end sessions
Prevents accumulation, maintains clean state
Use descriptive end notes
Provides context for future sessions
Check session status on startup
Resume existing session if applicable
Report session issues
Blocked sessions need orchestrator attention
Quality Standards
Deliverable Quality
Complete - All specified deliverables produced
Correct - Meets acceptance criteria
Documented - Changes are explained
Tested - Verified where applicable
Execution Quality
Methodical - Follow instructions in order
Thorough - Don't skip steps
Transparent - Document decisions
Communicative - Report blockers immediately
Anti-Patterns
Pattern
Problem
Solution
Skipping acceptance check
Incomplete work
Verify every criterion
Partial deliverables
Missing outputs
Complete all or report partial
Undocumented changes
Lost context
Write detailed output file
Silent failures
Orchestrator unaware
Report via manifest status
See also / References
This skill binds to the implementation LOOM lifecycle stage. Governing ADRs:
