@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/config/agents/catalog.yaml

@@ -3,244 +3,1180 @@ agents:
   - id: agent-orchestrator
     version: 1
     purpose: Resolve the DAG and delegate only to capable least-privilege agents.
+    use_when: ["Executable work has multiple steps or needs specialist delegation."]
+    do_not_use: ["Direct implementation, independent review, or approval."]
     codex_name: zaip-agent-orchestrator
-    nickname_candidates: [zaip-agent-Atlas, zaip-agent-Conductor, zaip-agent-Nexus]
+    codex_task_name: dave_product_owner_zaip_agent
+    persona: { nome: dave, cargo: product_owner }
+    nickname_candidates:
+      - dave_product_owner_zaip_agent
     role: orchestrator
     priority: 10
     inherits: null
-    capabilities: [dag-orchestration, lifecycle-governance]
+    capabilities:
+      - dag-orchestration
+      - lifecycle-governance
     execution_eligibility: []
-    tools: [zaip-cli]
-    skills: [zaip-skill-execution]
+    tools:
+      - zaip-cli
+    skills:
+      - zaip-skill-execution
     write_scopes: []
     permissions:
-      filesystem: { allow: [], deny: [workspace-write] }
-      network: { allow: [], deny: [external] }
-      shell: { allow: [zaip-cli], deny: [destructive] }
-      deployment: { allow: [], deny: [all] }
+      filesystem:
+        allow: []
+        deny:
+          - workspace-write
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - zaip-cli
+        deny:
+          - destructive
+      deployment:
+        allow: []
+        deny:
+          - all
     model:
-      required_capabilities: [tool-use, structured-output]
-      preferred: [policy-selected]
-    budget: { soft_cycles: 24, soft_input_tokens: 120000, max_repair_cycles: 2 }
+      required_capabilities:
+        - tool-use
+        - structured-output
+      preferred:
+        - gpt-5.6-terra
+      reasoning_effort: medium
+    budget:
+      soft_cycles: 12
     contract:
-      inputs: [prepared-plan, active-work]
-      outputs: [delegation, execution-state]
-      evidence: [run-attribution]
-    review: { can_approve: false, cannot_review_roles: [orchestrator, builder] }
-    escalation: [agent-auditor]
+      inputs:
+        - prepared-plan
+        - active-work
+      outputs:
+        - delegation
+        - execution-state
+      evidence:
+        - run-attribution
+        - idempotent-subagent-capture
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - orchestrator
+        - builder
+    escalation:
+      - agent-auditor
   - id: agent-builder
     version: 1
-    purpose: Implement bounded TypeScript work inside declared scopes.
+    purpose: Deliver generic technical work and SPEC decomposition, including dashboard or local scope when no specialist is mandatory.
+    use_when: ["Technical definition or a change without a more specific mandatory specialist."]
+    do_not_use: ["PRD, central design, specialized website, frontend, or backend work."]
     codex_name: zaip-agent-builder
-    nickname_candidates: [zaip-agent-Forge, zaip-agent-Maker, zaip-agent-Builder]
+    codex_task_name: rafa_tech_lead_zaip_agent
+    persona: { nome: rafa, cargo: tech_lead }
+    nickname_candidates:
+      - rafa_tech_lead_zaip_agent
     role: builder
     priority: 20
     inherits: null
-    capabilities: [typescript-delivery, test-authoring]
-    execution_eligibility: [delivery]
-    tools: [apply-patch, shell-read, test-runner]
-    skills: [zaip-skill-change]
-    write_scopes: [packages/*]
+    capabilities:
+      - project-stack-delivery
+      - test-authoring
+      - spec-creation
+      - spec-refinement
+      - technical-decomposition
+    execution_eligibility:
+      - delivery
+      - interaction
+    tools:
+      - apply-patch
+      - shell-read
+      - test-runner
+      - zaip-cli
+    skills:
+      - zaip-skill-change
+      - zaip-skill-spec
+    write_scopes:
+      - packages/*
+      - .agents/records/specs/*
+      - .agents/records/lifecycle/*
+      - .agents/dashboard/*
+      - .local/*
     permissions:
-      filesystem: { allow: [declared-write-scope], deny: [outside-workspace] }
-      network: { allow: [], deny: [external] }
-      shell: { allow: [tests, typecheck, build], deny: [destructive, deploy] }
-      deployment: { allow: [], deny: [all] }
+      filesystem:
+        allow:
+          - declared-write-scope
+        deny:
+          - outside-workspace
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - tests
+          - typecheck
+          - build
+          - zaip-cli
+        deny:
+          - destructive
+          - deploy
+      deployment:
+        allow: []
+        deny:
+          - all
     model:
-      required_capabilities: [code, tool-use]
-      preferred: [policy-selected]
-    budget: { soft_cycles: 40, soft_input_tokens: 180000, max_repair_cycles: 3 }
+      required_capabilities:
+        - code
+        - tool-use
+      preferred:
+        - gpt-5.6-terra
+      reasoning_effort: medium
+    budget:
+      soft_cycles: 40
     contract:
-      inputs: [task, requirements, context-pack]
-      outputs: [diff, test-results]
-      evidence: [acceptance-evidence]
-    review: { can_approve: false, cannot_review_roles: [builder] }
-    escalation: [agent-orchestrator]
+      inputs:
+        - task
+        - requirements
+        - context-pack
+      outputs:
+        - diff
+        - test-results
+        - spec-definition
+        - run-attribution
+      evidence:
+        - acceptance-evidence
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - builder
+    escalation:
+      - agent-orchestrator
   - id: agent-task-executor
     version: 1
-    purpose: Execute one bounded standalone Task end to end and return structured results to the orchestrator.
+    purpose: Execute one bounded generic Task, including dashboard or local scope, and return verification evidence to the orchestrator.
+    use_when: ["A ready, self-contained Task has no mandatory specialist scope."]
+    do_not_use: ["Macro planning, coordination, or independent review."]
     codex_name: zaip-agent-task-executor
-    nickname_candidates: [zaip-agent-Tasker, zaip-agent-Runner, zaip-agent-Executor]
+    codex_task_name: leo_software_engineer_zaip_agent
+    persona: { nome: leo, cargo: software_engineer }
+    nickname_candidates:
+      - leo_software_engineer_zaip_agent
     role: task-executor
     priority: 20
     inherits: null
-    capabilities: [task-delivery, verification, evidence-production]
-    execution_eligibility: [delivery]
-    tools: [apply-patch, shell-read, test-runner]
-    skills: [zaip-skill-change]
-    write_scopes: [declared-write-scope]
+    capabilities:
+      - task-delivery
+      - verification
+      - evidence-production
+    execution_eligibility:
+      - delivery
+    tools:
+      - apply-patch
+      - shell-read
+      - test-runner
+    skills:
+      - zaip-skill-change
+    write_scopes:
+      - declared-write-scope
     permissions:
-      filesystem: { allow: [declared-write-scope], deny: [outside-workspace] }
-      network: { allow: [], deny: [external] }
-      shell: { allow: [tests, typecheck, build], deny: [destructive, deploy] }
-      deployment: { allow: [], deny: [all] }
+      filesystem:
+        allow:
+          - declared-write-scope
+        deny:
+          - outside-workspace
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - tests
+          - typecheck
+          - build
+        deny:
+          - destructive
+          - deploy
+      deployment:
+        allow: []
+        deny:
+          - all
     model:
-      required_capabilities: [tool-use, structured-output]
-      preferred: [policy-selected]
-    budget: { soft_cycles: 32, soft_input_tokens: 160000, max_repair_cycles: 2 }
+      required_capabilities:
+        - tool-use
+        - structured-output
+      preferred:
+        - gpt-5.6-terra
+      reasoning_effort: medium
+    budget:
+      soft_cycles: 32
     contract:
-      inputs: [task, requirements, context-pack]
-      outputs: [diff, verification, structured-outcome]
-      evidence: [acceptance-evidence]
-    review: { can_approve: false, cannot_review_roles: [task-executor, builder] }
-    escalation: [agent-orchestrator]
+      inputs:
+        - task
+        - requirements
+        - context-pack
+      outputs:
+        - diff
+        - verification
+        - structured-outcome
+      evidence:
+        - acceptance-evidence
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - task-executor
+        - builder
+    escalation:
+      - agent-orchestrator
   - id: agent-analyst
     version: 1
-    purpose: Analyze interaction turns without manufacturing executable Tasks.
+    purpose: Manage product definition and interaction analysis, creating or refining PRDs through attributed ZAIP lifecycle commands without manufacturing delivery Tasks before readiness.
+    use_when: ["Product problem, PRD, discovery, scope, or refinement."]
+    do_not_use: ["SPEC, implementation, technical approval, or deployment."]
     codex_name: zaip-agent-analyst
-    nickname_candidates: [zaip-agent-Analyst, zaip-agent-Insight, zaip-agent-Scout]
+    codex_task_name: bia_product_manager_zaip_agent
+    persona: { nome: bia, cargo: product_manager }
+    nickname_candidates:
+      - bia_product_manager_zaip_agent
     role: analyst
     priority: 20
     inherits: null
-    capabilities: [conversation-analysis, question-answering, repository-analysis]
-    execution_eligibility: [interaction]
-    tools: [shell-read]
-    skills: [zaip-skill-context]
-    write_scopes: []
+    capabilities:
+      - conversation-analysis
+      - question-answering
+      - repository-analysis
+      - prd-creation
+      - prd-refinement
+    execution_eligibility:
+      - interaction
+    tools:
+      - shell-read
+      - zaip-cli
+    skills:
+      - zaip-skill-context
+      - zaip-skill-prd
+    write_scopes:
+      - .agents/records/prds/*
+      - .agents/records/specs/*
+      - .agents/records/lifecycle/*
+      - .local/*
     permissions:
-      filesystem: { allow: [read-only], deny: [workspace-write] }
-      network: { allow: [], deny: [external] }
-      shell: { allow: [validation], deny: [mutation, deploy, destructive] }
-      deployment: { allow: [], deny: [all] }
+      filesystem:
+        allow:
+          - declared-write-scope
+        deny:
+          - outside-workspace
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - validation
+          - zaip-cli
+        deny:
+          - deploy
+          - destructive
+      deployment:
+        allow: []
+        deny:
+          - all
     model:
-      required_capabilities: [reasoning, structured-output]
-      preferred: [policy-selected]
-    budget: { soft_cycles: 16, soft_input_tokens: 80000, max_repair_cycles: 1 }
+      required_capabilities:
+        - reasoning
+        - structured-output
+      preferred:
+        - gpt-5.6-sol
+      reasoning_effort: medium
+    budget:
+      soft_cycles: 16
     contract:
-      inputs: [interaction, context-pack]
-      outputs: [analysis, answer]
-      evidence: [run-attribution]
-    review: { can_approve: false, cannot_review_roles: [analyst] }
-    escalation: [agent-orchestrator]
+      inputs:
+        - interaction
+        - context-pack
+      outputs:
+        - analysis
+        - answer
+        - prd-definition
+      evidence:
+        - run-attribution
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - analyst
+    escalation:
+      - agent-orchestrator
   - id: agent-finalizer
     version: 1
     purpose: Evaluate terminal Execution evidence as the mandatory final Sub-Run for interaction or delivery and return a restricted outcome.
+    use_when: ["Mandatorily as the final Sub-Run of interaction or delivery."]
+    do_not_use: ["Before executor or reviewer finishes, or to correct code."]
     codex_name: zaip-agent-finalizer
-    nickname_candidates: [zaip-agent-Finalizer, zaip-agent-Closer, zaip-agent-Settler]
+    codex_task_name: gui_quality_assurance_lead_zaip_agent
+    persona: { nome: gui, cargo: quality_assurance_lead }
+    nickname_candidates:
+      - gui_quality_assurance_lead_zaip_agent
     role: execution-finalizer
     priority: 30
     inherits: null
-    capabilities: [lifecycle-finalization, gate-evaluation, structured-output]
+    capabilities:
+      - lifecycle-finalization
+      - gate-evaluation
+      - structured-output
     execution_eligibility: []
-    tools: [zaip-cli, shell-read]
-    skills: [zaip-skill-execution]
+    tools:
+      - zaip-cli
+      - shell-read
+    skills:
+      - zaip-skill-execution
     write_scopes: []
     permissions:
-      filesystem: { allow: [read-only], deny: [workspace-write] }
-      network: { allow: [], deny: [external] }
-      shell: { allow: [validation, zaip-cli-read], deny: [mutation, deploy, destructive] }
-      deployment: { allow: [], deny: [all] }
+      filesystem:
+        allow:
+          - read-only
+        deny:
+          - workspace-write
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - validation
+          - zaip-cli-read
+        deny:
+          - mutation
+          - deploy
+          - destructive
+      deployment:
+        allow: []
+        deny:
+          - all
     model:
-      required_capabilities: [reasoning, structured-output]
-      preferred: [gpt-5.6-terra]
+      required_capabilities:
+        - reasoning
+        - structured-output
+      preferred:
+        - gpt-5.6-terra
       reasoning_effort: medium
-    budget: { soft_cycles: 8, soft_input_tokens: 40000, max_repair_cycles: 0 }
+    budget:
+      soft_cycles: 8
     contract:
-      inputs: [task, descendant-results, gates, evidence]
-      outputs: [terminal-outcome, status-reason, evidence-refs]
-      evidence: [finalization-decision]
-    review: { can_approve: false, cannot_review_roles: [execution-finalizer] }
-    escalation: [agent-auditor]
+      inputs:
+        - task
+        - descendant-results
+        - gates
+        - evidence
+      outputs:
+        - terminal-outcome
+        - status-reason
+        - evidence-refs
+      evidence:
+        - finalization-decision
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - execution-finalizer
+    escalation:
+      - agent-auditor
   - id: agent-reviewer
     version: 1
     purpose: Review changes independently and emit findings without mutating product files.
+    use_when: ["Implemented change requiring independent review."]
+    do_not_use: ["Implementing its own correction or integrating worktrees."]
     codex_name: zaip-agent-reviewer
-    nickname_candidates: [zaip-agent-Sentinel, zaip-agent-Lens, zaip-agent-Verifier]
+    codex_task_name: nanda_principal_engineer_zaip_agent
+    persona: { nome: nanda, cargo: principal_engineer }
+    nickname_candidates:
+      - nanda_principal_engineer_zaip_agent
     role: reviewer
     priority: 10
     inherits: null
-    capabilities: [independent-review, architecture-review, security-review]
+    capabilities:
+      - independent-review
+      - architecture-review
+      - security-review
     execution_eligibility: []
-    tools: [shell-read, test-runner]
-    skills: [zaip-skill-review]
+    tools:
+      - shell-read
+      - test-runner
+    skills:
+      - zaip-skill-review
     write_scopes: []
     permissions:
-      filesystem: { allow: [read-only], deny: [workspace-write] }
-      network: { allow: [], deny: [external] }
-      shell: { allow: [tests, validation], deny: [mutation, deploy] }
-      deployment: { allow: [], deny: [all] }
+      filesystem:
+        allow:
+          - read-only
+        deny:
+          - workspace-write
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - tests
+          - validation
+        deny:
+          - mutation
+          - deploy
+      deployment:
+        allow: []
+        deny:
+          - all
     model:
-      required_capabilities: [reasoning, tool-use]
-      preferred: [policy-selected]
-    budget: { soft_cycles: 24, soft_input_tokens: 120000, max_repair_cycles: 0 }
-    contract:
-      inputs: [task, diff, requirements, evidence]
-      outputs: [findings, approval-state]
-      evidence: [review-report]
-    review: { can_approve: true, cannot_review_roles: [reviewer] }
-    escalation: [agent-auditor]
+      required_capabilities:
+        - reasoning
+        - tool-use
+      preferred:
+        - gpt-5.6-terra
+      reasoning_effort: medium
+    budget:
+      soft_cycles: 12
+    contract:
+      inputs:
+        - task
+        - diff
+        - requirements
+        - evidence
+      outputs:
+        - findings
+        - approval-state
+      evidence:
+        - review-report
+    review:
+      can_approve: true
+      cannot_review_roles:
+        - reviewer
+    escalation:
+      - agent-auditor
   - id: agent-integrator
     version: 1
     purpose: Integrate reviewed worktrees and run combined gates.
+    use_when: ["Reviewed worktrees or independent reviewed changes need integration."]
+    do_not_use: ["Before review or to create requirements."]
     codex_name: zaip-agent-integrator
-    nickname_candidates: [zaip-agent-Bridge, zaip-agent-Weaver, zaip-agent-Integrator]
+    codex_task_name: dani_integration_engineer_zaip_agent
+    persona: { nome: dani, cargo: integration_engineer }
+    nickname_candidates:
+      - dani_integration_engineer_zaip_agent
     role: integrator
     priority: 10
     inherits: null
-    capabilities: [git-integration, full-verification]
+    capabilities:
+      - git-integration
+      - full-verification
     execution_eligibility: []
-    tools: [git, test-runner, zaip-cli]
-    skills: [zaip-skill-execution]
-    write_scopes: [integration-branch]
+    tools:
+      - git
+      - test-runner
+      - zaip-cli
+    skills:
+      - zaip-skill-execution
+    write_scopes:
+      - integration-branch
     permissions:
-      filesystem: { allow: [reviewed-worktree], deny: [unreviewed-worktree] }
-      network: { allow: [], deny: [external] }
-      shell: { allow: [git-integrate, tests, build], deny: [force-push, deploy] }
-      deployment: { allow: [], deny: [all] }
+      filesystem:
+        allow:
+          - reviewed-worktree
+        deny:
+          - unreviewed-worktree
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - git-integrate
+          - tests
+          - build
+        deny:
+          - force-push
+          - deploy
+      deployment:
+        allow: []
+        deny:
+          - all
     model:
-      required_capabilities: [tool-use, conflict-resolution]
-      preferred: [policy-selected]
-    budget: { soft_cycles: 20, soft_input_tokens: 100000, max_repair_cycles: 1 }
+      required_capabilities:
+        - tool-use
+        - conflict-resolution
+      preferred:
+        - gpt-5.6-terra
+      reasoning_effort: high
+    budget:
+      soft_cycles: 20
     contract:
-      inputs: [reviewed-diffs, dependency-state]
-      outputs: [integrated-diff, gate-results]
-      evidence: [integration-evidence]
-    review: { can_approve: false, cannot_review_roles: [integrator, builder] }
-    escalation: [agent-orchestrator]
+      inputs:
+        - reviewed-diffs
+        - dependency-state
+      outputs:
+        - integrated-diff
+        - gate-results
+      evidence:
+        - integration-evidence
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - integrator
+        - builder
+    escalation:
+      - agent-orchestrator
   - id: agent-auditor
     version: 1
     purpose: Reproduce evidence and issue the final independent audit.
+    use_when: ["High risk, release, or a claim requires final reproduction."]
+    do_not_use: ["Implementation, correction, or authorship of the evidence."]
     codex_name: zaip-agent-auditor
-    nickname_candidates: [zaip-agent-Beacon, zaip-agent-Ledger, zaip-agent-Witness]
+    codex_task_name: ana_quality_auditor_zaip_agent
+    persona: { nome: ana, cargo: quality_auditor }
+    nickname_candidates:
+      - ana_quality_auditor_zaip_agent
     role: auditor
     priority: 10
     inherits: null
-    capabilities: [independent-review, release-audit, score-reproduction]
+    capabilities:
+      - independent-review
+      - release-audit
+      - score-reproduction
+    execution_eligibility: []
+    tools:
+      - shell-read
+      - test-runner
+      - package-inspector
+    skills:
+      - zaip-skill-review
+    write_scopes: []
+    permissions:
+      filesystem:
+        allow:
+          - read-only
+        deny:
+          - workspace-write
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - tests
+          - validation
+          - package-inspection
+        deny:
+          - product-mutation
+          - deploy
+      deployment:
+        allow: []
+        deny:
+          - all
+    model:
+      required_capabilities:
+        - reasoning
+        - tool-use
+        - structured-output
+      preferred:
+        - gpt-5.6-sol
+      reasoning_effort: high
+    budget:
+      soft_cycles: 32
+    contract:
+      inputs:
+        - rubric
+        - evidence-manifest
+        - release-candidate
+      outputs:
+        - audit-report
+        - go-no-go
+      evidence:
+        - reproduced-score
+    review:
+      can_approve: true
+      cannot_review_roles:
+        - auditor
+    escalation:
+      - agent-orchestrator
+  - id: agent-text-summarizer
+    version: 1
+    purpose: Produce faithful summaries, timestamp-aware transcript analyses, and source-grounded documentation for a declared audience without unsupported claims.
+    use_when: ["Bounded summary, timestamped transcript, or documentation with declared sources."]
+    do_not_use: ["Research without sources, product decisions, or unsupported claims."]
+    codex_name: zaip-agent-writer
+    codex_task_name: lia_technical_writer_zaip_agent
+    persona: { nome: lia, cargo: technical_writer }
+    nickname_candidates:
+      - lia_technical_writer_zaip_agent
+    role: task-executor
+    priority: 40
+    inherits: null
+    capabilities:
+      - faithful-summarization
+      - timestamped-transcript-analysis
+      - source-grounded-documentation
+    execution_eligibility:
+      - interaction
+      - delivery
+    tools:
+      - apply-patch
+      - shell-read
+      - test-runner
+    skills:
+      - zaip-skill-context
+      - zaip-skill-change
+      - zaip-skill-text-encoding
+    write_scopes:
+      - declared-write-scope
+    permissions:
+      filesystem:
+        allow:
+          - declared-write-scope
+        deny:
+          - outside-workspace
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - tests
+          - validation
+        deny:
+          - mutation
+          - deploy
+          - destructive
+      deployment:
+        allow: []
+        deny:
+          - all
+    model:
+      required_capabilities:
+        - reasoning
+        - structured-output
+      preferred:
+        - gpt-5.6-terra
+      reasoning_effort: medium
+    budget:
+      soft_cycles: 12
+    contract:
+      inputs:
+        - task
+        - source-material
+        - audience
+        - output-constraints
+      outputs:
+        - faithful-summary
+        - timestamped-transcript-analysis
+        - source-grounded-documentation
+      evidence:
+        - source-grounding
+        - timestamped-findings
+        - acceptance-evidence
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - task-executor
+    escalation:
+      - agent-orchestrator
+  - id: agent-data-analyst
+    version: 1
+    purpose: Analyze bounded datasets, explain methods and uncertainty, and return reproducible evidence-backed findings.
+    use_when: ["Metrics, structured data, or quantitative diagnostics are available."]
+    do_not_use: ["No data is available, or to implement product or edit the dashboard."]
+    codex_name: zaip-agent-data-analyst
+    codex_task_name: gabi_data_analyst_zaip_agent
+    persona: { nome: gabi, cargo: data_analyst }
+    nickname_candidates:
+      - gabi_data_analyst_zaip_agent
+    role: task-executor
+    priority: 40
+    inherits: null
+    capabilities:
+      - data-analysis
+      - metric-diagnostics
+      - evidence-production
+    execution_eligibility:
+      - delivery
+    tools:
+      - shell-read
+      - test-runner
+    skills:
+      - zaip-skill-change
+      - zaip-skill-data-analyst
+    write_scopes:
+      - declared-write-scope
+    permissions:
+      filesystem:
+        allow:
+          - declared-write-scope
+        deny:
+          - outside-workspace
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - tests
+          - validation
+        deny:
+          - destructive
+          - deploy
+      deployment:
+        allow: []
+        deny:
+          - all
+    model:
+      required_capabilities:
+        - reasoning
+        - code
+        - structured-output
+      preferred:
+        - gpt-5.6-terra
+      reasoning_effort: medium
+    budget:
+      soft_cycles: 24
+    contract:
+      inputs:
+        - task
+        - dataset
+        - metric-definitions
+      outputs:
+        - analysis
+        - reproducible-results
+      evidence:
+        - acceptance-evidence
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - task-executor
+    escalation:
+      - agent-orchestrator
+  - id: agent-refactoring-specialist
+    version: 1
+    purpose: Plan and execute safe refactors, migrations, modularization, and architecture improvements from an inventory-backed map with reversible slices and explicit validation gates.
+    use_when: ["Refactor, migration, architecture, modularization, or source inventory."]
+    do_not_use: ["A point change without refactor, central design UI, or deployment."]
+    codex_name: zaip-agent-refactoring-specialist
+    codex_task_name: tati_refactoring_specialist_zaip_agent
+    persona: { nome: tati, cargo: refactoring_specialist }
+    nickname_candidates:
+      - tati_refactoring_specialist_zaip_agent
+    role: builder
+    priority: 15
+    inherits: null
+    capabilities:
+      - refactor-existing-code
+      - migration
+      - modularization
+      - architecture
+      - source-inventory
+      - refactor-map
+      - verification
+    execution_eligibility:
+      - delivery
+    tools:
+      - apply-patch
+      - shell-read
+      - test-runner
+    skills:
+      - zaip-skill-change
+      - zaip-skill-refactor-existing-code
+      - zaip-skill-enforce-architecture
+    write_scopes:
+      - declared-write-scope
+    permissions:
+      filesystem:
+        allow:
+          - declared-write-scope
+        deny:
+          - outside-workspace
+      network:
+        allow: []
+        deny:
+          - external
+      shell:
+        allow:
+          - tests
+          - typecheck
+          - build
+          - validation
+        deny:
+          - destructive
+          - deploy
+      deployment:
+        allow: []
+        deny:
+          - all
+    model:
+      required_capabilities:
+        - reasoning
+        - code
+        - tool-use
+        - structured-output
+      preferred:
+        - gpt-5.6-terra
+      reasoning_effort: medium
+    budget:
+      soft_cycles: 32
+    contract:
+      inputs:
+        - task
+        - source-root
+        - target-architecture
+        - baseline
+      outputs:
+        - refactor-map
+        - slice-report
+        - validation-results
+      evidence:
+        - inventory-source
+        - refactor-map-validation
+        - acceptance-evidence
+    review:
+      can_approve: false
+      cannot_review_roles:
+        - builder
+    escalation:
+      - agent-orchestrator
+  - id: agent-frontend
+    version: 1
+    purpose: Implement only apps/frontend frontend experiences, accessibility, and component integration using the central visual contract.
+    use_when: ["apps/frontend/** or explicit frontend capability."]
+    do_not_use: ["Dashboard/local, institutional website, backend, or central design rules."]
+    codex_name: zaip-agent-frontend
+    codex_task_name: doug_frontend_specialist_zaip_agent
+    persona: { nome: doug, cargo: frontend_specialist }
+    nickname_candidates: [doug_frontend_specialist_zaip_agent]
+    role: builder
+    priority: 15
+    inherits: null
+    capabilities: [frontend-delivery, accessibility, component-integration]
+    execution_eligibility: [delivery]
+    tools: [apply-patch, shell-read, test-runner]
+    skills: [zaip-skill-change]
+    write_scopes: [apps/frontend/*]
+    permissions:
+      filesystem: { allow: [declared-write-scope], deny: [outside-workspace] }
+      network: { allow: [], deny: [external] }
+      shell: { allow: [tests, typecheck, build], deny: [destructive, deploy] }
+      deployment: { allow: [], deny: [all] }
+    model:
+      required_capabilities: [code, tool-use]
+      preferred: [gpt-5.6-terra]
+      reasoning_effort: medium
+    budget: { soft_cycles: 32 }
+    contract:
+      inputs: [task, requirements, .agents/design/DESIGN.md]
+      outputs: [frontend-diff, visual-verification, structured-outcome]
+      evidence: [acceptance-evidence, visual-contract-check]
+    review: { can_approve: false, cannot_review_roles: [builder] }
+    escalation: [agent-orchestrator]
+  - id: agent-backend
+    version: 1
+    purpose: Implement and verify backend, API, persistence, and integration boundaries inside declared scopes.
+    use_when: ["apps/backend/**, modules/**, or backend capability."]
+    do_not_use: ["Frontend, website, or central visual design."]
+    codex_name: zaip-agent-backend
+    codex_task_name: will_backend_specialist_zaip_agent
+    persona: { nome: will, cargo: backend_specialist }
+    nickname_candidates: [will_backend_specialist_zaip_agent]
+    role: builder
+    priority: 15
+    inherits: null
+    capabilities: [backend-delivery, api-delivery, persistence-integration]
+    execution_eligibility: [delivery]
+    tools: [apply-patch, shell-read, test-runner]
+    skills: [zaip-skill-change]
+    write_scopes: [apps/backend/*, modules/*]
+    permissions:
+      filesystem: { allow: [declared-write-scope], deny: [outside-workspace] }
+      network: { allow: [], deny: [external] }
+      shell: { allow: [tests, typecheck, build], deny: [destructive, deploy] }
+      deployment: { allow: [], deny: [all] }
+    model:
+      required_capabilities: [code, tool-use]
+      preferred: [gpt-5.6-terra]
+      reasoning_effort: medium
+    budget: { soft_cycles: 32 }
+    contract:
+      inputs: [task, requirements, context-pack]
+      outputs: [diff, verification, structured-outcome]
+      evidence: [acceptance-evidence]
+    review: { can_approve: false, cannot_review_roles: [builder] }
+    escalation: [agent-orchestrator]
+  - id: agent-website-developer
+    version: 1
+    purpose: Build website experiences with design-system, SEO, GEO, Markdown for Agents, and Agent Readiness awareness.
+    use_when: ["apps/site/**, institutional site, landing page, SEO, GEO, or Markdown for Agents."]
+    do_not_use: ["Product app, backend, or central design-rule changes."]
+    codex_name: zaip-agent-website-developer
+    codex_task_name: jonny_website_developer_zaip_agent
+    persona: { nome: jonny, cargo: website_developer }
+    nickname_candidates: [jonny_website_developer_zaip_agent]
+    role: builder
+    priority: 10
+    inherits: null
+    capabilities: [website-delivery, design-system, seo, geo, markdown-for-agents, agent-readiness]
+    execution_eligibility: [delivery]
+    tools: [apply-patch, shell-read, test-runner]
+    skills: [zaip-skill-change, zaip-skill-website-readiness]
+    write_scopes: [apps/site/*]
+    permissions:
+      filesystem: { allow: [declared-write-scope], deny: [outside-workspace] }
+      network: { allow: [], deny: [external] }
+      shell: { allow: [tests, typecheck, build], deny: [destructive, deploy] }
+      deployment: { allow: [], deny: [all] }
+    model:
+      required_capabilities: [code, tool-use]
+      preferred: [gpt-5.6-terra]
+      reasoning_effort: medium
+    budget: { soft_cycles: 32 }
+    contract:
+      inputs: [task, requirements, website-context]
+      outputs: [diff, verification, structured-outcome]
+      evidence: [acceptance-evidence]
+    review: { can_approve: false, cannot_review_roles: [builder] }
+    escalation: [agent-orchestrator]
+  - id: agent-designer
+    version: 1
+    purpose: Own the central visual rule in DESIGN.md, design tokens, central components, and catalog pages inside declared scopes.
+    use_when: ["Central design rule, design system, tokens, design-system, or componentes."]
+    do_not_use: ["A product-local component that only consumes existing rules."]
+    codex_name: zaip-agent-designer
+    codex_task_name: manu_product_designer_zaip_agent
+    persona: { nome: manu, cargo: product_designer }
+    nickname_candidates: [manu_product_designer_zaip_agent]
+    role: builder
+    priority: 0
+    inherits: null
+    capabilities: [design-system, design-tokens, central-components, page-design]
+    execution_eligibility: [delivery]
+    tools: [apply-patch, shell-read, test-runner]
+    skills: [zaip-skill-change, zaip-skill-design-system, design-md]
+    write_scopes: [.agents/design/*, .agents/design/**]
+    permissions:
+      filesystem: { allow: [declared-write-scope], deny: [outside-workspace] }
+      network: { allow: [], deny: [external] }
+      shell: { allow: [tests, typecheck, build], deny: [destructive, deploy] }
+      deployment: { allow: [], deny: [all] }
+    model:
+      required_capabilities: [code, tool-use]
+      preferred: [gpt-5.6-terra]
+      reasoning_effort: medium
+    budget: { soft_cycles: 32 }
+    contract:
+      inputs: [task, requirements, design-context]
+      outputs: [diff, verification, structured-outcome]
+      evidence: [acceptance-evidence]
+    review: { can_approve: false, cannot_review_roles: [builder] }
+    escalation: [agent-orchestrator]
+  - id: agent-cloud-engineer
+    version: 1
+    purpose: Design and validate declared cloud infrastructure without deployment.
+    use_when: ["Cloud infrastructure, provisioning, containers, Terraform, or Docker environments."]
+    do_not_use: ["Application implementation, deployment, or unmanaged infrastructure changes."]
+    codex_name: zaip-agent-cloud-engineer
+    codex_task_name: dan_cloud_engineer_zaip_agent
+    persona: { nome: dan, cargo: cloud_engineer }
+    nickname_candidates: [dan_cloud_engineer_zaip_agent]
+    role: builder
+    priority: 10
+    inherits: null
+    capabilities: [cloud-infrastructure, terraform, docker, environment-provisioning]
+    execution_eligibility: [delivery]
+    tools: [apply-patch, shell-read, test-runner]
+    skills: [zaip-skill-change, zaip-skill-cloud-engineering]
+    write_scopes: [declared-write-scope]
+    permissions:
+      filesystem: { allow: [declared-write-scope], deny: [outside-workspace] }
+      network: { allow: [], deny: [external] }
+      shell: { allow: [tests, typecheck, build], deny: [destructive, deploy] }
+      deployment: { allow: [], deny: [all] }
+    model:
+      required_capabilities: [code, tool-use]
+      preferred: [gpt-5.6-terra]
+      reasoning_effort: medium
+    budget: { soft_cycles: 24 }
+    contract:
+      inputs: [task, requirements, infrastructure-context]
+      outputs: [diff, verification, structured-outcome]
+      evidence: [acceptance-evidence]
+    review: { can_approve: false, cannot_review_roles: [builder] }
+    escalation: [agent-orchestrator]
+  - id: agent-security-auditor
+    version: 1
+    purpose: Perform independent read-only technical security audits and prioritized recommendations.
+    use_when: ["Security audit, sensitive change, or release requires independent assessment."]
+    do_not_use: ["Implementation, remediation authorship, or deployment."]
+    codex_name: zaip-agent-security-auditor
+    codex_task_name: luiz_security_auditor_zaip_agent
+    persona: { nome: luiz, cargo: security_auditor }
+    nickname_candidates: [luiz_security_auditor_zaip_agent]
+    role: auditor
+    priority: 20
+    inherits: null
+    capabilities: [security-audit, security-review, risk-assessment]
     execution_eligibility: []
     tools: [shell-read, test-runner, package-inspector]
-    skills: [zaip-skill-review]
+    skills: [zaip-skill-review, zaip-skill-security]
     write_scopes: []
     permissions:
-      filesystem: { allow: [read-only], deny: [workspace-write] }
+      filesystem: { allow: [], deny: [workspace-write] }
       network: { allow: [], deny: [external] }
-      shell: { allow: [tests, validation, package-inspection], deny: [product-mutation, deploy] }
+      shell: { allow: [tests, validation], deny: [destructive, deploy] }
       deployment: { allow: [], deny: [all] }
     model:
-      required_capabilities: [reasoning, tool-use, structured-output]
-      preferred: [policy-selected]
-    budget: { soft_cycles: 32, soft_input_tokens: 180000, max_repair_cycles: 0 }
+      required_capabilities: [reasoning, tool-use]
+      preferred: [gpt-5.6-sol]
+      reasoning_effort: high
+    budget: { soft_cycles: 20 }
     contract:
-      inputs: [rubric, evidence-manifest, release-candidate]
-      outputs: [audit-report, go-no-go]
-      evidence: [reproduced-score]
+      inputs: [audit-scope, evidence-manifest, release-candidate]
+      outputs: [audit-report, prioritized-findings]
+      evidence: [reproduced-security-evidence]
     review: { can_approve: true, cannot_review_roles: [auditor] }
     escalation: [agent-orchestrator]
+  - id: agent-marketing-analyst
+    version: 1
+    purpose: Plan evidence-grounded marketing, copy, campaigns, and image briefs inside declared scopes.
+    use_when: ["Marketing strategy, campaign, landing-page copy, or image brief."]
+    do_not_use: ["Product implementation, backend changes, or central design governance."]
+    codex_name: zaip-agent-marketing-analyst
+    codex_task_name: lucia_marketing_analyst_zaip_agent
+    persona: { nome: lucia, cargo: marketing_analyst }
+    nickname_candidates: [lucia_marketing_analyst_zaip_agent]
+    role: builder
+    priority: 20
+    inherits: null
+    capabilities: [marketing-strategy, copywriting, campaign-planning, marketing-assets, image-briefing]
+    execution_eligibility: [delivery]
+    tools: [apply-patch, shell-read, imagegen]
+    skills: [zaip-skill-change, zaip-skill-marketing]
+    write_scopes: [declared-write-scope]
+    permissions:
+      filesystem: { allow: [declared-write-scope], deny: [outside-workspace] }
+      network: { allow: [], deny: [external] }
+      shell: { allow: [tests, validation], deny: [destructive, deploy] }
+      deployment: { allow: [], deny: [all] }
+    model:
+      required_capabilities: [code, tool-use]
+      preferred: [gpt-5.6-terra]
+      reasoning_effort: medium
+    budget: { soft_cycles: 20 }
+    contract:
+      inputs: [task, requirements, marketing-context]
+      outputs: [strategy, copy-assets, structured-outcome]
+      evidence: [acceptance-evidence]
+    review: { can_approve: false, cannot_review_roles: [builder] }
+    escalation: [agent-orchestrator]
 squads:
   - id: squad-critical-delivery
     version: 1
     purpose: Deliver critical work with independent review and controlled integration.
-    members: [agent-orchestrator, agent-analyst, agent-task-executor, agent-finalizer, agent-builder, agent-reviewer, agent-integrator, agent-auditor]
+    members:
+      - agent-orchestrator
+      - agent-analyst
+      - agent-task-executor
+      - agent-finalizer
+      - agent-builder
+      - agent-reviewer
+      - agent-integrator
+      - agent-auditor
+      - agent-frontend
+      - agent-backend
+      - agent-website-developer
+      - agent-designer
+      - agent-text-summarizer
+      - agent-refactoring-specialist
+      - agent-data-analyst
+      - agent-cloud-engineer
+      - agent-security-auditor
+      - agent-marketing-analyst
     max_parallelism: 5
     delegation:
-      - { from: agent-orchestrator, to: agent-builder, capability: typescript-delivery }
-      - { from: agent-orchestrator, to: agent-task-executor, capability: task-delivery }
-      - { from: agent-orchestrator, to: agent-analyst, capability: conversation-analysis }
-      - { from: agent-orchestrator, to: agent-finalizer, capability: lifecycle-finalization }
-      - { from: agent-builder, to: agent-reviewer, capability: independent-review }
-      - { from: agent-reviewer, to: agent-integrator, capability: git-integration }
-      - { from: agent-integrator, to: agent-auditor, capability: release-audit }
+      - from: agent-orchestrator
+        to: agent-builder
+        capability: project-stack-delivery
+      - from: agent-orchestrator
+        to: agent-builder
+        capability: spec-creation
+      - from: agent-orchestrator
+        to: agent-task-executor
+        capability: task-delivery
+      - from: agent-orchestrator
+        to: agent-analyst
+        capability: conversation-analysis
+      - from: agent-orchestrator
+        to: agent-analyst
+        capability: prd-creation
+      - from: agent-orchestrator
+        to: agent-finalizer
+        capability: lifecycle-finalization
+      - from: agent-orchestrator
+        to: agent-frontend
+        capability: frontend-delivery
+      - from: agent-orchestrator
+        to: agent-backend
+        capability: backend-delivery
+      - from: agent-orchestrator
+        to: agent-website-developer
+        capability: website-delivery
+      - from: agent-orchestrator
+        to: agent-designer
+        capability: design-system
+      - from: agent-orchestrator
+        to: agent-data-analyst
+        capability: data-analysis
+      - from: agent-orchestrator
+        to: agent-cloud-engineer
+        capability: cloud-infrastructure
+      - from: agent-orchestrator
+        to: agent-security-auditor
+        capability: security-audit
+      - from: agent-orchestrator
+        to: agent-marketing-analyst
+        capability: marketing-strategy
+      - from: agent-orchestrator
+        to: agent-refactoring-specialist
+        capability: refactor-existing-code
+      - from: agent-orchestrator
+        to: agent-refactoring-specialist
+        capability: architecture
+      - from: agent-orchestrator
+        to: agent-reviewer
+        capability: independent-review
+      - from: agent-orchestrator
+        to: agent-integrator
+        capability: git-integration
+      - from: agent-orchestrator
+        to: agent-auditor
+        capability: release-audit
+      - from: agent-orchestrator
+        to: agent-text-summarizer
+        capability: faithful-summarization
+      - from: agent-orchestrator
+        to: agent-text-summarizer
+        capability: timestamped-transcript-analysis
+      - from: agent-orchestrator
+        to: agent-text-summarizer
+        capability: source-grounded-documentation
+      - from: agent-builder
+        to: agent-reviewer
+        capability: independent-review
+      - from: agent-reviewer
+        to: agent-integrator
+        capability: git-integration
+      - from: agent-integrator
+        to: agent-auditor
+        capability: release-audit
     review_policy:
       independent: true
-      executor_roles: [analyst, builder, task-executor]
-      reviewer_roles: [reviewer, auditor]
-    escalation: [agent-auditor, agent-orchestrator]
+      executor_roles:
+        - analyst
+        - builder
+        - task-executor
+      reviewer_roles:
+        - reviewer
+        - auditor
+    escalation:
+      - agent-auditor
+      - agent-orchestrator