iron-edge 1.0.0

package/squads/squad-claude/tasks/audit-hooks.md

@@ -0,0 +1,76 @@
+---
+task: audit-hooks
+responsavel: "@hooks-architect"
+responsavel_type: Agent
+atomic_layer: Task
+elicit: false
+Entrada:
+  - campo: context
+    tipo: object
+    origem: "workflow ou manual"
+    obrigatorio: true
+Saida:
+  - campo: resultado
+    tipo: document
+    destino: "stakeholders"
+Checklist:
+  - "[ ] Validar inputs"
+  - "[ ] Executar steps"
+  - "[ ] Verificar qualidade"
+  - "[ ] Gerar output"
+---
+
+# Audit Hooks
+
+## Objective
+
+Audit all existing Claude Code hooks for completeness, correctness, performance, and security. Identify missing automation opportunities, redundant hooks, and potential failure points.
+
+## Inputs
+
+- Current hook configurations (settings.json hooks section or .claude/hooks.json)
+- Project automation requirements
+- Known hook-related issues (if any)
+
+## Steps
+
+1. **Inventory All Hooks** — List every configured hook with its event, matcher, command, timeout, and error handling. Create a complete registry.
+2. **Check Event Coverage** — Map hooks to the full event list (PreToolUse, PostToolUse, Notification, Stop, SubagentStop, etc.). Identify unhandled events that could benefit from automation.
+3. **Validate Matchers** — Verify each matcher pattern is correct, specific enough (no overly broad matches), and does not conflict with other hooks on the same event.
+4. **Test Commands** — For each hook command, verify it exists, is executable, handles the expected payload schema, and returns within the configured timeout.
+5. **Assess Performance** — Check timeout configurations against event type requirements. Flag PreToolUse hooks with > 500ms timeout. Identify hooks that could cause latency spikes.
+6. **Review Security** — Check if any hooks execute untrusted commands, expose sensitive data in payloads, or could be exploited via crafted tool inputs.
+7. **Identify Gaps** — Based on project requirements, recommend hooks that should exist but don't (e.g., no auto-lint hook, no security gate, no notification routing).
+8. **Generate Report** — Produce a scored audit report with findings and recommendations.
+
+## Quality Gates
+
+- Every configured hook must be validated
+- Performance assessment must include measured or estimated latency
+- Security review must cover command injection and data exposure risks
+- Recommendations must be actionable with specific hook configurations
+
+## Output Format
+
+```markdown
+# Hook Audit Report
+
+## Hook Inventory
+| # | Event | Matcher | Command | Timeout | Status |
+|---|-------|---------|---------|---------|--------|
+| 1 | PreToolUse | ... | ... | 5000ms | OK/WARN/FAIL |
+
+## Coverage Map
+- PreToolUse: X hooks (coverage: Y%)
+- PostToolUse: X hooks
+- ...
+
+## Issues Found
+1. [CRITICAL] ...
+2. [WARNING] ...
+
+## Missing Hooks (Recommendations)
+1. ...
+
+## Score: X/5
+```

package/squads/squad-claude/tasks/audit-settings.md

