sinapse-ai 1.0.0

package/squad-claude/tasks/create-team-topology.md

@@ -0,0 +1,72 @@
+---
+task: create-team-topology
+responsavel: "@swarm-orchestrator"
+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"
+---
+
+# Create Team Topology
+
+## Objective
+
+Design a multi-agent team topology for a Claude Code project, defining agent roles, communication patterns, shared resources, and coordination protocols. Produce agent configuration files and orchestration rules.
+
+## Inputs
+
+- Project scope and complexity
+- Types of work to be done (coding, testing, review, documentation, deployment)
+- Parallelism potential (independent features? shared codebase?)
+- Team topology preference (stream-aligned, platform, enabling, or hybrid)
+
+## Steps
+
+1. **Assess Workload** — Classify the project's work into domains: feature development, testing/QA, infrastructure, documentation, research. Estimate relative effort for each.
+2. **Select Topology Pattern** — Choose the primary pattern: Stream-aligned (feature teams, one agent per feature), Platform (shared service agents), Enabling (coaching/review agents), or Hybrid.
+3. **Define Agent Roles** — For each agent in the topology: name, responsibility scope, tools needed, files it can access, and its interaction pattern with other agents.
+4. **Design Communication Channels** — Define how agents communicate: shared files (handoff artifacts), status files (JSON), or direct subagent invocation. Minimize coordination overhead.
+5. **Set Boundaries** — Define explicit boundaries: which files each agent owns, which tools each agent can use, and what decisions each agent can make autonomously vs. must escalate.
+6. **Create Coordination Protocol** — Define the orchestration flow: who spawns whom, dependency order, synchronization points, and completion criteria.
+7. **Generate Configuration** — Produce agent definition files, orchestration rules, and a team manifest document.
+
+## Quality Gates
+
+- Every work domain must be covered by at least one agent
+- No two agents should own the same file (ownership conflicts)
+- Communication protocol must be documented and testable
+- Coordination overhead must be estimated and acceptable (< 20% of total work)
+
+## Output Format
+
+```markdown
+# Team Topology: {project name}
+
+## Topology Pattern: {pattern}
+
+## Agent Roster
+| Agent | Role | Domain | Tools | Files Owned |
+|-------|------|--------|-------|-------------|
+
+## Communication Protocol
+{diagram or description}
+
+## Coordination Flow
+{sequence of operations}
+
+## Agent Definition Files
+{list of files to create}
+```

package/squad-claude/tasks/diagnose.md

@@ -0,0 +1,76 @@
+---
+task: diagnose
+responsavel: "@cm-orchestrator"
+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"
+---
+
+# Diagnose
+
+## Objective
+
+Diagnose and resolve Claude Code issues by systematically narrowing down the problem domain, identifying root causes, and providing actionable fixes. Covers configuration errors, hook failures, MCP connectivity issues, context overflow, and permission problems.
+
+## Inputs
+
+- Symptom description (what is going wrong)
+- Error messages (if any)
+- Recent changes to configuration (if known)
+- Claude Code version
+- Operating system and shell environment
+
+## Steps
+
+1. **Classify Symptom** — Categorize the issue: Configuration (wrong behavior), Hook (automation failure), MCP (connection/tool error), Context (overflow/degradation), Permission (blocked action), or Unknown.
+2. **Gather Diagnostics** — Read relevant configuration files based on classification. For config issues: settings.json + CLAUDE.md. For hooks: hook definitions + recent logs. For MCP: server configs + connection status. For context: measure token footprint.
+3. **Check Common Causes** — Run through the common causes checklist for the classified category: syntax errors, missing fields, version incompatibilities, permission mismatches, stale caches.
+4. **Identify Root Cause** — Trace the symptom to its root cause using elimination. Document the causal chain: trigger -> intermediate effect -> observed symptom.
+5. **Design Fix** — Create a specific, minimal fix that addresses the root cause without side effects. Include rollback instructions.
+6. **Validate Fix** — Verify the fix resolves the symptom and does not introduce regressions. If the fix involves config changes, run the relevant audit task.
+7. **Document Resolution** — Record the issue, root cause, and fix for future reference.
+
+## Quality Gates
+
+- Root cause must be identified (not just symptom treated)
+- Fix must be minimal (no unnecessary changes)
+- Rollback instructions must be provided
+- Resolution must be documented
+
+## Output Format
+
+```markdown
+# Diagnosis Report
+
+## Symptom
+{description}
+
+## Classification
+{category}
+
+## Root Cause
+{explanation with causal chain}
+
+## Fix
+{step-by-step fix instructions}
+
+## Rollback
+{how to undo the fix if needed}
+
+## Prevention
+{how to prevent this issue in the future}
+```

