evo

Plugin evo from marketplace evo in mickeyyaya/evolve-loop. Commands read from the repo's manifest — today.

Skills (33)

• adversarial-testing
• architecture-review
• audit
• code-review-simplify
• commit
• diff-review
• docs-review
• docs-write
• engineering-craft
• evaluator
• explain
• fable
• golang-test-review
• inspirer
• intent
• loop
• minimalism
• phase-create
• plan-review
• publish
• quality-index
• refactor
• release
• retro
• scout
• security-review-scored
• setup
• ship
• solution-audit
• solution-build
• solution-scout
• tdd
• verify-release

Slash commands (34)

• /evo:adversarial-testing
• /evo:architecture-review
• /evo:audit
• /evo:build
• /evo:code-review-simplify
• /evo:commit
• /evo:diff-review
• /evo:docs-review
• /evo:docs-write
• /evo:engineering-craft
• /evo:evaluator
• /evo:explain
• /evo:fable
• /evo:golang-test-review
• /evo:inspirer
• /evo:intent
• /evo:loop
• /evo:minimalism
• /evo:phase-create
• /evo:plan-review
• /evo:publish
• /evo:quality-index
• /evo:refactor
• /evo:release
• /evo:retro
• /evo:scout
• /evo:security-review-scored
• /evo:setup
• /evo:ship
• /evo:solution-audit
• /evo:solution-build
• /evo:solution-scout
• /evo:tdd
• /evo:verify-release

Subagents (113)

• AGENTS
• agent-templates

  Base schemas and context blocks for all agents.

• evolve-accessibility-audit

  Accessibility audit agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after build whenever scout.goal_type == "accessibility" to adversarially review changed UI/HTML/React against WCAG 2.1/2.2 AA.

• evolve-account-reconcile

  Account reconciliation agent for the Evolve Loop (Evaluate archetype). Reviews general ledger balances against source subsystem data, identifies reconciling items, and recommends adjustments.

• evolve-adversarial-review

  Adversarial-review agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after build when the change touches source, to red-team the diff for exploitable weaknesses. Reasons like an attacker over the just-built change — input handling, auth/authz boundaries, injection, resou

• evolve-api-contract-design

  Contract-first interface designer (Plan archetype) — authors the API surface contract before Builder touches implementation for feature cycles.

• evolve-architecture-design

  Architecture-design agent for the Evolve Loop (Plan archetype). The advisor SELECTS this phase for large or novel cycles that need an explicit design pass before TDD/build. Reads scout's task + the codebase, produces a trade-off-driven architecture-design.md (current state → options → decision → blu

• evolve-auditor-reference
• evolve-auditor

  Single-pass review agent for the Evolve Loop. Covers code quality, security, pipeline integrity, and eval gating. READ-ONLY — flags MEDIUM+ issues.

• evolve-authz-gap-scan

  Authorization-gap adversary for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after build on security cycles (scout.goal_type == security) to hunt for missing or incorrect access-control checks on changed code that touches protected resources.

• evolve-behavior-baseline

  Behavior baseline agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase on refactor cycles before build (after TDD) to record a golden master of observable behavior and test outputs.

• evolve-behavior-compare

  Behavior comparison agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase on refactor cycles after build to compare post-build outputs against the baseline golden master and fail on unexplained drift.

• evolve-benchmark-gate

  Statistical benchmark comparison gate (Evaluate archetype).

• evolve-bug-reproduction

  Bug reproduction agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase on bugfix cycles before build (after fault localization) to write a test or script that fails on the current buggy code.

• evolve-build-planner

  Build-planning agent for the Evolve Loop. Moves Builder's design step into an independent phase (Opt C). Reads TDD test contract and scout report; produces a structured build-plan.md before Builder executes code. Default-off (enable via workflow.phase_enables.build-planner=on in policy.json).

• evolve-builder-reference
• evolve-builder

  Implementation agent for the Evolve Loop. Designs, builds, and self-verifies changes in an isolated worktree with TDD and minimal-change principles.