@@ -0,0 +1,72 @@
+---
+task: audit-settings
+responsavel: "@config-engineer"
+responsavel_type: Agent
+atomic_layer: Task
+elicit: false
+Entrada:
+  - campo: context
+    tipo: object
+    origem: "workflow ou manual"
+    obrigatorio: true
+Saida:
+  - campo: resultado
+    tipo: document
+    destino: "stakeholders"
+Checklist:
+  - "[ ] Validar inputs"
+  - "[ ] Executar steps"
+  - "[ ] Verificar qualidade"
+  - "[ ] Gerar output"
+---
+
+# Audit Settings
+
+## Objective
+
+Audit existing Claude Code settings for security gaps, permission inconsistencies, deprecated options, missing configurations, and optimization opportunities. Produce a scored report with specific fixes.
+
+## Inputs
+
+- .claude/settings.json (project level)
+- ~/.claude/settings.json (user level, if accessible)
+- Managed policies (if applicable)
+- .claude/settings.local.json (if exists)
+
+## Steps
+
+1. **Read All Settings Layers** — Collect settings from all levels: managed policies, user global, project, and local. Document the effective merged configuration.
+2. **Check Permission Consistency** — Verify no contradictions between layers. Check that deny rules at higher levels are not overridden at lower levels (they should not be).
+3. **Assess Security Posture** — Flag overly permissive auto-approve lists, missing deny rules for dangerous operations (rm -rf, git push --force, etc.), and exposed secrets.
+4. **Validate MCP Configurations** — Check each MCP server entry for correct schema, valid environment variable references, and appropriate transport type.
+5. **Identify Deprecated Options** — Flag any configuration keys that are deprecated in the current Claude Code version.
+6. **Check Completeness** — Compare against a reference configuration for the project's stack. Identify missing permissions, unregistered MCP servers, and absent behavioral flags.
+7. **Generate Recommendations** — Produce prioritized fixes ordered by security impact, then usability impact.
+
+## Quality Gates
+
+- All settings layers must be examined
+- Security issues must be flagged with severity (critical/high/medium/low)
+- Each finding must include the specific fix
+- Report must distinguish between project settings and user settings issues
+
+## Output Format
+
+```markdown
+# Settings Audit Report
+
+## Effective Configuration Summary
+{merged settings overview}
+
+## Security Findings
+| # | Severity | Finding | Fix |
+|---|----------|---------|-----|
+
+## Consistency Issues
+...
+
+## Missing Configurations
+...
+
+## Score: X/5
+```

package/squads/squad-claude/tasks/audit-setup.md

@@ -0,0 +1,85 @@
+---
+task: audit-setup
+responsavel: "@claude-orqx"
+responsavel_type: Agent
+atomic_layer: Task
+elicit: false
+Entrada:
+  - campo: context
+    tipo: object
+    origem: "workflow ou manual"
+    obrigatorio: true
+Saida:
+  - campo: resultado
+    tipo: document
+    destino: "stakeholders"
+Checklist:
+  - "[ ] Validar inputs"
+  - "[ ] Executar steps"
+  - "[ ] Verificar qualidade"
+  - "[ ] Gerar output"
+---
+
+# Audit Setup
+
+## Objective
+
+Perform a comprehensive audit of a project's Claude Code setup across all 6 dimensions: configuration completeness, hooks maturity, MCP integration, context efficiency, agent topology, and CI/CD readiness. Produce a scored report with prioritized recommendations.
+
+## Inputs
+
+- Project root path
+- Current .claude/ directory contents (if any)
+- CLAUDE.md files at all levels
+- Active MCP server configurations
+- Existing hooks (if any)
+
+## Steps
+
+1. **Scan Configuration Layer** — Read .claude/settings.json, all CLAUDE.md files, and .claude/rules/ directory. Check for missing required fields, deprecated options, and permission gaps.
+2. **Assess Hooks Maturity** — Enumerate all configured hooks, check event coverage (PreToolUse, PostToolUse, Notification, Stop), identify missing automation opportunities.
+3. **Evaluate MCP Integration** — List all configured MCP servers, verify connectivity, check for unused tools, assess security configuration.
+4. **Measure Context Efficiency** — Calculate total token footprint of CLAUDE.md + rules + knowledge bases. Identify redundancy, staleness, and bloat.
+5. **Review Agent Topology** — Assess subagent configurations, team topology patterns, worktree usage, and delegation clarity.
+6. **Check CI/CD Readiness** — Verify if Claude Code is integrated into CI/CD pipelines, check for automated review hooks, and assess deployment patterns.
+7. **Score Each Dimension** — Rate each dimension 1-5 (1=absent, 2=basic, 3=functional, 4=optimized, 5=exemplary). Calculate overall health score.
+8. **Generate Recommendations** — Produce prioritized list of improvements ordered by impact/effort ratio.
+
+## Quality Gates
+
+- All 6 dimensions must be assessed (no skips)
+- Each recommendation must include estimated effort (hours) and expected impact
+- Score justifications must reference specific files or configurations
+- Report must be actionable, not just descriptive
+
+## Output Format
+
+```markdown
+# Claude Code Setup Audit Report
+
+## Summary
+- **Overall Score:** X/30 (sum of 6 dimensions)
+- **Health Level:** [Critical | Needs Work | Functional | Optimized | Exemplary]
+
+## Dimension Scores
+| Dimension | Score | Key Finding |
+|-----------|-------|-------------|
+| Configuration | X/5 | ... |
+| Hooks | X/5 | ... |
+| MCP Integration | X/5 | ... |
+| Context Efficiency | X/5 | ... |
+| Agent Topology | X/5 | ... |
+| CI/CD Readiness | X/5 | ... |
+
+## Prioritized Recommendations
+1. [HIGH IMPACT] ...
+2. [MEDIUM IMPACT] ...
+3. ...
+
+## Detailed Findings
+### Configuration
+...
+### Hooks
+...
+(etc.)
+```

package/squads/squad-claude/tasks/automated-code-review-pipeline.md

@@ -0,0 +1,89 @@
+---
+task: automated-code-review-pipeline
+responsavel: "@hooks-architect"
+responsavel_type: Agent
+atomic_layer: Task
+elicit: false
+Entrada:
+  - campo: context
+    tipo: object
+    origem: "workflow ou manual"
+    obrigatorio: true
+Saida:
+  - campo: resultado
+    tipo: document
+    destino: "stakeholders"
+Checklist:
+  - "[ ] Validar inputs"
+  - "[ ] Executar steps"
+  - "[ ] Verificar qualidade"
+  - "[ ] Gerar output"
+---
+
+# Automated Code Review Pipeline
+
+## Objective
+
+Build an automated code review pipeline that uses Claude Code hooks, linting tools, and AI-powered analysis to review code changes before they are committed or pushed. Produce a pipeline that catches bugs, style violations, security issues, and architectural drift automatically.
+
+## Pre-Conditions
+
+- Project has linting and formatting tools configured (ESLint, Prettier, etc.)
+- Git repository initialized with branch protection awareness
+- Claude Code hooks system available
+- Code review criteria and standards documented
+- CI/CD pipeline accessible for integration (optional for full pipeline)
+
+## Steps
+
+1. **Define Review Stages** — Design the pipeline stages in order: Stage 1 (Pre-commit) — syntax and format checks; Stage 2 (Pre-push) — lint, type check, test; Stage 3 (PR) — AI-powered semantic review, security scan, architecture compliance.
+2. **Configure Pre-Commit Hooks** — Set up PostToolUse hooks that trigger after Bash(git commit): run linter on staged files, verify formatting compliance, check for debug statements (console.log, TODO), and validate import conventions.
+3. **Build Lint Gate** — Create a PreToolUse hook for Bash that detects git push commands and blocks them if: linting fails, type checking fails, or test suite has failures. Provide clear error messages indicating what to fix.
+4. **Design AI Review Prompt** — Create a structured prompt for AI-powered code review: include diff context, coding standards reference, common anti-patterns to check, security checklist, and output format (findings with severity, line numbers, and suggestions).
+5. **Implement Security Scanning** — Add checks for common security issues: hardcoded credentials (API keys, passwords in code), unsafe eval or exec calls, SQL injection patterns, XSS vulnerabilities in templates, and sensitive data in logs.
+6. **Add Architecture Compliance Check** — Create rules that validate architectural decisions: import boundaries (no frontend importing backend), layer violations (UI accessing database directly), dependency direction enforcement, and file placement rules.
+7. **Configure Feedback Format** — Design the review output format: severity levels (Critical/Warning/Info), file and line references, explanation of the issue, suggested fix with code example, and link to relevant coding standard.
+8. **Implement Self-Healing Loop** — For auto-fixable issues (formatting, import sorting, simple lint fixes), implement automatic correction: detect the issue, apply the fix, re-run validation, and report what was auto-fixed. Maximum 2 self-healing iterations.
+9. **Set Up Review Reporting** — Create a review summary that aggregates all findings: total issues by severity, files with most issues, recurring patterns, and trend analysis (is code quality improving or degrading over time).
+10. **Test the Pipeline** — Run the pipeline against: clean code (should pass), code with known issues (should catch all), large diffs (should complete in reasonable time), and edge cases (binary files, generated code, lock files).
+11. **Document and Onboard** — Write setup instructions, explain how to bypass the pipeline in emergencies (with justification requirement), how to add new review rules, and how to interpret review results.
+
+## Output
+
+```markdown
+# Automated Code Review Pipeline
+
+## Pipeline Stages
+| Stage | Trigger | Checks | Blocking? | Auto-Fix? |
+|-------|---------|--------|-----------|-----------|
+
+## Hook Configuration
+{JSON configuration for all review hooks}
+
+## Review Rules
+| Rule | Category | Severity | Auto-Fixable | Description |
+|------|----------|----------|-------------|-------------|
+
+## AI Review Prompt
+{complete prompt template for semantic review}
+
+## Self-Healing Config
+| Issue Type | Fix Strategy | Max Iterations |
+|-----------|-------------|----------------|
+
+## Setup Instructions
+1. {step-by-step setup}
+
+## Emergency Bypass
+- Command: {bypass command}
+- Requirement: {justification process}
+```
+
+## Quality Criteria
+
+- Pipeline must catch at least 90% of lint violations and formatting issues
+- Security scanning must detect hardcoded credentials with zero false negatives
+- Self-healing must successfully auto-fix formatting and import issues
+- Full pipeline execution must complete within 30 seconds for typical diffs
+- Review output must include actionable suggestions (not just "there is a problem")
+- Emergency bypass must be documented and require explicit justification

package/squads/squad-claude/tasks/batch-processing-workflow.md

@@ -0,0 +1,93 @@
+---
+task: batch-processing-workflow
+responsavel: "@hooks-architect"
+responsavel_type: Agent
+atomic_layer: Task
+elicit: false
+Entrada:
+  - campo: context
+    tipo: object
+    origem: "workflow ou manual"
+    obrigatorio: true
+Saida:
+  - campo: resultado
+    tipo: document
+    destino: "stakeholders"
+Checklist:
+  - "[ ] Validar inputs"
+  - "[ ] Executar steps"
+  - "[ ] Verificar qualidade"
+  - "[ ] Gerar output"
+---
+
+# Batch Processing Workflow
+
+## Objective
+
+Design batch processing workflows that leverage Claude Code to process multiple files, data sets, or operations efficiently. Create patterns for parallel processing, progress tracking, error recovery, and result aggregation across large-scale automated tasks.
+
+## Pre-Conditions
+
+- Batch operation requirements defined (what to process, how many items)
+- Input data format and source documented
+- Output format and destination specified
+- Error tolerance level defined (fail-fast vs. best-effort)
+- Resource constraints identified (memory, API rate limits, context window)
+
+## Steps
+
+1. **Define Batch Scope** — Document the batch operation: input source (file system, API, database), item count estimate, processing logic per item, output destination, and success criteria. Classify as small (< 50 items), medium (50-500), or large (500+).
+2. **Design Item Processing Logic** — Define the processing pipeline for a single item: read input, validate format, transform/analyze, generate output, and write result. Identify which steps require AI processing and which are mechanical.
+3. **Implement Chunking Strategy** — Break the batch into manageable chunks based on constraints: context window limits (max items per prompt), API rate limits (requests per second), memory constraints, and optimal parallelism level. Define chunk size and overlap handling.
+4. **Build Progress Tracking** — Create a progress tracking system: log file recording processed items, pending items, failed items, and current position. Enable resume from last checkpoint after interruption. Include estimated time remaining based on throughput.
+5. **Design Error Recovery** — Implement error handling per item and per batch: per-item errors (log, skip, retry up to 3 times), per-chunk errors (retry chunk, reduce chunk size, escalate), per-batch errors (save progress, report, allow manual resume).
+6. **Create Parallel Execution Plan** — Identify independent operations that can run in parallel: file reads, API calls, transformations. Design the parallelism strategy: concurrent tool calls within a turn, sequential turns with batched operations, or subagent delegation.
+7. **Implement Result Aggregation** — Design how individual results are combined: append to output file, merge into summary document, update database, or generate aggregate statistics. Handle partial results (some items failed) gracefully.
+8. **Add Rate Limiting** — Implement rate limiting for external API calls: token bucket or sliding window algorithm, configurable limits per API, backoff strategy when limits are hit, and queue management for pending requests.
+9. **Build Validation Pipeline** — Create post-processing validation: verify output count matches input count (minus expected failures), spot-check random results for quality, verify output format compliance, and generate quality metrics.
+10. **Create Batch Report** — Generate a comprehensive batch execution report: total items, processed/failed/skipped counts, execution time, throughput metrics, error summary with categories, and sample outputs for quality review.
+
+## Output
+
+```markdown
+# Batch Processing Workflow: {Operation Name}
+
+## Batch Configuration
+| Parameter | Value |
+|-----------|-------|
+| Input source | {source} |
+| Item count | {count} |
+| Chunk size | {size} |
+| Parallelism | {level} |
+| Error tolerance | {fail-fast/best-effort} |
+
+## Processing Pipeline
+1. {step} — {tool/method} — {output}
+2. {step} — {tool/method} — {output}
+
+## Chunking Strategy
+- Chunk size: {items per chunk}
+- Total chunks: {count}
+- Overlap handling: {strategy}
+
+## Error Recovery
+| Error Type | Strategy | Max Retries | Fallback |
+|-----------|----------|-------------|----------|
+
+## Progress Tracking
+- Log file: {path}
+- Checkpoint frequency: {every N items}
+- Resume command: {command}
+
+## Execution Report Template
+{report template with placeholders}
+```
+
+## Quality Criteria
+
+- Batch must be resumable from any checkpoint after interruption
+- Error recovery must handle all three levels (item, chunk, batch)
+- Progress tracking must be accurate to within 1% of actual completion
+- Parallel execution must not exceed defined rate limits
+- Result aggregation must account for partial failures (no silent data loss)
+- Batch report must include quality metrics alongside completion metrics