package/squad-claude/tasks/end-to-end-ai-workflow.md

@@ -0,0 +1,103 @@
+---
+task: end-to-end-ai-workflow
+responsavel: "@swarm-orchestrator"
+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"
+---
+
+# End-to-End AI Workflow
+
+## Objective
+
+Design complete AI-powered workflows that take a process from input to final output using Claude Code as the orchestration layer. Map every step, tool interaction, decision point, and quality gate to create a repeatable, auditable workflow that maximizes AI assistance while maintaining human oversight.
+
+## Pre-Conditions
+
+- Business process or development workflow to automate identified
+- Current manual process documented with pain points
+- Available AI tools and MCP servers inventoried
+- Human-in-the-loop requirements defined (which decisions need human approval)
+- Success metrics established (time saved, quality improvement, error reduction)
+
+## Steps
+
+1. **Map the Current Process** — Document the existing workflow step by step: who does what, in what order, with what tools, producing what outputs. Identify bottlenecks, error-prone steps, and steps that are purely mechanical (candidates for full automation).
+2. **Classify Automation Potential** — For each step, classify: fully automatable (no judgment needed, clear rules), AI-assisted (AI does the work, human reviews), human-required (judgment, creativity, or approval needed), and hybrid (AI prepares, human decides). Create an automation heat map.
+3. **Design the AI Workflow** — Redesign the process with AI integration: replace mechanical steps with tool calls, add AI analysis where human judgment was needed for routine decisions, and keep human checkpoints for critical decisions. Produce a step-by-step workflow definition.
+4. **Select Tools per Step** — For each automated step, select the optimal tool: native Claude Code tools (Read, Write, Bash, Grep), MCP tools (Supabase, GitHub, Figma), external APIs, or custom scripts. Document why each tool was chosen and its fallback.
+5. **Design Data Flow** — Map how data moves through the workflow: inputs enter at step 1, transformed through intermediate steps, quality-checked at gates, and delivered as final output. Define the data schema at each transition point.
+6. **Implement Quality Gates** — Place automated quality checks at critical points: after data transformation (validate output schema), before external actions (confirm parameters), after AI generation (check for hallucination markers), and before delivery (final quality sweep).
+7. **Add Error Handling and Recovery** — For each step, define: what can go wrong (tool failure, unexpected input, quality gate failure), how to detect it (error codes, validation failures), how to recover (retry, fallback, escalate), and how to communicate the issue.
+8. **Create Monitoring Points** — Design observability: log each step's input/output (with PII redaction), track execution time per step, measure quality gate pass rates, and alert on failures or degradation.
+9. **Build the Workflow Definition** — Package the workflow as a reusable definition: YAML or markdown format, step definitions with tool references, quality gate definitions, error handling rules, and human checkpoint specifications.
+10. **Test End-to-End** — Execute the workflow against real scenarios: standard input (happy path), edge case input (boundary conditions), failure scenarios (tool unavailable, invalid data), and high-volume input (performance test). Document results and refine.
+11. **Measure ROI** — Compare the AI workflow against the manual process: time per execution, error rate, human effort required, and output quality. Calculate the automation ROI.
+
+## Output
+
+```markdown
+# End-to-End AI Workflow: {Workflow Name}
+
+## Process Overview
+| Step | Type | Tool | Input | Output | Gate |
+|------|------|------|-------|--------|------|
+
+## Automation Map
+| Step | Current (Manual) | Proposed (AI) | Classification |
+|------|-----------------|---------------|---------------|
+
+## Data Flow
+{step 1} --{schema}--> {step 2} --{schema}--> {step 3}
+
+## Quality Gates
+| Gate | After Step | Checks | Pass Criteria | On Fail |
+|------|-----------|--------|--------------|---------|
+
+## Error Handling
+| Step | Failure Mode | Detection | Recovery | Escalation |
+|------|-------------|-----------|----------|-----------|
+
+## Workflow Definition
+```yaml
+workflow:
+  name: "{name}"
+  steps:
+    - id: "{step_id}"
+      tool: "{tool}"
+      input: "{schema}"
+      output: "{schema}"
+      gate: "{gate_id}"
+      on_error: "{strategy}"
+```
+
+## ROI Analysis
+| Metric | Manual | AI-Powered | Improvement |
+|--------|--------|-----------|-------------|
+| Time per execution | {duration} | {duration} | {%} |
+| Error rate | {%} | {%} | {%} |
+| Human effort | {hours} | {hours} | {%} |
+```
+
+## Quality Criteria
+
+- Every step must have defined input/output schemas (no ambiguous data flow)
+- Quality gates must be placed after every AI-generation step
+- Error handling must cover at least 3 failure modes per step
+- Human checkpoints must be placed at all critical decision points
+- Workflow must be reproducible (same input produces consistent output)
+- ROI analysis must show at least 30% improvement on one key metric