• evolve-cache-strategy-scan

  Cache-coherence audit agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build on cycles whose scout.goal_type == "caching" to verify the implemented cache honors its strategy — and BLOCKS when the cache can serve stale data or stampede (missing/incorrect invalidati

• evolve-caching-strategy-design

  Caching-strategy designer for the Evolve Loop (Plan archetype). The advisor INSERTS this phase after Triage on caching cycles (scout.goal_type == "caching"), BEFORE any build, to commit the cache pattern, key schema, and invalidation/TTL design up front. Delivers caching-strategy-design-report.md —

• evolve-capacity-plan

  Capacity planning agent for the Evolve Loop (Plan archetype). Forecasts demand, assesses current capacity, and identifies capacity gaps requiring remediation.

• evolve-changelog-sync

  Changelog drift controller (Control archetype) — verifies CHANGELOG/release-notes match shipped commits after every cycle ship.

• evolve-cicd-pipeline-audit

  CI/CD pipeline security gate for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build on infrastructure cycles (scout.goal_type == "infrastructure") to audit every changed workflow/pipeline definition for supply-chain and secret-exfiltration posture before it can ship — a

• evolve-cleanup-sweep

  Dead-code and unused dependency detection (Evaluate archetype).

• evolve-close-checklist

  Close checklist agent for the Evolve Loop (Control archetype). Manages financial close tasks, tracks blocking items, and collects sign-offs.

• evolve-code-reviewer

  Independent code-review agent for the Evolve Loop (Evaluate archetype). The kernel pins this phase after Build on every code cycle whose build touched files. Plans a justified review of the build's diff on the shared quality index, reports findings with a concrete suggested fix each (recorded in the

• evolve-compat-surface-check

  Backward-compatibility audit agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build whenever scout.goal_type == "api-design", to diff the realized exported surface against the prior release and BLOCK unversioned breaking changes.

• evolve-console-builder

  The console build seat. Builds one console-owned item in the dev worktree that the console gives, changes only the files that the console names, and reports the changes and the test results. The console reviews, gates and commits the change.

• evolve-container-hardening-scan

  Container & manifest hardening gate for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build on infrastructure cycles to inspect the changed Dockerfiles and Kubernetes manifests for insecure defaults — and BLOCKS when an added line ships a CRITICAL misconfiguration (root

• evolve-context-condense

  Run-dir artifact condenser (Control archetype) — summarizes and prunes long per-cycle artifacts when cumulative size exceeds threshold to keep downstream phases within context budget.

• evolve-contract-fuzz-probe

  Trust-boundary validation auditor for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after build on cycles where scout.goal_type == "api-design" to prove that changed input-handling code rejects malformed untrusted input instead of merely not crashing.

• evolve-coverage-gate

  Coverage-regression gate for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build whenever the cycle's build.diff_loc is at least 50 changed lines, to verify the changed lines are covered by tests and BLOCK on coverage regressions.

• evolve-data-integrity-check

  Data-pipeline integrity auditor for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build whenever the cycle's scout.goal_type == "data-pipeline", to statically audit the changed batch/stream code for records it could silently corrupt, drop, duplicate, or reorder — and BLO

• evolve-data-model-design

  Data-model designer for the Evolve Loop (Plan archetype). The advisor INSERTS this phase after Triage on database cycles (scout.goal_type == "database"), BEFORE any build, to fix entities, keys, indexes, and query access paths against the cycle's data-heavy goal. DELIVERS a data-model-design-report.

• evolve-debugger

  Ship-failure recovery diagnostician. Diagnoses root cause of a structured ShipError and emits debug-decision.json declaring RESHIP, RERUN_PHASE, or BLOCK.

• evolve-deliverable-recovery

  The recovery agent of the logic-first ladder (ADR-0106). Dispatched when a phase's deliverable failed the contract gate on FORM only — a missing file, a missing section, a malformed JSON secondary — after the phase itself did its work. Reads the phase's logic evidence (its output, its partial artifa

• evolve-dependency-audit

  Dependency auditor for the Evolve Loop (Evaluate archetype). Reviews go.mod/go.sum changes for vulnerable, outdated, or incompatible dependencies. Emits dependency.severity_max; fails the cycle on >=CRITICAL.

• evolve-dependency-map

  Dependency mapping and critical path analysis agent for the Evolve Loop (Evaluate archetype). Analyzes project dependencies, identifies the critical path, and highlights blocking items.

• evolve-diagnose-reference

  Layer-3 on-demand reference for diagnosing runtime failures in Evolve Loop. 6-phase debug loop with [DEBUG-XXXX] tag pattern; grounded in evolve-loop failure modes.

• evolve-diff-architecture-reviewer

  Structural/architectural review of code changes — SOLID, dependency direction, design-pattern fit, SSOT/duplication, coupling — and whether the change was built test-first to the project's Clean Code and Design Patterns standard. Use PROACTIVELY after any structural change, new module, or API modifi

• evolve-diff-code-reviewer

  Expert code reviewer for correctness, security, and maintainability of a change. Diff-scoped by design — reviews the changed hunks with bounded context, never reads whole packages or re-runs suites. Use immediately after writing or modifying code.

• evolve-diff-code-simplifier

  Simplifies recently modified code for clarity and consistency while preserving behavior exactly. Diff-scoped by design — works only inside the changed hunks, never reads packages or runs suites. Use after a change, before the reviewers.

• evolve-diff-docs-review

  Reviews a change of only documents (each changed path ends in .md). It runs the deterministic checks first, then the four lenses of the docs-review skill, and reports the findings with evidence. It is the docs review capability of the commit gate.

• evolve-diff-go-reviewer

  Expert Go code reviewer for idiomatic Go, error handling, concurrency, and test quality. Diff-scoped by design — reviews the changed hunks, never re-runs the repo's suites or linters. Use for all Go code changes.

• evolve-doc-sync

  Documentation synchronization agent for the Evolve Loop. Automatically updates project documentation, changelogs, and readmes based on codebase modifications.

• evolve-error-handling-scan

  Silent-failure adversary for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build on bugfix cycles — and on any large diff regardless of goal type — to hunt swallowed errors, ignored return values, and catch-all fallbacks in the changed code. BLOCKS when a failure path is

• evolve-failure-adjudicator

  Reviews an audit rejection from an ARCHITECTURE level and chooses, among the paths deterministic policy has already made legal, which one this cycle should take. Read-only except its own decision artifact.

• evolve-failure-advisor

  The LLM escalation tail of the Phase Recovery Pipeline (ADR-0044). Dispatched ONLY for a terminal state the deterministic FatalPaneDetector could not classify (CauseUnknown) — reads the incident + recent pane tail, classifies it into the typed cause vocabulary (model_invalid | cli_self_updated | dea

• evolve-fault-localization

  Fault localization agent for the Evolve Loop (Plan archetype). The advisor INSERTS this phase on bugfix cycles before build to identify the files and lines that contain the bug.

• evolve-flake-rerun-scan

  Non-determinism gate for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build whenever the cycle touched at least one file (build.files_touched > 0) to re-run the affected tests under -count=N and -shuffle and prove their verdicts are stable.

• evolve-forces-analysis

  Forces analysis and industry attractiveness evaluation agent for the Evolve Loop (Evaluate archetype). Evaluates competitive rivalry, buyer/supplier power, entry/substitute threats, and delivers an attractiveness verdict.

• evolve-frontend-design-review

  Adversarial frontend design review agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build whenever scout.goal_type == "frontend-ui", to judge changed UI for production-grade design quality and BLOCK on design-system violations or broken responsive states.

• evolve-fuzz-probe

  Fuzz testing runner and evaluator (Evaluate archetype).

• evolve-idempotency-check

  Delivery-semantics auditor for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build on messaging cycles (scout.goal_type == "messaging") to prove that every changed message/event handler is safe to process the SAME message twice under at-least-once delivery — and BLOCKS w

• incident-postmortem

  Structured 4-section debrief to prevent incident recurrence when root causes go unrecorded.

• evolve-intent

  Pre-Scout intent capture agent. Takes a vague user goal, classifies it via the Ask-when-Needed framework, and emits a structured intent.md with goal/non-goals/constraints/interfaces/acceptance/assumptions/challenged-premises/risk-level. Mandatory ≥1 challenged premise.

• evolve-license-provenance-audit

  License & provenance audit agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build whenever the cycle's scout.goal_type == "supply-chain", to vet every newly added or version-bumped dependency for license compatibility and provenance integrity before it reaches the

• evolve-locale-format-check

  Internationalization audit agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build whenever the cycle's scout.goal_type == "i18n" to verify changed UI/string code externalizes copy and formats data locale-aware before launch.

• evolve-market-sizing

  Market sizing and feasibility analysis agent for the Evolve Loop (Evaluate archetype). Estimates TAM, SAM, and SOM, outlining methodology and assumptions.

• evolve-memo-reference

  Layer-3 on-demand reference for the Layer-P memo phase. Defines the section template and downstream-consumer contract for the memo subagent output.

• evolve-memo

  Lightweight PASS-cycle memo agent (v8.57.0+, Layer P). Fires on PASS verdicts after ship to capture observations Scout/Triage saw but did NOT commit to top_n. Single-pass, ~$0.10–0.20 per cycle. Emits carryover-todos.json and memo.md — does NOT do retrospective/digest work (that's the FAIL/WARN retr

• evolve-merge-to-main-gate

  Merge-to-main promotion-readiness gate for the Evolve Loop (Evaluate archetype). The campaign executor invokes this at milestone/wave boundaries to verify a completed milestone's already-integrated work is ready to be promoted to main, emitting a PASS/WARN/FAIL verdict plus merge_gate.* signals. REA

• evolve-metric-tree

  Metric tree evaluation agent for the Evolve Loop (Evaluate archetype). Defines the North Star Metric, identifies input metrics, and establishes guardrail metrics using the Amplitude North Star Framework.

• evolve-migration-safety-check

  Migration safety auditor for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build whenever the cycle's scout.goal_type == "data-migration", to statically audit the changed migration scripts for irreversible, non-idempotent, or production-locking operations.

• evolve-mutation-gate

  Mutation testing evaluator (Evaluate archetype).

• evolve-observability-design

  Observability-design agent for the Evolve Loop (Plan archetype). The advisor INSERTS this phase after Triage on observability cycles (scout.goal_type == "observability"), BEFORE any build — it declares the metrics/logs/traces, SLOs, and alerts a new path must emit so instrumentation is designed, not

• evolve-okr-draft

  Objectives and Key Results draft agent for the Evolve Loop (Plan archetype). Formulates strategic objectives, defines measurable key results, and sets confidence scores.

• evolve-operator

  Post-cycle monitoring agent for the Evolve Loop. Assesses progress, detects stalls, tracks quality trends, and recommends adjustments.

• evolve-opportunity-map

  Opportunity mapping agent for the Evolve Loop (Plan archetype). Maps desired outcomes, surfaces opportunities, proposes candidate solutions, and identifies assumption tests using the Torres Opportunity Solution Tree framework.

• evolve-orchestrator-reference
• evolve-orchestrator

  Cycle orchestrator subagent. Proposes the phase sequence (Scout → Builder → Auditor → Ship/Retrospective) and the next step after each verdict; the Go kernel decides, clamps every proposal, and the persona cannot edit source code or commit/push directly. Subordinate to ship-gate, role-gate, and phas

• evolve-perf-profile

  Performance-profiling agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after a substantial build (large diff / hot-path touch) to check the change for performance regressions. Reasons about algorithmic complexity, allocation, and I/O on the touched paths, runs available

• evolve-post-ship-monitor

  Post-ship behavioral health prober (Control archetype) — runs evolve doctor and dry-run probes one cycle after ship to catch integration failures early.

• evolve-prd-draft

  Product Requirements Document draft agent for the Evolve Loop (Plan archetype). Defines the problem, sets goals and success metrics, specifies requirements, and delineates scope using the SVPG/Lenny PRD convergence framework.

• evolve-preliminary-study

  Researches a campaign goal and decomposes it into a dependency-aware, multi-cycle execution plan.

• evolve-premise-challenge

  Premise-falsification adversary for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Triage on large cycles (scout.cycle_size == "large") to attack the cycle's stated goal and assumptions BEFORE any build — and BLOCKS when the success criteria are unfalsifiable or a strictl

• evolve-prompt-regression-eval

  Agent-instruction regression auditor for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build when the cycle goal_type is "agent-instruction" — i.e. the cycle edited persona/profile/skill/prompt files — to score those instruction edits against a behavioral rubric and BLOC

• evolve-query-performance-scan

  Query-shape adversary for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build on database cycles (scout.goal_type == "database") to statically hunt N+1 access, missing-index lookups, full-table scans, and unbounded result sets in the changed queries, ORM calls, and data-

• evolve-race-condition-scan

  Adversarial concurrency-audit agent for the Evolve Loop (Evaluate archetype). The advisor INSERTS this phase after Build on cycles whose scout.goal_type == "concurrency" to hunt data races, deadlocks, and goroutine leaks in the changed code.

• evolve-reflector-reference
• evolve-reflector

  Every-cycle Learn-phase synthesizer (v10.20.0+, Layer R). Reads each phase's <phase>-reflection.yaml sidecar for the current cycle, calls aggregate-reflections.sh for a 5-cycle rollup, and emits learn/reflector-synthesis.md. Runs regardless of audit verdict. Does NOT extract lessons (retrospective o

• evolve-resilience-design
• evolve-resilience-gap-scan
• evolve-retrospective-reference
• evolve-retrospective
• evolve-risk-register
• evolve-rollback-plan
• evolve-rollout-plan
• evolve-router
• evolve-runbook-draft
• evolve-scope-baseline
• evolve-scout-reference
• evolve-scout-scan
• evolve-scout
• evolve-secret-leak-scan
• evolve-security-scan
• evolve-selfheal-orchestrator
• evolve-smell-scan
• evolve-spec-verifier
• evolve-spec-verify
• evolve-stop-criterion-reference
• evolve-swarm-planner
• evolve-tdd-engineer-reference
• evolve-tdd-engineer
• evolve-telemetry-coverage-check
• evolve-test-amplification
• evolve-tester
• evolve-threat-model
• evolve-triage-reference
• evolve-triage
• evolve-type-safety-audit
• evolve-variance-analysis
• plan-reviewer
• reflection-authoring-step

Similar plugins