package/squads/squad-claude/tasks/brownfield-setup.md

@@ -0,0 +1,77 @@
+---
+task: brownfield-setup
+responsavel: "@project-integrator"
+responsavel_type: Agent
+atomic_layer: Task
+elicit: false
+Entrada:
+  - campo: context
+    tipo: object
+    origem: "workflow ou manual"
+    obrigatorio: true
+Saida:
+  - campo: resultado
+    tipo: document
+    destino: "stakeholders"
+Checklist:
+  - "[ ] Validar inputs"
+  - "[ ] Executar steps"
+  - "[ ] Verificar qualidade"
+  - "[ ] Gerar output"
+---
+
+# Brownfield Setup
+
+## Objective
+
+Perform a brownfield assessment of an existing project's Claude Code setup, identify the current maturity level, and create an upgrade plan to reach the target maturity level with minimal disruption.
+
+## Inputs
+
+- Project root path
+- Current .claude/ directory contents
+- Current CLAUDE.md files
+- Target maturity level (basic / standard / advanced / expert)
+- Constraints (files that must not be modified, team preferences)
+
+## Steps
+
+1. **Assess Current Maturity** — Score the existing setup using the Integration Maturity Model: Level 0 (no Claude Code), Level 1 (basic CLAUDE.md), Level 2 (rules + settings), Level 3 (hooks + MCP), Level 4 (full automation + CI/CD).
+2. **Identify Gaps** — Compare current level to target level. List every configuration, file, and integration missing to reach the target.
+3. **Check for Anti-Patterns** — Scan existing configuration for common mistakes: overly broad permissions, stale CLAUDE.md content, missing deny rules, hardcoded paths, etc.
+4. **Design Upgrade Path** — Create a step-by-step migration plan from current level to target. Each step must be independently valuable (no "all or nothing" migrations).
+5. **Estimate Effort** — For each step, estimate time and risk. Order steps by value/effort ratio for optimal adoption.
+6. **Execute First Step** — Implement the highest-value, lowest-risk step to demonstrate immediate improvement.
+7. **Generate Upgrade Plan** — Produce the complete upgrade plan with timeline, dependencies, and rollback instructions for each step.
+
+## Quality Gates
+
+- Current maturity must be accurately assessed (validated against actual files)
+- Upgrade path must be incremental (each step independently valuable)
+- Anti-patterns must be flagged with severity
+- First step must be successfully executed and validated
+
+## Output Format
+
+```markdown
+# Brownfield Assessment
+
+## Current Maturity: Level {X}
+## Target Maturity: Level {Y}
+
+## Gap Analysis
+| Gap | Priority | Effort | Risk |
+|-----|----------|--------|------|
+
+## Anti-Patterns Found
+| # | Pattern | Severity | Fix |
+|---|---------|----------|-----|
+
+## Upgrade Plan
+### Step 1 (DONE): {description}
+### Step 2: {description}
+...
+
+## Timeline
+{estimated timeline to reach target}
+```