package/squad-claude/tasks/enterprise-config.md

@@ -0,0 +1,74 @@
+---
+task: enterprise-config
+responsavel: "@roadmap-sentinel"
+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"
+---
+
+# Enterprise Config
+
+## Objective
+
+Design enterprise-grade Claude Code configuration with managed policies, compliance controls, audit logging, and organization-wide standards. Produce configurations suitable for deployment across multiple teams and projects.
+
+## Inputs
+
+- Organization size and structure (teams, projects, repos)
+- Compliance requirements (SOC2, HIPAA, GDPR, etc.)
+- Security policies (data classification, network restrictions)
+- Managed policy deployment mechanism (MDM, central config repo)
+- Standardization requirements (what must be uniform across teams)
+
+## Steps
+
+1. **Map Organization Structure** — Document teams, projects, and their relationships. Identify which configurations should be organization-wide, team-level, or project-level.
+2. **Design Managed Policies** — Create top-level managed policies that enforce non-negotiable rules across the organization: deny lists for dangerous operations, required security hooks, mandatory MCP configurations.
+3. **Define Compliance Controls** — For each compliance requirement, map to specific Claude Code configurations: data handling restrictions, audit logging, access controls, network restrictions.
+4. **Create Policy Templates** — Build reusable configuration templates for common team types: frontend team, backend team, data team, DevOps team. Each template extends the organization policy.
+5. **Design Deployment Strategy** — Plan how managed policies are distributed: central git repo with CI/CD, MDM push, or manual distribution with verification scripts.
+6. **Build Audit Trail** — Design hooks and logging that create audit trails for Claude Code operations: what was generated, what was approved, what was denied, by whom.
+7. **Create Rollout Plan** — Phase the enterprise deployment: pilot team first, then gradual expansion. Include feedback loops and adjustment periods.
+
+## Quality Gates
+
+- Managed policies must enforce all compliance requirements
+- No team-level override can weaken organization-level policies
+- Audit trail must capture all required compliance events
+- Rollout plan must include rollback procedures
+
+## Output Format
+
+```markdown
+# Enterprise Configuration
+
+## Organization Policies
+{managed policy files}
+
+## Team Templates
+{per-team-type configurations}
+
+## Compliance Mapping
+| Requirement | Control | Configuration |
+|------------|---------|---------------|
+
+## Deployment Strategy
+{distribution plan}
+
+## Rollout Plan
+{phased timeline}
+```

package/squad-claude/tasks/few-shot-example-library.md

@@ -0,0 +1,93 @@
+---
+task: few-shot-example-library
+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"
+---
+
+# Few-Shot Example Library
+
+## Objective
+
+Build a curated library of few-shot examples organized by task type, difficulty, and domain. Each example set must demonstrate ideal input-output pairs that consistently improve model performance when included in prompts.
+
+## Pre-Conditions
+
+- Target tasks and domains identified for few-shot coverage
+- Access to high-quality input-output pairs (human-validated)
+- Token budget constraints defined per prompt category
+- Baseline performance metrics without few-shot examples available
+- Output format standards established for each task type
+
+## Steps
+
+1. **Inventory Task Categories** — Catalog all task types that benefit from few-shot examples: code generation, data transformation, analysis, classification, summarization, creative writing, structured output generation. Group related tasks into categories.
+2. **Define Example Quality Criteria** — Establish what makes a good few-shot example: representative of the task, diverse in complexity, demonstrates edge cases, follows exact output format, minimal but complete. Create a scoring rubric (1-5 scale).
+3. **Collect Candidate Examples** — For each task category, gather 10-15 candidate input-output pairs from real interactions, documentation, or manual creation. Ensure diversity in input length, complexity, and edge case coverage.
+4. **Curate and Score** — Apply the quality rubric to each candidate. Discard examples scoring below 3. For each task category, select the top 3-5 examples that provide maximum coverage with minimum redundancy.
+5. **Order Examples Strategically** — Arrange examples from simple to complex within each set. The first example should be the clearest demonstration of the pattern. The last example should cover the most common edge case.
+6. **Format for Token Efficiency** — Standardize example formatting: use consistent delimiters (---), clear input/output labels, minimal whitespace. Measure token count per example set. Create compact and full versions.
+7. **Test Example Effectiveness** — For each example set, measure model performance with 0, 1, 3, and 5 examples. Identify the point of diminishing returns. Document the optimal number of examples per task type.
+8. **Build the Library Index** — Create a searchable index with: task category, example count, token cost, effectiveness score, last validated date, and usage instructions. Organize by domain and difficulty.
+9. **Create Retrieval Guidelines** — Document when to use each example set: trigger conditions, compatible prompt patterns, known conflicts with other prompt elements, and fallback options.
+10. **Establish Maintenance Process** — Define how examples are updated: validation schedule (monthly), retirement criteria (accuracy drops below threshold), addition process (new examples must pass rubric), and version tracking.
+
+## Output
+
+```markdown
+# Few-Shot Example Library
+
+## Index
+| Category | Examples | Token Cost | Effectiveness | Last Validated |
+|----------|----------|-----------|---------------|----------------|
+
+## Example Sets
+
+### {Category Name}
+**Usage:** {when to use this set}
+**Token cost:** {compact/full}
+
+#### Example 1 (Simple)
+**Input:** {input}
+**Output:** {output}
+
+#### Example 2 (Standard)
+**Input:** {input}
+**Output:** {output}
+
+#### Example 3 (Edge Case)
+**Input:** {input}
+**Output:** {output}
+
+## Retrieval Guidelines
+| Trigger | Example Set | Notes |
+|---------|-------------|-------|
+
+## Maintenance Schedule
+- Next validation: {date}
+- Retirement queue: {list}
+```
+
+## Quality Criteria
+
+- Library must cover at least 5 distinct task categories
+- Each example set must score 4+ on the quality rubric
+- Token cost per example set must be documented and within budget
+- Adding few-shot examples must improve task accuracy by at least 10% over zero-shot
+- Each example set must include at least one edge case demonstration
+- Library index must be searchable by category, domain, and token cost

package/squad-claude/tasks/hook-designer.md

@@ -0,0 +1,72 @@
+---
+task: hook-designer
+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"
+---
+
+# Hook Designer
+
+## Objective
+
+Design and implement custom Claude Code hooks for specific automation needs. Produce hook configurations with proper event bindings, matchers, command definitions, and error handling for the target hook events.
+
+## Inputs
+
+- Automation goal (what should happen automatically)
+- Target hook event(s) (PreToolUse, PostToolUse, Notification, Stop, SubagentStop, etc.)
+- Trigger conditions (tool name, file pattern, error type, etc.)
+- Desired action (run command, block action, modify output, send notification)
+- Performance constraints (max latency tolerance)
+
+## Steps
+
+1. **Map Goal to Events** — Determine which hook event(s) are needed. PreToolUse for gates/blocking, PostToolUse for reactions, Notification for alerts, Stop for cleanup, SubagentStop for agent lifecycle.
+2. **Define Matchers** — Specify the matcher configuration: tool name patterns, file globs, content patterns, or custom conditions that trigger the hook.
+3. **Design Command** — Write the shell command or script that executes when the hook fires. Ensure it handles the hook payload (stdin JSON with session_id, tool_name, tool_input, etc.).
+4. **Implement Error Handling** — Define behavior on command failure: block (for PreToolUse), warn (for PostToolUse), retry (with backoff), or ignore.
+5. **Set Timeout and Performance** — Configure timeout values. PreToolUse hooks must be fast (< 500ms). PostToolUse hooks can be slower. Notification hooks should be async.
+6. **Write Hook Configuration** — Produce the complete hook entry for settings.json or .claude/hooks.json in the correct schema format.
+7. **Test Hook** — Describe test scenarios to verify the hook fires correctly, handles edge cases, and meets performance targets.
+
+## Quality Gates
+
+- Hook must fire on correct events only (no false triggers)
+- Command must handle all expected payload shapes
+- Timeout must be set appropriately for the event type
+- Error handling must not block Claude Code operation (except intentional PreToolUse gates)
+- Hook must be documented with purpose, trigger, and expected behavior
+
+## Output Format
+
+```json
+{
+  "hooks": {
+    "{event_name}": [
+      {
+        "matcher": "{pattern}",
+        "command": "{shell command}",
+        "timeout": 5000,
+        "on_error": "warn"
+      }
+    ]
+  }
+}
+```
+
+Plus documentation block explaining purpose, trigger conditions, and test plan.

