Claude Skills by masharratt

Unified atomic ingestion of CFN dependency manifests (trigger-dev, cli-mode, shared)

Skill deployment and promotion lifecycle management. Use when transitioning skills from APPROVED to DEPLOYED status, or promoting skills from staging to production with SLA enforcement.

Automated skill deployment pipeline for CFN Loop integration

Skill Promotion Workflow - Atomic promotion from staging to production

Pre-edit backup and post-edit validation for safe file modifications. Use when you need to capture file state before edits, validate changes after modifications, revert files to previous state, or ensure edit safety with automatic backup and validation hooks.

Creates and manages file backups before edit operations in agent workflows.

Hybrid AISP epic creation with formal API contracts and natural language user content. Uses AISP (AI Symbolic Protocol) for type definitions and agent binding contracts while preserving human-readable descriptions.

Creates comprehensive epic definitions with sequential reviews from 10 key personas. Use when you need to analyze requirements from multiple perspectives and generate structured epic documentation with cost estimates and risk assessments.

Converts natural language epic documents from markdown into structured JSON configurations for MDAP or CFN Loop execution. Use when you need to parse epic documents, validate epic structure, or generate execution configurations from planning documents.

Unified error handling, batching, and logging for CFN Loop. Use when you need to capture agent errors, batch multiple errors for processing, log structured error data, or categorize and recover from agent failures.

Update CFN system expert agent with relevant git commits and project changes

Human intervention detection and orchestration for CFN Loop. Use when automated processes need human oversight, when escalation is required, or when managing intervention workflows and approval gates.

Detect problematic patterns in agent performance during CFN Loop iterations that may require intervention. 1. **Confidence Plateau**: - Minimal confidence improvement over multiple iterations - Threshold: Δ < 0.05 for 2+ consecutive iterations 2. **Recurring Feedback**: - Same feedback theme repeated 3+ times - Indicates underlying issue not being addressed 3. **Deliverables Stuck**: - No new files created in 2+ consecutive iterations - Configurable thresholds

Coordinate and execute intervention strategies during CFN Loop execution. 1. Agent Swap 2. Specialist Injection 3. Scope Simplification 1. Receive intervention trigger 2. Analyze current loop context 3. Select appropriate intervention strategy 4. Generate actionable recommendations 5. Prepare configuration for next iteration ```bash ./execute-intervention.sh \ --trigger "confidence_plateau" \ --iteration 3 \ --loop3-agents "backend-dev,coder" \ --feedback-themes

Organizational learning from CFN Loop execution - workflow codification and playbooks. Use when you need to store successful patterns, query past learnings, track edge cases and failures, or retrieve agent configurations and iteration strategies from previous tasks.

**Version:** 1.0.0 **Purpose:** Store and query successful CFN Loop patterns for continuous improvement

The Workflow Codification skill provides edge case tracking and cost tracking capabilities for CFN skills. It captures execution failures, detects patterns, generates update proposals, and calculates ROI metrics.

CFN Loop coordination and orchestration - gate checks, validation, consensus, coordination patterns. Use when orchestrating multi-agent workflows, managing iteration cycles, or coordinating Loop 2/Loop 3 dependencies.

Strategic decision-making for CFN Loop progression with robust parsing. Use when evaluating validator consensus and determining PROCEED/ITERATE/ABORT outcomes.

Type-safe output processing for Loop 2 validators and Loop 3 implementers. Use when parsing agent confidence scores, feedback, or calculating consensus from multiple validators.

Multi-layer validation and quality gates for CFN Loop workflows. Use when implementing gate checks, consensus validation, or enforcing clean agent exit patterns.

Outputs portions of CFN MDAP codebase grouped by functional area for debugging. Provides immediate context without reading entire codebase. 1. Docker mode failures → --docker flag 2. CLI mode issues → --cli flag 3. Orchestration deadlocks → --cfn-loop flag 4. Full MDAP workflow → --all flag 1. Need few files → Use Read directly 2. Runtime logs → Use docker logs 3. Documentation → Check docs/ first 4. Token budget critical → Start with --coordinator Basic: bash inject.sh --docker Advanced: bas...

cd .claude/skills/cfn-mdap-error-fixer/lib/fixer npm install cd /path/to/your/rust-project export CEREBRAS_API_KEY="your-key" npx tsx /path/to/.claude/skills/cfn-mdap-error-fixer/lib/fixer/cerebras-gated-fixer-v2.ts npx tsx cerebras-gated-fixer-v2.ts --project=/path/to/rust-project export RUST_PROJECT_PATH=/path/to/rust-project npx tsx cerebras-gated-fixer-v2.ts

Data persistence for CFN Loop - SQLite storage, Redis coordination, automatic memory persistence

Redis-based agent coordination with pub/sub and waiting mode

This skill provides secure SQLite memory access with a 5-level Access Control List (ACL) system, integrating with Redis for session management and caching. The implementation includes encrypted query patterns, TTL-based expiration, comprehensive test coverage, and a CLI wrapper for agent-accessible memory operations.

File and log operations for CFN

Centralized file locking and atomic write operations for bash scripts. **Part of Task 4.2: Centralized File Locking & Atomic Operations**

**Specialization**: Distributed logging, log aggregation, and monitoring **Part of**: Task 4.4 Distributed Logging Standardization

Secure SQL query execution with parameterized queries to prevent SQL injection attacks. Use when executing database queries, inserting/updating records, or performing any SQL operations that require security hardening.

Epic decomposition, coordinator planning, and scope management. Use when breaking down epics into sprints and tasks, coordinating multi-coordinator workflows, or simplifying and managing project scope boundaries.

**Purpose:** Systematic planning and validation for parallel multi-coordinator execution workflows. **Usage:** ```bash ./.claude/skills/cfn-multi-coordinator-planning/plan-multi-coordinator-work.sh [zone-config-file] ```

Break down large epics into manageable, sequenced sprints with clear dependencies and scope boundaries.

Reduce and focus project scope when agents are consistently stuck or unable to make progress. 1. Identify critical deliverables 2. Defer non-essential components 3. Create minimal, achievable goals 4. Provide focused context injection - Analyze unfinished deliverables - Select 1-2 most critical items - Generate focused, achievable context - Defer remaining deliverables to future iterations ```bash ./simplify-scope.sh \ --original-deliverables "file1.ts,file2.ts,file3.ts"