package/squads/squad-claude/tasks/chain-of-thought-optimization.md

@@ -0,0 +1,91 @@
+---
+task: chain-of-thought-optimization
+responsavel: "@skill-craftsman"
+responsavel_type: Agent
+atomic_layer: Task
+elicit: false
+Entrada:
+  - campo: context
+    tipo: object
+    origem: "workflow ou manual"
+    obrigatorio: true
+Saida:
+  - campo: resultado
+    tipo: document
+    destino: "stakeholders"
+Checklist:
+  - "[ ] Validar inputs"
+  - "[ ] Executar steps"
+  - "[ ] Verificar qualidade"
+  - "[ ] Gerar output"
+---
+
+# Chain-of-Thought Optimization
+
+## Objective
+
+Optimize chain-of-thought (CoT) prompting strategies for complex reasoning tasks. Analyze existing prompts, identify reasoning gaps, and restructure prompts to elicit step-by-step thinking that improves accuracy and reduces hallucination in multi-step problem solving.
+
+## Pre-Conditions
+
+- Target task or domain requiring multi-step reasoning identified
+- Baseline prompts (without CoT) available for comparison
+- Sample inputs covering easy, medium, and hard difficulty levels
+- Success criteria defined (accuracy, completeness, consistency)
+- Understanding of the reasoning chain expected for the task
+
+## Steps
+
+1. **Analyze the Reasoning Task** — Break down the target task into its logical reasoning steps. Identify where the model typically fails: missing steps, incorrect inferences, premature conclusions, or circular reasoning. Document the ideal reasoning chain.
+2. **Audit Existing Prompts** — Review current prompts for reasoning quality. Score each on: step granularity (are steps explicit?), logical flow (does each step follow from the previous?), verification points (does the model check its work?), and conclusion validity.
+3. **Select CoT Strategy** — Choose the appropriate CoT variant: zero-shot CoT ("Let's think step by step"), few-shot CoT (examples with reasoning), structured CoT (numbered steps with specific sub-tasks), or self-consistency CoT (multiple reasoning paths).
+4. **Design Reasoning Scaffolds** — Create explicit reasoning templates that guide the model through the required steps. Include placeholders for intermediate results, verification checkpoints, and decision points.
+5. **Add Verification Prompts** — Insert self-check instructions at critical points: "Before proceeding, verify that X is consistent with Y", "Check your calculation by working backwards", "List any assumptions you made in this step."
+6. **Implement Step Decomposition** — Break complex steps into atomic sub-steps. Each sub-step should produce a verifiable intermediate result. Use numbered lists with clear input/output for each step.
+7. **Test with Graduated Difficulty** — Run the optimized prompt against easy, medium, and hard test cases. Track accuracy at each difficulty level. Identify the point where reasoning breaks down.
+8. **Compare Against Baseline** — Measure improvement over non-CoT baseline: accuracy delta, reasoning completeness, consistency across runs, and hallucination rate. Document with specific examples.
+9. **Optimize Token Efficiency** — Balance reasoning quality with token cost. Identify which reasoning steps are essential vs. verbose. Test compressed versions that maintain accuracy while reducing token usage by 20-30%.
+10. **Document Patterns** — Extract reusable CoT patterns that can be applied to similar tasks. Create a pattern library with trigger conditions (when to use each pattern) and expected outcomes.
+
+## Output
+
+```markdown
+# Chain-of-Thought Optimization Report
+
+## Task Analysis
+- Task: {description}
+- Reasoning steps required: {count}
+- Key failure points: {list}
+
+## Strategy Selected
+- CoT variant: {variant}
+- Rationale: {why this variant}
+
+## Optimized Prompt
+{complete prompt with CoT scaffolding}
+
+## Results
+| Difficulty | Baseline Accuracy | CoT Accuracy | Delta |
+|-----------|------------------|-------------|-------|
+| Easy      | {%}              | {%}         | {+%}  |
+| Medium    | {%}              | {%}         | {+%}  |
+| Hard      | {%}              | {%}         | {+%}  |
+
+## Reusable Patterns
+| Pattern | Trigger | Template |
+|---------|---------|----------|
+
+## Token Impact
+- Baseline tokens: {count}
+- CoT tokens: {count}
+- Cost increase: {percentage}
+```
+
+## Quality Criteria
+
+- CoT prompt must improve accuracy by at least 15% over baseline on hard tasks
+- Every reasoning step must produce a verifiable intermediate output
+- Self-check instructions must catch at least 50% of reasoning errors in testing
+- Token overhead from CoT must not exceed 3x the baseline prompt length
+- At least 3 reusable patterns must be extracted and documented
+- Prompt must maintain accuracy across 5+ consecutive runs (consistency check)