package/squad-claude/tasks/human-in-the-loop-design.md

@@ -0,0 +1,102 @@
+---
+task: human-in-the-loop-design
+responsavel: "@swarm-orchestrator"
+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"
+---
+
+# Human-in-the-Loop Design
+
+## Objective
+
+Design human-in-the-loop (HITL) patterns for AI-powered workflows that balance automation speed with human oversight. Define when human intervention is required, how to present decisions effectively, how to incorporate feedback, and how to minimize friction while maintaining control.
+
+## Pre-Conditions
+
+- AI workflow identified that requires human oversight
+- Risk assessment completed (what happens if AI makes wrong decision)
+- Human reviewer roles and availability defined
+- Acceptable response time for human review established
+- Feedback capture requirements documented
+
+## Steps
+
+1. **Classify Decision Points** — Analyze the workflow and classify each decision point: autonomous (AI decides, low risk, reversible), supervised (AI recommends, human approves, medium risk), controlled (human decides with AI assistance, high risk), and manual (human only, critical/irreversible). Create a decision classification matrix.
+2. **Design Approval Workflows** — For supervised decisions, design the approval flow: AI generates recommendation with reasoning, presents to human with clear options (approve/reject/modify), captures human decision with optional rationale, and proceeds based on decision. Define timeout behavior (auto-approve, auto-reject, or escalate).
+3. **Create Decision Presentation Format** — Design how AI presents decisions to humans: summary of the situation, AI recommendation with confidence level, alternatives considered with pros/cons, risk assessment, and clear action buttons. Minimize cognitive load — the human should be able to decide in under 30 seconds for routine decisions.
+4. **Implement Feedback Capture** — Design how human feedback is collected and used: structured feedback (approve/reject + reason code), free-text feedback (for nuanced corrections), implicit feedback (human modifies AI output — capture the delta), and batch feedback (periodic review of AI decisions).
+5. **Build Escalation Paths** — Define escalation triggers: AI confidence below threshold, human reviewer unavailable within timeout, conflicting feedback from multiple reviewers, and novel situations not covered by existing rules. Each trigger must have a clear escalation target and procedure.
+6. **Design Progressive Autonomy** — Create a system where the AI earns more autonomy over time: track AI decision quality per category, increase autonomy threshold when accuracy exceeds target (e.g., 95% approval rate for 30 days), decrease autonomy when errors occur, and notify humans of autonomy level changes.
+7. **Implement Audit Trail** — Design a complete audit trail: every AI decision (with reasoning), every human override (with rationale), every escalation (with resolution), and every autonomy level change. The audit trail must be searchable and support compliance review.
+8. **Create Undo and Rollback** — Design undo capabilities for human-approved actions: immediate undo (within time window), rollback (revert to previous state), and damage assessment (what was affected by the decision). Define which actions are reversible and which are not.
+9. **Optimize the Human Experience** — Reduce reviewer fatigue: batch similar decisions for efficient review, highlight anomalies that need attention, provide context summaries (not raw data), and track reviewer workload to prevent burnout.
+10. **Test with Simulation** — Simulate the HITL workflow: generate realistic decision scenarios, present to test reviewers, measure decision time, accuracy, and satisfaction. Identify friction points and optimize the flow.
+
+## Output
+
+```markdown
+# Human-in-the-Loop Design: {Workflow Name}
+
+## Decision Classification Matrix
+| Decision Point | Classification | Risk Level | Reversible? |
+|---------------|---------------|-----------|-------------|
+| {decision} | {autonomous/supervised/controlled/manual} | {low/med/high} | {yes/no} |
+
+## Approval Workflow
+### Supervised Decisions
+1. AI generates recommendation
+2. Present to reviewer: {format}
+3. Reviewer decides: {options}
+4. Capture feedback: {method}
+5. Timeout: {action after N minutes}
+
+## Decision Presentation Template
+```
+## Decision Required: {title}
+**Situation:** {1-2 sentence summary}
+**AI Recommendation:** {recommendation} (Confidence: {%})
+**Alternatives:** {list}
+**Risk:** {assessment}
+**Actions:** [Approve] [Reject] [Modify]
+```
+
+## Progressive Autonomy Rules
+| Category | Current Level | Threshold to Upgrade | Threshold to Downgrade |
+|----------|-------------|---------------------|----------------------|
+
+## Audit Trail Schema
+| Field | Type | Purpose |
+|-------|------|---------|
+
+## Escalation Paths
+| Trigger | Escalation Target | Procedure | SLA |
+|---------|-------------------|-----------|-----|
+
+## Undo Capabilities
+| Action Type | Undo Window | Rollback Method |
+|------------|-------------|----------------|
+```
+
+## Quality Criteria
+
+- Every decision point must be classified with risk level and reversibility
+- Supervised decisions must present recommendation in a format decidable in under 30 seconds
+- Feedback capture must support both structured and free-text input
+- Progressive autonomy must have clear, measurable thresholds for upgrade and downgrade
+- Audit trail must be complete (zero gaps in decision history)
+- Undo capabilities must exist for all reversible actions with defined time windows