Process instrumentation and lifecycle management

Provides comprehensive process management capabilities for system-wide process orchestration. - Process start/stop/restart - System-wide process monitoring - Dependency-aware process management - Health and metrics tracking - Redis-based status updates - Event-driven process state changes - Minimal token consumption - Configurable via `config.json` - Supports dynamic process definitions - Zero-downtime process management - `redis-coordination` - `cfn-loop-validation`

Backlog and changelog management for CFN projects

Systematically capture and track backlogged items during CFN sprints to prevent work from being forgotten. Provides centralized documentation of deferred tasks with context, rationale, and proposed solutions. During CFN Loop execution, agents frequently identify improvements, optimizations, or edge cases that should be addressed but are out of scope for the current sprint. Without systematic capture, these items are lost in chat history or forgotten entirely. - **During CFN sprints** w

Systematically track implementation changes with sparse, structured entries appended to project changelog. Enables quick visibility into what changed, when, and why without verbose commit-style messages.

Provider routing and hybrid configuration for CFN

**Status:** Production Ready | **Category:** Provider Integration | **Complexity:** Low

Task("handoff-coordinator", prompt with session context)

Skill loading, propagation, and building for CFN. Use when dynamically discovering and loading skills, deploying skills across environments, or creating new skill scaffolding.

**Version:** 1.0.0 **Status:** Active **Namespace:** cfn **Priority:** 10 (Bootstrap)

Sprint planning, execution, and checkpointing for CFN Loop

Wave checkpoint mechanism provides crash recovery, orphan container detection, and automated resumption capabilities for CFN Docker orchestration. Enables orchestrators to survive process failures and resume wave execution without losing work or leaving orphaned containers. ``` execute_waves() ├── spawn_wave(task_id, wave_num) │ └── save_checkpoint(task_id, wave_num, container_ids, ...) ├── monitor_wave(task_id, wave_num) │ └── CRASH: Container/process dies

Provide a focused wrapper for executing individual sprints within a multi-sprint epic.

Generate detailed sprint plans with focused context injection, ensuring clear scope boundaries and dependencies.

./decompose-task.sh --task-id=ts-errors --description="Fix all TypeScript errors in the codebase" --tool-budget=12 --complexity=high

Classify tasks (type/domain), estimate complexity/iterations, recommend specialists from feedback themes