wicked-garden 12.27.0

package/CONTRIBUTING.md

@@ -0,0 +1,99 @@
+# Contributing to wicked-garden
+
+## Development Setup
+
+Clone the repo and install with `uv`:
+
+```bash
+git clone https://github.com/mikeparcewski/wicked-garden.git
+cd wicked-garden
+uv sync
+```
+
+Run the test suite:
+
+```bash
+uv run pytest tests/ -x
+```
+
+## Escape Hatches
+
+### WG_SKIP_WICKED_TESTING_CHECK
+
+**For offline CI and dev environments without npm access only.**
+
+When set to `1`, the SessionStart wicked-testing probe is bypassed:
+
+```bash
+export WG_SKIP_WICKED_TESTING_CHECK=1
+```
+
+Effect:
+- `wicked_testing_missing` is set to `false` — crew commands proceed normally.
+- The probe subprocess (`npx wicked-testing --version`) is never invoked.
+- A single warning is emitted to **stderr** (not to the Claude session briefing):
+  `WG_SKIP_WICKED_TESTING_CHECK is set — wicked-testing version check bypassed (offline dev mode). Do not use in production.`
+
+**When to use**: CI pipelines where npm is unavailable; local development on
+machines without Node.js installed; offline development sessions.
+
+**When NOT to use**: Production environments, any session where crew QE gates
+will actually run (the bypass skips the version check but wicked-testing agents
+will still fail if the package is absent).
+
+This escape hatch is a developer override. It does NOT appear in user-facing help,
+setup wizard output, or the README. It is not a supported production configuration.
+
+### WICKED_VAULT_BIN
+
+**For offline CI and dev environments without the wicked-vault peer only.**
+
+wicked-vault (npm, ≥0.3, install `npx wicked-vault-install`) is a required peer
+alongside wicked-loom/bus/brain/testing. The garden's produces-gates re-derive
+evidence through **wicked-loom** — `scripts/qe/vault_gate.py` shells `wicked-loom
+gate`, which in turn shells `wicked-vault cross-check`, so the vault is the backend
+loom re-runs the verifier against. loom resolves the vault; the concrete-install
+probe (`vault_available`) and the `WICKED_VAULT_BIN` kill-switch below still apply.
+The vault CLI is resolved in order:
+
+1. `WICKED_VAULT_BIN` env var
+2. a config preference
+3. a global `wicked-vault` on `PATH`
+4. a local `node_modules/.bin/wicked-vault`
+5. `npx --yes wicked-vault`
+
+Setting `WICKED_VAULT_BIN=""` (set-but-empty) is the vault analogue of
+`WG_SKIP_WICKED_TESTING_CHECK`:
+
+```bash
+export WICKED_VAULT_BIN=""
+```
+
+Effect:
+- Vault resolution is disabled entirely — none of the fallbacks above are tried.
+- The produces-gate fails closed (or, with `--no-require`, falls back to the
+  doctrine-light claim-only path).
+- A SessionStart bootstrap check warns (non-blocking) when the vault isn't
+  resolvable.
+
+**When to use**: CI pipelines or local sessions where the wicked-vault peer is
+unavailable and you accept gates failing closed (or running claim-only).
+
+**When NOT to use**: Production environments, or any session where produces-gates
+must actually re-derive evidence — disabling resolution means there is no vault to
+cross-check against.
+
+This escape hatch is a developer override. It does NOT appear in user-facing help,
+setup wizard output, or the README. It is not a supported production configuration.
+
+### Fail-open boundary
+
+The wicked-testing probe (`_wicked_testing_probe.probe()`) is called by
+`_probe_wicked_testing()` in `hooks/scripts/bootstrap.py` at SessionStart.
+Any exception that escapes the probe is caught by `_probe_wicked_testing()`
+which logs actionable detail to stderr and continues bootstrap (fail-open).
+
+**CH-02 close**: `crew_command_gate()` in `scripts/crew/_prerequisites.py`
+is fail-closed: if `session_state.extras["wicked_testing_probe"]` is absent
+(probe exception path), the gate treats this as missing rather than passing.
+This prevents silent unblocked crew runs when the probe fails silently.

package/ETHOS.md

@@ -0,0 +1,83 @@
+# ETHOS
+
+> **What this is.** A single-page identity for wicked-garden — what we believe, what we refuse, what we optimize for.
+>
+> Coding agents grew into *harnesses* — they plan and execute well, with strong opinions about how they work. wicked-garden fills the gaps they can't fill alone — proof not claims, links grep can't see, deterministic refactor, memory across sessions, a second opinion that isn't itself — and never fights how the harness already works. It reads the *shape* of the work to apply the right rigor, then steps back. **Done is not claimed; done is re-derived.**
+>
+> `CLAUDE.md` tells you *how* the system works. This tells you *why*.
+
+---
+
+## What we believe
+
+**Don't fight the harness; fill its gaps.** Modern coding agents already plan, parallelize, and execute — and each has strong opinions about how it works. Wrestling that is wasted effort. We add only what a planner-executor genuinely can't do alone: re-derive "done" from evidence, see relationships grep can't, refactor deterministically across files, remember across sessions, and get a second opinion that isn't itself talking. Everything it already does well, we leave well alone.
+
+**Project shape determines ceremony.** A typo fix and a multi-repo schema migration are not the same project. Each prompt classifies into one or more of nine **work-shape archetypes** — `triage`, `explore`, `specify`, `decide`, `build`, `review`, `ship`, `incident`, `migrate` — and each owns its own phase shape, produces contract, and human-in-the-loop (HITL) discipline. A typo and a migration get appropriately-scaled rigor — not the same rigor, and not the same shape.
+
+**"Done" is re-derived, not asserted.** A gate does not go green because someone said so. Evidence is re-hashed and its verifier re-run through wicked-loom every time — which re-runs the verifier via wicked-vault underneath — a claimed-but-false "tests pass" is REJECTED, and a missing backend fails closed rather than passing on a self-assertion. The cheapest lie in software is a green checkmark with nothing behind it; we refuse to accept it.
+
+**Quality pressure must be structural, not delegated to willpower.** Reviews skipped under deadline pressure are gates that didn't exist. So enforcement lives in code, not prose: hard gates refuse to advance at runtime, produces re-derive through wicked-loom (which re-runs the verifier via the vault), and the audit trail is append-only. Good intentions don't have to survive a Friday afternoon — the gates do.
+
+**Knowledge compounds across sessions or it isn't knowledge.** If a decision, gotcha, or pattern lives only in the current chat, it dies with the chat. Every memorable thing belongs in a tier-appropriate memory store with confidence and decay rules. wicked-brain is the difference between learning once and learning every time.
+
+**Native primitives over bespoke abstractions.** Claude Code's `TaskCreate`, `Skill`, `Agent`, hooks, and slash commands are the surface. We extend them — we don't replace them. A task with metadata is more durable than a custom kanban; an agent with a frontmatter description is more discoverable than a registry call.
+
+**The gate is required; the rest is a toolkit.** wicked-garden's one non-negotiable is the evidence gate, so it stands on two required peers: **wicked-vault** (the backend that makes "done" re-derivable) and **wicked-loom** (the engine that re-runs the verifier). `/wicked-garden:setup` blocks without them — a gate you can fake is worse than no gate. The other siblings are **opt-in layers**, not prerequisites: **wicked-testing** (acceptance testing), **wicked-brain** (cross-session memory — the *what*), **wicked-understanding** (repo playbooks — the *how*), **wicked-bus** (the audit trail). Install the ones you'll use; the toolkit works without the others — breadth you adopt incrementally, not a five-thing prerequisite wall. And required-at-install is not brittle-at-runtime: a transient outage degrades gracefully and never bricks a session — but a gate never pretends missing evidence is a pass; that path **fails closed**. We depend on the gate; we don't crash with the layers.
+
+**Cross-platform is non-negotiable.** macOS, Linux, Windows (Git Bash, WSL, native). Bare `python3` doesn't exist on Windows; bare `/tmp` doesn't exist on Windows; the shim and `${TMPDIR:-/tmp}` exist for a reason. If a contributor adds shell that breaks on Windows, the contribution is incomplete.
+
+**Honest verdicts beat green dashboards.** A FAIL that surfaces a real bug is worth more than a PASS that masked it. Hard gates demand an *independent* judgment — the evaluator is not the agent that did the work — because authors cannot review their own work credibly.
+
+---
+
+## What we refuse
+
+**We do not require one fixed sequence of phases.** No universal pipeline. A prompt routes to a *set* of work-shape archetypes, and each runs its own phases. We deliberately do not factor "common phases" — that's how the old universal pipeline emerged, and it forced every kind of work into the same shape.
+
+**We do not let work grade its own "done".** Self-assessment is not evidence. A produces-gate re-derives the claim; a hard gate's verdict comes from an evaluator who is not the worker, recorded as a tamper-evident attestation. A "done" with no re-derivable backing is a fabrication, not a verdict.
+
+**We do not silently degrade quality signals.** When the evidence backend isn't resolvable, the gate **fails closed** and says so — it never invents a pass. When a signal is missing, we surface it as a finding; we don't paper over it to keep a dashboard green.
+
+**We do not hide our dependencies.** The gate's two required peers — and the three opt-in layers — are named, pinned, and checked at setup, not silent transitive surprises. If wicked-garden needs something to function, it says so up front and verifies it, rather than failing mysteriously three commands in.
+
+**We do not let vendors land regressions in the name of cleanup.** Five legitimate skill rewrites bundled with three frontmatter regressions and a vendor-CI hook is not a contribution worth merging. Reject the bundle, salvage the wins in-house.
+
+---
+
+## What we optimize for
+
+**A verdict you can trust on the first read.** A reviewer who can't trust the gate re-reads everything by hand, and flow is gone. We optimize for verdicts that are *re-derived* (recomputed, not cached) and *independent* (not self-graded) — trustworthy enough that the green means green.
+
+**Archetype-shaped rigor.** The detector classifies *work shape*, and rigor follows the shape — not a global dial that defaults to maximum. A `triage` is negligible; a `migrate` cutover is a hard gate with a rollback proof. The output is rigor that fits the work, applied where it matters.
+
+**Enforcement that travels.** `/wicked-garden:compile` emits a self-contained, vault-backed gate into any repo — one that re-derives the build's claims with **no wicked-garden runtime present**. We compile the *trigger* and the *enforcement*; we never compile the *tool*. The guarantee outlives the session that created it.
+
+**Append-only audit trails that survive context resets.** Decisions, gate verdicts, and evidence all land on disk in append-only form. A new session resumes work without losing the chain of reasoning. State that lives only in chat history is state that doesn't exist.
+
+**Honest measurement over vanity metrics.** PASS counts inflated by SKIPped scenarios are not coverage. MANUAL-ONLY is a distinct verdict from SKIP. A 70% real PASS rate beats a 95% inflated one, because the second hides regressions.
+
+---
+
+## What this is not
+
+**Not a prompt library.** Skills, agents, and commands are executable surfaces with frontmatter contracts and runtime enforcement — not text snippets to copy.
+
+**Not a fixed-sequence pipeline.** No two prompts run the same phase chain. Work shape is detected per prompt, not configured once per repo.
+
+**Not a starter for learning Claude Code.** This is a working toolkit that rides on a real harness, not a beginner tutorial. Basic harness fluency makes the first hour productive rather than steep.
+
+**Not a single-language toolkit.** Cross-platform stdlib-only Python for the plumbing. wicked-patch's generators support Python, TypeScript, Java, Go, SQL, Rust, Kotlin, C#, PHP, Ruby out of the box; new languages plug in via the generator interface.
+
+**Not closed.** The siblings (vault + loom required for the gate; testing, brain, understanding, bus opt-in) are peers, not forks — and the compiler emits a vault-backed harness any repo can adopt **without installing wicked-garden at all**. The plugin's relationship to other tools is "stand on, and hand off," not "absorb."
+
+---
+
+## How to read the rest
+
+- **`CLAUDE.md`** — operational guidance. How the surfaces compose, what the gates enforce, where state lives.
+- **`README.md`** — what to install, how to start, where to go next.
+- **`docs/v11/archetypes.md`** — the design note: why the universal pipeline went away and what replaced it.
+- **`docs/required-peers.md`** · **`docs/compiler.md`** — the peers (two required, three opt-in), and the compiler.
+- **`scenarios/`** — acceptance tests; each scenario is an executable assertion of intended behavior.
+
+If you can quote one sentence from this page after reading it once, the document worked. If you can quote three, we won.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mike Parcewski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+```
+           _      _            _                           _            
+ __      _(_) ___| | _____  __| |       __ _  __ _ _ __ __| | ___ _ __  
+ \ \ /\ / / |/ __| |/ / _ \/ _` |_____ / _` |/ _` | '__/ _` |/ _ \ '_ \ 
+  \ V  V /| | (__|   <  __/ (_| |_____| (_| | (_| | | | (_| |  __/ | | |
+   \_/\_/ |_|\___|_|\_\___|\__,_|      \__, |\__,_|_|  \__,_|\___|_| |_|
+                                       |___/                             
+```
+
+# Wicked Garden
+
+**Your coding agent already plans and swarms. Wicked Garden is the curated toolkit for what it can't do alone.**
+
+> 📖 Docs → [mikeparcewski.github.io/wicked-garden](https://mikeparcewski.github.io/wicked-garden/). Identity & beliefs → [`ETHOS.md`](ETHOS.md). How it works → [`CLAUDE.md`](.claude/CLAUDE.md).
+
+---
+
+## The premise
+
+Coding agents grew up. Claude Code, Codex, Cursor, Antigravity, Aider, OpenCode, Gemini CLI, Zed/ACP — they're not autocomplete anymore. They plan. They parallelize. And each has *strong opinions* about how it likes to work.
+
+Most plugins try to boss them around — re-implement planning, impose a workflow, make the agent dance. You end up fighting your own tools.
+
+**Wicked Garden refuses to wrestle the harness.** It assumes your agent is good at the things it's good at, and fills the gaps it *can't* fill on its own.
+
+## The gaps it fills
+
+| Your harness… | Wicked Garden… |
+|---|---|
+| says *"tests pass"* (sometimes it's lying) | re-runs the proof. False "done" → **rejected.** Missing backend → **fails closed.** Never a vacuous green. |
+| greps and reads — blind to string-wired links | sees the **injected edges** (event→consumer, command→agent, agent→capability) grep never will → `blast-radius`, `lineage` |
+| refactors on a hope and a prayer | renames across files as a **graph operation**, not find-replace roulette → wicked-patch |
+| forgets everything at `exit` | remembers what session 1 decided when you're in session 47 → wicked-brain |
+| re-derives *how to work in this repo* every task — which file owns the bug, the wiring step, the test command | loads the repo's own playbooks (`fix-bug`/`add-feature`/`verify`…), generated from HEAD → wicked-understanding |
+| asks *itself* for a second opinion | convenes a **real multi-model panel** (Gemini / Codex / …) → `jam:council` |
+| re-derives WCAG/CWE/SOC2 from memory every time | loads the rubric on demand, ships it to any repo |
+| grades its own homework | author ≠ executor ≠ reviewer → evidence-gated testing |
+
+The throughline: **done is re-derived, not asserted.** Verdicts you can trust on the first read — not green checkmarks you can't.
+
+## What it's *not*
+
+- **Not a workflow it forces on you.** Your harness still drives. Wicked Garden reads the *shape* of the work, applies the right amount of rigor, and steps back.
+- **Not a reinvention** of the planning and swarm your agent already nails.
+- **Not Claude-only under the hood.** Ships as a Claude Code plugin, but the engine is CLI/npm peers — and the gate **compiles into any repo and runs with no wicked-garden installed** (`/wicked-garden:compile`). Stand on the harness, fill its gaps, hand off. Never absorb.
+
+<details><summary><b>How it stays out of the way: work-shape, not pipeline</b></summary>
+
+No universal pipeline to obey. A hook reads each prompt's *shape* and that decides one thing: **how much rigor this work earns.** A typo (`triage`) gets none; a migration cutover (`migrate`) gets a hard, independently-attested gate with a rollback proof. Nine shapes — `triage · explore · specify · decide · build · review · ship · incident · migrate` — steering, not blocking. Why shapes and not one pipeline → [`docs/v11/archetypes.md`](docs/v11/archetypes.md).
+</details>
+
+---
+
+## Install
+
+```bash
+/plugin install wicked-garden      # in Claude Code
+/wicked-garden:setup               # verifies peers; blocks only on the two the gate needs
+```
+
+**Two required, three opt-in.** The evidence gate is the floor we won't fake, so it needs two peers — setup blocks without them:
+
+```bash
+npx wicked-vault-install       # the honest-evidence backend the gate re-derives against (≥ 0.3)
+npm i -g wicked-loom           # the gate engine that re-runs the verifier (or via npx)
+```
+
+The rest of the kit is **opt-in layers** — add what you want, skip the rest and the toolkit still works:
+
+```bash
+npx wicked-testing install     # the acceptance-testing layer (author ≠ executor ≠ reviewer)
+/plugin install wicked-brain   # the memory layer — cross-session recall + cited search (the "what")
+npx skills add mikeparcewski/wicked-understanding --all   # the repo-playbooks layer — "how to work in THIS repo" (the "how"; pairs with brain)
+/plugin install wicked-bus     # the audit-trail layer (fire-and-forget; fail-open without it)
+```
+
+Optional, lights up the code graph: `npx @colbymchenry/codegraph` (Node ≥ 22.5) → powers `blast-radius` / `lineage` / `hotspots` / wicked-patch. Details: [`docs/required-peers.md`](docs/required-peers.md).
+
+## Try it
+
+```bash
+# Just work — the hook applies the right rigor underneath, quietly
+"implement caching for the dashboard"
+
+# Or reach for a gap-filler on purpose
+/wicked-garden:prove                              # re-derive "done" from evidence (fail-closed)
+/wicked-garden:search:blast-radius emit_event     # impact, incl. edges grep can't see
+/wicked-garden:engineering:rename oldField newField   # deterministic, graph-driven
+/wicked-garden:jam:council "redis or memcached?"  # a panel that isn't just you
+
+# Stamp the evidence gate into ANY repo (runs with no wicked-garden installed)
+/wicked-garden:compile ~/path/to/repo --trigger ci
+```
+
+---
+
+## Principles
+
+- **Don't fight the harness.** Fill the gaps; never re-implement what it already does well.
+- **Done is re-derived, not asserted.** Every gate recomputes the evidence; the gates that matter are signed by someone who isn't the author.
+- **Steering, not blocking.** Rigor follows the shape of the work, applied only where it earns its keep.
+- **Enforcement that travels.** The gate compiles into any repo and runs without wicked-garden present.
+- **Borrow the harness's primitives.** Extend `TaskCreate`/`Task()`/skills/hooks — don't rebuild them.
+
+## More
+
+[`ETHOS.md`](ETHOS.md) · [`docs/getting-started.md`](docs/getting-started.md) · [`docs/domains.md`](docs/domains.md) · [`docs/required-peers.md`](docs/required-peers.md) · [`docs/compiler.md`](docs/compiler.md)
+
+## Requirements
+
+A coding-agent harness ([Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) ≥ 1.0 for the plugin surface; the peers + compiled gate are harness-agnostic) · Python 3.9+ (stdlib-only hooks) · Node + `npx` · the gate's two required peers (`wicked-vault` + `wicked-loom`) plus opt-in layers (`wicked-testing` · `wicked-brain` · `wicked-bus`).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/WICKED_GARDEN_BUS_EVENTS.md

@@ -0,0 +1,149 @@
+# wicked-garden Bus Event Catalog
+
+> Auto-generated from `scripts/_bus.py:BUS_EVENT_MAP`. Do not edit manually.
+> Regenerate: `python3 scripts/_bus_catalog_gen.py > WICKED_GARDEN_BUS_EVENTS.md`
+
+## Naming Convention
+
+```
+wicked.<noun>.<past-tense-verb>
+```
+
+Three segments. Always starts with `wicked.`. Noun = the thing that changed. Verb = past tense.
+`domain` field is always `wicked-garden`. `subdomain` identifies the functional area.
+
+## Payload Tiers
+
+| Tier | Contents | Rule |
+|------|----------|------|
+| **Tier 1** | IDs + outcomes | Always included |
+| **Tier 2** | Small categoricals (complexity_score, duration_secs, specialist) | Include when relevant |
+| **Tier 3** | Content, diffs, memory body, source code | **NEVER on bus** |
+
+## Payload Deny-List
+
+These fields are **stripped automatically** by `_bus.py` before emission:
+
+- `api_key`
+- `body`
+- `content`
+- `credential`
+- `diff`
+- `file_content`
+- `memory_content`
+- `password`
+- `patch`
+- `prompt`
+- `raw_text`
+- `secret`
+- `source_code`
+- `thinking`
+- `token`
+
+## Event Catalog
+
+### Crew
+
+| Event Type | Subdomain | Description |
+|------------|-----------|-------------|
+| `wicked.amendment.appended` | `crew.amendment` | Phase amendment appended to amendments.jsonl (Site W6 cutover) |
+| `wicked.archetype.advanced` | `crew.archetype` | v11 archetype phase approved + (when present) next phase named |
+| `wicked.archetype.classified` | `crew.classify` | v11 prompt classified into work-shape archetype set (LLM or regex tier) |
+| `wicked.archetype.completed` | `crew.archetype` | v11 archetype final phase approved (project is_complete) |
+| `wicked.archetype.created` | `crew.archetype` | v11 archetype-mode project created (carries v11_archetype + initial phase_plan) |
+| `wicked.archetype.hard_gate_passed` | `crew.archetype` | v11 archetype hard gate (cutover/mitigate/etc.) passed with confirmed_by + evidence |
+| `wicked.condition.marked_cleared` | `crew.condition` | Condition verification flipped to verified=True via mark_cleared() (Site 5 cutover) |
+| `wicked.consensus.evidence_recorded` | `crew.consensus` | Consensus rejection evidence written to consensus-evidence.json (audit trail) |
+| `wicked.consensus.gate_completed` | `crew.consensus` | Consensus gate verdict written to reviewer-report.md (append or create) |
+| `wicked.consensus.gate_pending` | `crew.consensus` | Pending consensus gate placeholder written to reviewer-report.md (evaluation failed) |
+| `wicked.consensus.report_created` | `crew.consensus` | Consensus gate report written to consensus-report.json |
+| `wicked.convergence.transition_recorded` | `crew.convergence` | Convergence-log transition recorded for an artifact (Site W8 cutover) |
+| `wicked.crew.inline_review_context_recorded` | `crew.solo_mode` | Inline-HITL gate review evidence recorded by solo_mode (Site W1 cutover) |
+| `wicked.crew.legacy_adopted` | `crew.migration` | Legacy beta.3 → v6.0 project migration applied via adopt_legacy.py (audit marker) |
+| `wicked.crew.qe_evaluator_migrated` | `crew.migration` | qe-evaluator → gate-adjudicator rename applied via migrate_qe_evaluator_name.py (audit marker) |
+| `wicked.crew.yolo_revoked` | `crew.yolo` | Yolo auto-approval revoked due to scope-increase mutation (audit + observability) |
+| `wicked.dispatch.log_entry_appended` | `crew.dispatch` | HMAC-signed dispatch-log.jsonl entry appended (orphan-check sentinel) |
+| `wicked.gate.blocked` | `crew.gate` | Gate returned REJECT — phase advancement blocked |
+| `wicked.gate.condition.resolved` | `crew.condition` | Mechanical CONDITIONAL finding resolved via crew:resolve skill (verdict unchanged) |
+| `wicked.gate.decided` | `crew.gate` | Gate returned APPROVE, CONDITIONAL, or REJECT |
+| `wicked.hitl.decision_recorded` | `crew.hitl` | HITL pause-decision evidence recorded by hitl_judge.write_hitl_decision_evidence (Site W5 cutover) |
+| `wicked.modernize.stack_gap` | `crew.modernize` | Legacy stack class is planned/none/unknown — capability-gap task emitted instead of a fabricated migration |
+| `wicked.phase.auto_advanced` | `crew.phase` | Phase auto-advanced for low-complexity project (audit trail) |
+| `wicked.phase.transitioned` | `crew.phase` | Phase approved and advanced to next |
+| `wicked.project.completed` | `crew.project` | Crew project completed (final phase approved) |
+| `wicked.project.complexity_scored` | `crew.scoring` | Complexity score computed for a project |
+| `wicked.project.created` | `crew.project` | New crew project created with complexity scoring |
+| `wicked.reeval.addendum_appended` | `crew.reeval` | Re-eval addendum appended to per-phase + project-root JSONL logs (Site W7 cutover; dual-file projection) |
+| `wicked.review.semantic_gap_recorded` | `crew.review` | Semantic-gap report persisted at review phase (Site W10a cutover) |
+| `wicked.rework.triggered` | `crew.rework` | Rework initiated after gate REJECT or CONDITIONAL |
+| `wicked.subagent.engaged` | `crew.subagent` | Specialist subagent engagement recorded by subagent_lifecycle (Site W9b cutover) |
+
+### Delivery
+
+| Event Type | Subdomain | Description |
+|------------|-----------|-------------|
+| `wicked.quality.drift_detected` | `delivery.telemetry` | Cross-session quality metric drifted past baseline threshold (special-cause or >=15% drop) |
+
+### Facts
+
+| Event Type | Subdomain | Description |
+|------------|-----------|-------------|
+| `wicked.fact.extracted` | `facts` | Structured fact extracted from conversation (consumed by wicked-brain auto-memorize) |
+
+### Gate
+
+| Event Type | Subdomain | Description |
+|------------|-----------|-------------|
+| `wicked.verdict.recorded` | `gate.verdict` | wicked-testing reviewer recorded a gate verdict (PASS/FAIL/N-A/SKIP) |
+
+### Jam
+
+| Event Type | Subdomain | Description |
+|------------|-----------|-------------|
+| `wicked.council.voted` | `jam.council` | Council evaluation completed with model votes |
+| `wicked.persona.contributed` | `jam.persona` | Persona contributed a perspective in a brainstorm round |
+| `wicked.session.started` | `jam.session` | Brainstorm or council session started |
+| `wicked.session.synthesis_ready` | `jam.session` | All expected Round 1 personas contributed or timeout elapsed — facilitator may synthesize |
+| `wicked.session.synthesized` | `jam.session` | Session synthesis completed |
+
+### Platform
+
+| Event Type | Subdomain | Description |
+|------------|-----------|-------------|
+| `wicked.compliance.failed` | `platform.compliance` | Compliance check failed for a framework |
+| `wicked.compliance.passed` | `platform.compliance` | Compliance check passed for a framework |
+| `wicked.guard.findings` | `platform.guard` | Autonomous session-close guard pipeline surfaced findings (Issue #448) |
+| `wicked.log.rotated` | `platform.log_retention` | Log file rotated by log_retention.rotate_if_needed (audit marker) |
+| `wicked.security.finding_raised` | `platform.security` | Security review raised a finding |
+
+### Qe
+
+| Event Type | Subdomain | Description |
+|------------|-----------|-------------|
+| `wicked.coverage.changed` | `qe.coverage` | Test coverage metrics changed |
+| `wicked.scenario.run` | `qe.scenario` | Test scenario executed with pass/fail result |
+
+## chain_id
+
+All crew events carry `chain_id` in the `metadata` field (top-level, not buried in payload).
+Format: `{uuid8}.root` for project root, `{uuid8}.{phase}` for phase scope.
+Enables timeline reconstruction across phases without a graph DB.
+
+## Consumer Integration Examples
+
+### Slack Bot (5 events)
+
+Subscribe to: `wicked.gate.blocked`, `wicked.phase.transitioned`, `wicked.project.completed`,
+`wicked.session.synthesized`, `wicked.rework.triggered`
+
+```bash
+npx wicked-bus subscribe --plugin my-slack-bot --filter 'wicked.gate.*' --filter 'wicked.phase.*'
+```
+
+### Dashboard (all events)
+
+Subscribe to: `wicked.*@wicked-garden`
+
+```bash
+npx wicked-bus subscribe --plugin my-dashboard --filter 'wicked.*@wicked-garden'
+```