package/squad-claude/tasks/integrate-project.md

@@ -0,0 +1,73 @@
+---
+task: integrate-project
+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"
+---
+
+# Integrate Project
+
+## Objective
+
+Integrate Claude Code into an existing project by assessing current state, identifying the optimal configuration for the project's stack, and creating all necessary configuration files without disrupting existing workflows.
+
+## Inputs
+
+- Project root path
+- Technology stack (language, framework, package manager)
+- Existing AI tooling (Copilot, Cursor, other)
+- Team conventions and coding standards
+- CI/CD pipeline (if any)
+
+## Steps
+
+1. **Scan Project Structure** — Map the repository: identify source directories, test directories, config files, build systems, and any existing .claude/ or CLAUDE.md files.
+2. **Identify Framework** — Detect the primary framework(s): Next.js, React, Vue, Angular, Express, FastAPI, Django, Rust, Go, etc. Each has specific Claude Code optimization patterns.
+3. **Assess Current AI Tooling** — Check for existing AI configurations (.cursor/, .github/copilot/, etc.). Plan how Claude Code will coexist or replace these.
+4. **Generate CLAUDE.md** — Delegate to `@config-engineer` via `claude-md-engineer` task. Include framework-specific conventions, project structure, and coding standards.
+5. **Configure Settings** — Delegate to `@config-engineer` via `configure-settings` task. Set permissions appropriate for the project's security requirements.
+6. **Create Initial Rules** — Delegate to `@config-engineer` via `create-rules` task. Create rules for the most common file patterns in the project.
+7. **Validate Integration** — Run a test session: read a file, make a small edit, run a command. Verify Claude Code behaves according to the configuration.
+8. **Document Integration** — Produce a summary of what was configured, what conventions were adopted, and what the team needs to know.
+
+## Quality Gates
+
+- All config files must pass validation
+- CLAUDE.md must reference actual project paths and conventions
+- No existing workflows disrupted (existing tooling still works)
+- Test session must complete without permission errors or misconfigurations
+
+## Output Format
+
+```markdown
+# Project Integration Complete
+
+## Project: {name}
+## Stack: {stack}
+
+## Files Created
+- {list}
+
+## Configuration Summary
+- Permissions: {mode}
+- Rules: {count} files
+- MCP servers: {count}
+
+## Team Onboarding Notes
+{what the team needs to know}
+```