package/squads/squad-claude/tasks/ci-cd-setup.md

@@ -0,0 +1,56 @@
+---
+task: ci-cd-setup
+responsavel: "@project-integrator"
+responsavel_type: Agent
+atomic_layer: Task
+elicit: false
+Entrada:
+  - campo: context
+    tipo: object
+    origem: "workflow ou manual"
+    obrigatorio: true
+Saida:
+  - campo: resultado
+    tipo: document
+    destino: "stakeholders"
+Checklist:
+  - "[ ] Validar inputs"
+  - "[ ] Executar steps"
+  - "[ ] Verificar qualidade"
+  - "[ ] Gerar output"
+---
+
+# CI/CD Setup
+
+## Objective
+
+Integrate Claude Code into CI/CD pipelines for automated code review, generation, and validation. Configure GitHub Actions, GitLab CI, or other CI systems to leverage Claude Code in the development workflow.
+
+## Inputs
+
+- CI/CD platform (GitHub Actions, GitLab CI, Jenkins, CircleCI)
+- Pipeline triggers (PR, push, schedule)
+- Claude Code tasks to automate (code review, test generation, documentation)
+- API key management strategy
+- Cost constraints (API usage limits)
+
+## Steps
+
+1. **Assess Pipeline Requirements** — Determine which Claude Code operations should run in CI/CD: PR review, commit message validation, test generation, documentation updates, code quality checks.
+2. **Design Pipeline Stage** — Create a dedicated Claude Code stage in the CI/CD pipeline. Position it after build/test but before deploy. Define when it runs (all PRs? only specific paths?).
+3. **Configure Authentication** — Set up API key management using CI/CD secrets. Ensure keys are scoped appropriately and rotated regularly. Never hardcode keys.
+4. **Create Pipeline Configuration** — Write the CI/CD configuration file (workflow YAML, Jenkinsfile, etc.) with Claude Code invocation commands, timeout settings, and failure handling.
+5. **Implement Cost Controls** — Add guards: max token limits per run, path-based filtering (only run on changed files), caching of previous results, scheduling limits.
+6. **Add Reporting** — Configure pipeline to output Claude Code results as PR comments, check annotations, or pipeline artifacts.
+7. **Test Pipeline** — Run the pipeline on a test PR to verify: correct trigger, successful authentication, accurate results, proper reporting, and acceptable cost.
+
+## Quality Gates
+
+- API keys must be stored as CI/CD secrets (never in code)
+- Pipeline must have timeout configured (prevent runaway costs)
+- Cost controls must be implemented and tested
+- Pipeline failure must not block deployment (unless configured as required check)
+
+## Output Format
+
+Complete CI/CD configuration file plus documentation of the pipeline design, cost controls, and maintenance procedures.