mikeparcewski/wicked-garden / skills/archetype
wicked-garden-archetype
Verifiedv11 work-shape archetype runner. When a prompt has been routed to one of the archetypes (triage, explore, specify, decide, ship, review, incident, build, migrate, modernize), this skill is the entry point. It picks the right per-archetype playbook from refs/ and executes the phase shape declared in `.claude-plugin/archetypes.json`. Use when: a `<wg archetype="X">` or `<wg archetypes>` system-reminder tag appears, an explicit "let's run the X archetype" request, or a direct per-archetype ask — "triage this prompt", "review this PR / artifact", "build this feature", "decide between these options", "explore this problem", "handle this incident", "run this migration", "modernize / port this legacy app", "ship this release", "write acceptance criteria" (invoke with archetype=<name> plus the user's args — see the Direct invocation table).
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 8.0 KB |
| refs/build.md | markdown | 7.5 KB |
| refs/decide.md | markdown | 6.1 KB |
| refs/explore.md | markdown | 2.3 KB |
| refs/incident.md | markdown | 8.2 KB |
| refs/migrate.md | markdown | 9.7 KB |
| refs/modernize.md | markdown | 11.6 KB |
| refs/review.md | markdown | 9.7 KB |
| refs/ship.md | markdown | 6.1 KB |
| refs/specify.md | markdown | 5.8 KB |
| refs/triage.md | markdown | 2.7 KB |
refs/review.md
View on GitHub# review — independent assessment with hard verdict
When an artifact (code, design, spec, incident response) needs an
external quality check. Produces a verdict: APPROVE / CONDITIONAL /
REJECT, with a remediation list when not APPROVE.
## Phase shape
| Phase | Goal |
|------------------------|--------------------------------------------|
| scope | Name what's being reviewed and what isn't. |
| assess | Apply the relevant rubric / quality bar. |
| findings | List what's wrong, what's missing, what's good (in that order). |
| remediate-or-accept | Pick: fix the findings, accept them with a CONDITIONAL, or reject. |
## Produces
- **Verdict**: `APPROVE` / `CONDITIONAL` / `REJECT`.
- **Remediation list**: each item has an id, severity, and a concrete
action. Empty when APPROVE.
The final-verdict gate **re-derives** these through the garden's in-process gate engine (`scripts/qe/vault_gate.py` → `scripts/loom/`, which shells `wicked-vault cross-check`): the verdict JSON is re-validated and the
remediation-list structure re-checked, never trusting a self-asserted
"done". The gate engine ships inside wicked-garden; wicked-vault (the evidence backend) is the one **required** peer (installed by the `wicked-garden-core` skill's `setup` action); if the engine cannot resolve — or the vault behind it is absent — the gate **fails closed** (`gate: "unavailable"`, `satisfied: false`) rather than passing
on a claim alone. Because final-verdict is a **hard** gate, the contract
also demands an **independent attestation** — the verdict must be signed
off by an evaluator that is NOT the worker who did the reviewed work
(anti-self-grade, G10). `--no-require` opts a throwaway/low-rigor run
back to the doctrine-light claim-only path.
## HITL
`hard:final-verdict` — the verdict is a hard gate. Auto-approve is
banned (banned-reviewer enforcement applies — `auto-approve-*`,
`fast-pass`, `just-finish-auto` are rejected at the gate).
## How to run
### scope
Confirm this is the right review first: this archetype is the only
review that produces a **binding verdict**. For a code-quality pass use
`engineering:review`; for an AI agent system use `agentic:review`; for
a UI use `product:ux-review` (see `docs/domains.md` → "review appears
in three domains").
1. Name what's in scope: this PR, this commit, this design doc.
2. Name what's out of scope: don't drift into adjacent code that wasn't
changed.
3. Pick the rubric: code review uses R1–R6; design review uses
testability + boundary clarity; spec review uses SMART+T.
4. If a vault is resolvable (`wicked-garden run scripts/qe/vault_gate.py resolve` →
`available: true`), declare the re-derivable contract for this phase
so the final-verdict gate has a bar to check against:
`wicked-vault init` (once per repo) then
`wicked-vault declare-contract --scope <scope> --phase review --spec contract.json`.
`required_evidence` should pin `verdict` to `exit_code_eq:0` on a
verdict-schema validation (`scripts/qe/verdict_schema.py`) and
`remediation-list` to a presence/structure `regex_match`. Because
this is a **hard** gate, the contract also requires a passing
independent `opinion_attestation` (the judgment tier). Skip silently
if no vault.
### assess
1. Apply the rubric. Take notes; don't write the findings yet.
2. Use the right specialist — `pr-review-toolkit:code-reviewer` (an external
subagent, where your harness has it), a garden worker skill
(`wicked-garden-qe-semantic-reviewer`, `wicked-garden-engineering-solution-architect`,
etc.), or the Evaluator section of the `wicked-garden-governed-worker` floor. Match
the artifact to the specialist.
**Hand-off** — open the chosen worker skill by name and carry out its SKILL.md with
the artifact as the argument; on Claude Code this is the Skill tool, on any other seat
open the named skill from your catalog and run it inline, keeping its output separate
from yours, then continue here.
3. **Parity items compare values (garden#1253).** For every item that says the
work matches an existing surface ("the same as the form", "like the Desk
row"), derive the value that surface produces — from its own code path or
the run's recorded output — and quote it beside the new code's value, both
with `file:line`. Presence of the field, or a test the author wrote pinning
a value, is not evidence; a difference is a blocker (the governed-worker
floor's rule E4).
4. **Duplicates of a built-in are findings (POL-2101).** Flag every piece of
custom code that re-implements what the chosen framework or library already
provides, even when the author gave a reason. Cite the code and the built-in,
both with `file:line` or the stack's doc at the pinned version, and judge the
reason against what the change actually needs. An unjustified duplicate is at
least `minor`. Code that swaps out the framework the user or a policy chose is a
`blocker` (the governed-worker floor's rule E5).
5. For high-stakes reviews, run a council via the
`wicked-garden-jam-council` skill — independent multi-model verdicts
catch what a single reviewer misses.
### findings
1. Write the findings list. Each finding:
- `id`: F-1, F-2, ...
- `severity`: blocker / major / minor / nit
- `claim`: what's wrong, in one sentence.
- `fix`: a concrete action.
2. Order: blockers first, then major, then minor. Nits last (or
collapsed into a "nit-pile" comment).
### remediate-or-accept
1. Decide the verdict:
- **APPROVE**: no blockers, no majors, the code is shippable as-is.
- **CONDITIONAL**: blockers/majors that have a clear fix path. Each
condition gets a row in the conditions manifest so the next
archetype (build / migrate / etc.) can pin it to the resolution
artifact.
- **REJECT**: fundamental issues. Don't bandaid; send back to the
author.
2. Write the verdict JSON. Validate with `scripts/qe/verdict_schema.py`
— confirms shape (verdict enum, reviewer not banned, score in
range, invariants per verdict type).
3. Sanitize free-text fields with `scripts/qe/content_sanitizer.py`
to strip prompt-injection patterns from reasons / findings /
condition descriptions before persisting.
4. Append to the audit log with `wicked-garden run scripts/qe/verdict_audit.py append`
so the verdict is replayable.
Then record both produces as re-derivable evidence (vault present;
**wicked-vault ≥ 0.8.0** <!-- vault-floor -->):
`wicked-vault record --scope <scope> --phase review --claim verdict
--kind verdict --source "<verdict.json>" --criteria "<the bar>"
--verifier exit_code_eq:0 --actor "${WICKED_VAULT_ACTOR:-garden-prove}"
--run` where the run is `wicked-garden run scripts/qe/verdict_schema.py <verdict.json>`,
and a second `record` for `--claim remediation-list ... --verifier
regex_match:<pattern> --actor "${WICKED_VAULT_ACTOR:-garden-prove}"`.
The **`--actor`** is mandatory for a hard gate: the vault refuses an
`attest` over evidence recorded under a weak/ambient identity
(`created_by_source='env-user'`; fail-closed since 0.4.0), so without an
explicit actor the independent sign-off below fails closed and the gate
can never reach PASS. The `--run` captures the validator's real exit code now and the
gate re-runs it later — a claim you can't re-derive is not evidence. No
vault → fall back to `evidence_tracker.py claim`.
Then have an **independent** evaluator sign off via the
`wicked-vault:analyze-evidence` skill, which records an
`opinion_attestation` over the frozen criteria. The evaluator must
NOT be the agent that did the reviewed work — the gate fails closed
on a self-grade. This is the "never let work self-grade its own done"
guarantee.
5. On CONDITIONAL: initialise the conditions manifest with
`wicked-garden run scripts/qe/conditions_manifest.py init --from-verdict <path>`.
The downstream archetype calls `mark` as it satisfies each one.
6. Don't soften — REJECT means REJECT.
## When to stop
Review is done when the produces-gate is satisfied. Check the gate —
don't self-assert it:
`wicked-garden run scripts/qe/prove.py <claim> --by "<command>" --scope <scope> --phase review --with-attestations` (frictionless, single claim — re-derive, don't assert) — or the full multi-claim contract via `wicked-garden run scripts/qe/vault_gate.py gate <project_dir> --scope <scope> --phase review --with-attestations` **`--with-attestations`** keeps this gate `UNATTESTED`/`REJECT` until an INDEPENDENT evaluator (not the doer) runs `wicked-vault attest <artifact-id> --opinion pass` — find it via `wicked-vault list --scope <scope> --phase review`. The doer's own evidence cannot satisfy a hard gate.
(exit 0 = satisfied). This is a re-derived PASS over the declared
contract. `--with-attestations` makes the gate require a passing
independent `opinion_attestation` recorded via the
`wicked-vault:analyze-evidence` skill, where the evaluator ≠ the agent
that did the reviewed work — it fails closed on a self-grade. A REJECT
means the recorded evidence does not clear its contract — fix the work,
not the claim. An `unavailable` verdict means the required vault isn't
installed — run the `wicked-garden-core` skill's `setup` action. Then hand off to `build` (when
fixes are needed before ship) or `ship` (when APPROVE).
## Anti-patterns
- **Don't sandbag with nits.** If the only findings are nits, APPROVE.
Don't gate on cosmetic preferences.
- **Don't write a fix during review.** The reviewer's job is the
verdict; the fix is the author's.
- **Don't auto-approve for speed.** Banned-reviewer enforcement exists
for a reason. Time pressure is not a CONDITIONAL.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |