wicked-garden 12.27.0

package/scripts/_bus_catalog_gen.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Generate WICKED_GARDEN_BUS_EVENTS.md from the static BUS_EVENT_MAP in _bus.py.
+
+Run: python3 scripts/_bus_catalog_gen.py > WICKED_GARDEN_BUS_EVENTS.md
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from _bus import BUS_EVENT_MAP, _PAYLOAD_DENY_LIST
+
+
+def generate():
+    lines = []
+    lines.append("# wicked-garden Bus Event Catalog")
+    lines.append("")
+    lines.append("> Auto-generated from `scripts/_bus.py:BUS_EVENT_MAP`. Do not edit manually.")
+    lines.append("> Regenerate: `python3 scripts/_bus_catalog_gen.py > WICKED_GARDEN_BUS_EVENTS.md`")
+    lines.append("")
+    lines.append("## Naming Convention")
+    lines.append("")
+    lines.append("```")
+    lines.append("wicked.<noun>.<past-tense-verb>")
+    lines.append("```")
+    lines.append("")
+    lines.append("Three segments. Always starts with `wicked.`. Noun = the thing that changed. Verb = past tense.")
+    lines.append("`domain` field is always `wicked-garden`. `subdomain` identifies the functional area.")
+    lines.append("")
+    lines.append("## Payload Tiers")
+    lines.append("")
+    lines.append("| Tier | Contents | Rule |")
+    lines.append("|------|----------|------|")
+    lines.append("| **Tier 1** | IDs + outcomes | Always included |")
+    lines.append("| **Tier 2** | Small categoricals (complexity_score, duration_secs, specialist) | Include when relevant |")
+    lines.append("| **Tier 3** | Content, diffs, memory body, source code | **NEVER on bus** |")
+    lines.append("")
+    lines.append("## Payload Deny-List")
+    lines.append("")
+    lines.append("These fields are **stripped automatically** by `_bus.py` before emission:")
+    lines.append("")
+    for field in sorted(_PAYLOAD_DENY_LIST):
+        lines.append(f"- `{field}`")
+    lines.append("")
+    lines.append("## Event Catalog")
+    lines.append("")
+
+    # Group by subdomain prefix (domain area)
+    groups = {}
+    for event_type, defn in sorted(BUS_EVENT_MAP.items()):
+        area = defn["subdomain"].split(".")[0]
+        groups.setdefault(area, []).append((event_type, defn))
+
+    for area, events in sorted(groups.items()):
+        lines.append(f"### {area.title()}")
+        lines.append("")
+        lines.append("| Event Type | Subdomain | Description |")
+        lines.append("|------------|-----------|-------------|")
+        for event_type, defn in events:
+            lines.append(f"| `{event_type}` | `{defn['subdomain']}` | {defn['description']} |")
+        lines.append("")
+
+    lines.append("## chain_id")
+    lines.append("")
+    lines.append("All crew events carry `chain_id` in the `metadata` field (top-level, not buried in payload).")
+    lines.append("Format: `{uuid8}.root` for project root, `{uuid8}.{phase}` for phase scope.")
+    lines.append("Enables timeline reconstruction across phases without a graph DB.")
+    lines.append("")
+    lines.append("## Consumer Integration Examples")
+    lines.append("")
+    lines.append("### Slack Bot (5 events)")
+    lines.append("")
+    lines.append("Subscribe to: `wicked.gate.blocked`, `wicked.phase.transitioned`, `wicked.project.completed`,")
+    lines.append("`wicked.session.synthesized`, `wicked.rework.triggered`")
+    lines.append("")
+    lines.append("```bash")
+    lines.append("npx wicked-bus subscribe --plugin my-slack-bot --filter 'wicked.gate.*' --filter 'wicked.phase.*'")
+    lines.append("```")
+    lines.append("")
+    lines.append("### Dashboard (all events)")
+    lines.append("")
+    lines.append("Subscribe to: `wicked.*@wicked-garden`")
+    lines.append("")
+    lines.append("```bash")
+    lines.append("npx wicked-bus subscribe --plugin my-dashboard --filter 'wicked.*@wicked-garden'")
+    lines.append("```")
+
+    return "\n".join(lines) + "\n"
+
+
+if __name__ == "__main__":
+    print(generate(), end="")

package/scripts/_bus_consumers.json

@@ -0,0 +1,46 @@
+{
+  "_comment": "Consumer registry — max 8 active consumers. Review gate for additions.",
+  "max_consumers": 8,
+  "consumers": [
+    {
+      "id": "crew:auto-advance",
+      "event_filter": "wicked.gate.decided",
+      "domain": "crew",
+      "description": "Auto-advances phase for complexity ≤ 2 projects with auto_advance=true",
+      "module": "scripts/crew/_bus_consumers.py",
+      "added": "2026-04-13"
+    },
+    {
+      "id": "smaht:brain-consolidated",
+      "event_filter": "wicked.brain.consolidated",
+      "domain": "smaht",
+      "description": "Invalidates smaht brain adapter cache when brain consolidates",
+      "module": "scripts/smaht/_bus_consumers.py",
+      "added": "2026-04-13"
+    },
+    {
+      "id": "smaht:brain-config-updated",
+      "event_filter": "wicked.config.updated",
+      "domain": "smaht",
+      "description": "Clears brain port cache when brain config changes",
+      "module": "scripts/smaht/_bus_consumers.py",
+      "added": "2026-04-13"
+    },
+    {
+      "id": "smaht:brain-initialized",
+      "event_filter": "wicked.brain.initialized",
+      "domain": "smaht",
+      "description": "Auto-configures smaht brain adapter when brain is first created",
+      "module": "scripts/smaht/_bus_consumers.py",
+      "added": "2026-04-13"
+    },
+    {
+      "id": "jam:synthesis-trigger",
+      "event_filter": "wicked.persona.contributed",
+      "domain": "jam",
+      "description": "Emits wicked.session.synthesis_ready when all Round 1 personas have contributed or 120s elapsed",
+      "module": "scripts/jam/_bus_consumers.py",
+      "added": "2026-04-17"
+    }
+  ]
+}

package/scripts/_bus_emit.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+CLI wrapper for _bus.emit_event() — called from agent/command markdown via bash.
+
+Usage:
+    python3 scripts/_bus_emit.py <event_type> <payload_json> [--chain-id <id>]
+
+Examples:
+    python3 scripts/_bus_emit.py wicked.session.started '{"session_id":"abc","topic":"test"}'
+    python3 scripts/_bus_emit.py wicked.phase.transitioned '{"project_id":"x"}' --chain-id x.root
+"""
+
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from _bus import emit_event
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: _bus_emit.py <event_type> <payload_json> [--chain-id <id>]", file=sys.stderr)
+        sys.exit(1)
+
+    event_type = sys.argv[1]
+    try:
+        payload = json.loads(sys.argv[2])
+    except json.JSONDecodeError:
+        print(f"Invalid JSON payload: {sys.argv[2]}", file=sys.stderr)
+        sys.exit(1)
+
+    chain_id = None
+    if "--chain-id" in sys.argv:
+        idx = sys.argv.index("--chain-id")
+        if idx + 1 < len(sys.argv):
+            chain_id = sys.argv[idx + 1]
+
+    emit_event(event_type, payload, chain_id=chain_id)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/_capability_registry.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""
+_capability_registry.py — Registry of capabilities that need runtime discovery.
+
+Only lists capabilities where tools must be PROBED at runtime (MCP servers,
+CLI binaries). Built-in Claude Code tools (Read, Write, Edit, Grep, Glob,
+Bash, WebFetch, WebSearch, Task) are always available and known to the
+model — they don't belong here.
+
+stdlib-only — no external dependencies.
+
+Usage:
+    from _capability_registry import CAPABILITY_REGISTRY, CapabilityDef, ToolOption
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ToolOption:
+    """A tool that requires runtime detection to confirm availability."""
+
+    name: str  # Tool name as it appears in allowed-tools
+    detection: str  # "mcp:{pattern}" | "cli:{binary}"
+    mcp_pattern: str = ""  # Substring match against MCP server names
+    cli_binary: str = ""  # Binary name for shutil.which() probe
+    priority: int = 100  # Lower = preferred (user prefs override)
+    install_hint: str = ""  # Shown when required capability is missing
+
+
+@dataclass
+class CapabilityDef:
+    """A capability that requires runtime environment probing."""
+
+    name: str  # kebab-case capability name
+    description: str  # Human-readable purpose
+    tools: list[ToolOption] = field(default_factory=list)  # Probeable tool options
+    required: bool = False  # If True, warn when no tool available
+
+
+# ---------------------------------------------------------------------------
+# Registry — only capabilities that need runtime discovery
+# ---------------------------------------------------------------------------
+
+CAPABILITY_REGISTRY: dict[str, CapabilityDef] = {
+    "project-management": CapabilityDef(
+        name="project-management",
+        description="Track tasks and issues via Jira, Linear, or GitHub Issues MCP servers.",
+        tools=[
+            ToolOption(
+                name="mcp__jira__*",
+                detection="mcp:jira",
+                mcp_pattern="jira",
+                priority=50,
+                install_hint="Configure a Jira MCP server for project management.",
+            ),
+            ToolOption(
+                name="mcp__linear__*",
+                detection="mcp:linear",
+                mcp_pattern="linear",
+                priority=50,
+                install_hint="Configure a Linear MCP server for project management.",
+            ),
+            ToolOption(
+                name="mcp__github__*",
+                detection="mcp:github",
+                mcp_pattern="github",
+                priority=60,
+                install_hint="Configure the GitHub MCP server for issue tracking.",
+            ),
+        ],
+    ),
+    "security-scanning": CapabilityDef(
+        name="security-scanning",
+        description="Scan code for vulnerabilities via Semgrep, Snyk, or Trivy.",
+        tools=[
+            ToolOption(
+                name="mcp__semgrep-plugin__semgrep",
+                detection="mcp:semgrep",
+                mcp_pattern="semgrep",
+                priority=30,
+                install_hint="pip install semgrep && semgrep login",
+            ),
+            ToolOption(
+                name="snyk",
+                detection="cli:snyk",
+                cli_binary="snyk",
+                priority=50,
+                install_hint="npm install -g snyk && snyk auth",
+            ),
+            ToolOption(
+                name="trivy",
+                detection="cli:trivy",
+                cli_binary="trivy",
+                priority=50,
+                install_hint="brew install aquasecurity/trivy/trivy",
+            ),
+        ],
+    ),
+    "error-tracking": CapabilityDef(
+        name="error-tracking",
+        description="Monitor errors and system health via Sentry or Datadog MCP servers.",
+        tools=[
+            ToolOption(
+                name="mcp__sentry__*",
+                detection="mcp:sentry",
+                mcp_pattern="sentry",
+                priority=40,
+                install_hint="Configure a Sentry MCP server for error tracking.",
+            ),
+            ToolOption(
+                name="mcp__datadog__*",
+                detection="mcp:datadog",
+                mcp_pattern="datadog",
+                priority=40,
+                install_hint="Configure a Datadog MCP server for error tracking.",
+            ),
+        ],
+    ),
+    "documentation": CapabilityDef(
+        name="documentation",
+        description="Access external documentation via Confluence or Notion MCP servers.",
+        tools=[
+            ToolOption(
+                name="mcp__confluence__*",
+                detection="mcp:confluence",
+                mcp_pattern="confluence",
+                priority=40,
+                install_hint="Configure a Confluence MCP server for documentation access.",
+            ),
+            ToolOption(
+                name="mcp__notion__*",
+                detection="mcp:notion",
+                mcp_pattern="notion",
+                priority=40,
+                install_hint="Configure a Notion MCP server for documentation access.",
+            ),
+        ],
+    ),
+    "version-control": CapabilityDef(
+        name="version-control",
+        description="GitHub/GitLab integration via CLI or MCP server.",
+        tools=[
+            ToolOption(
+                name="gh",
+                detection="cli:gh",
+                cli_binary="gh",
+                priority=30,
+                install_hint="brew install gh && gh auth login",
+            ),
+            ToolOption(
+                name="glab",
+                detection="cli:glab",
+                cli_binary="glab",
+                priority=40,
+                install_hint="brew install glab && glab auth login",
+            ),
+            ToolOption(
+                name="mcp__github__*",
+                detection="mcp:github",
+                mcp_pattern="github",
+                priority=50,
+            ),
+            ToolOption(
+                name="mcp__gitlab__*",
+                detection="mcp:gitlab",
+                mcp_pattern="gitlab",
+                priority=50,
+            ),
+        ],
+    ),
+    "ci-cd": CapabilityDef(
+        name="ci-cd",
+        description="CI/CD pipeline interaction via GitHub Actions, GitLab CI, or CircleCI.",
+        tools=[
+            ToolOption(
+                name="mcp__github__*",
+                detection="mcp:github",
+                mcp_pattern="github",
+                priority=40,
+            ),
+            ToolOption(
+                name="mcp__gitlab__*",
+                detection="mcp:gitlab",
+                mcp_pattern="gitlab",
+                priority=40,
+            ),
+            ToolOption(
+                name="circleci",
+                detection="cli:circleci",
+                cli_binary="circleci",
+                priority=60,
+                install_hint="brew install circleci",
+            ),
+        ],
+    ),
+    "data-query": CapabilityDef(
+        name="data-query",
+        description="Query databases via DuckDB, PostgreSQL, or data MCP servers.",
+        tools=[
+            ToolOption(
+                name="mcp__duckdb__*",
+                detection="mcp:duckdb",
+                mcp_pattern="duckdb",
+                priority=40,
+                install_hint="Configure a DuckDB MCP server for data querying.",
+            ),
+            ToolOption(
+                name="duckdb",
+                detection="cli:duckdb",
+                cli_binary="duckdb",
+                priority=50,
+                install_hint="brew install duckdb",
+            ),
+            ToolOption(
+                name="psql",
+                detection="cli:psql",
+                cli_binary="psql",
+                priority=60,
+                install_hint="brew install postgresql",
+            ),
+        ],
+    ),
+    "apm": CapabilityDef(
+        name="apm",
+        description="Application performance monitoring via Datadog, New Relic, or Grafana.",
+        tools=[
+            ToolOption(
+                name="mcp__datadog__*",
+                detection="mcp:datadog",
+                mcp_pattern="datadog",
+                priority=40,
+                install_hint="Configure a Datadog MCP server for APM.",
+            ),
+            ToolOption(
+                name="mcp__newrelic__*",
+                detection="mcp:newrelic",
+                mcp_pattern="newrelic",
+                priority=45,
+                install_hint="Configure a New Relic MCP server for APM.",
+            ),
+            ToolOption(
+                name="mcp__grafana__*",
+                detection="mcp:grafana",
+                mcp_pattern="grafana",
+                priority=50,
+                install_hint="Configure a Grafana MCP server for APM dashboards.",
+            ),
+        ],
+    ),
+    "tracing": CapabilityDef(
+        name="tracing",
+        description="Distributed tracing via Honeycomb, Grafana Tempo, or Datadog.",
+        tools=[
+            ToolOption(
+                name="mcp__honeycomb__*",
+                detection="mcp:honeycomb",
+                mcp_pattern="honeycomb",
+                priority=40,
+                install_hint="Configure a Honeycomb MCP server for distributed tracing.",
+            ),
+            ToolOption(
+                name="mcp__grafana__*",
+                detection="mcp:grafana",
+                mcp_pattern="grafana",
+                priority=50,
+                install_hint="Configure a Grafana MCP server (Tempo) for tracing.",
+            ),
+            ToolOption(
+                name="mcp__datadog__*",
+                detection="mcp:datadog",
+                mcp_pattern="datadog",
+                priority=50,
+                install_hint="Configure a Datadog MCP server for tracing.",
+            ),
+        ],
+    ),
+    "logging": CapabilityDef(
+        name="logging",
+        description="Log aggregation and search via Grafana Loki, Datadog, or Elasticsearch.",
+        tools=[
+            ToolOption(
+                name="mcp__grafana__*",
+                detection="mcp:grafana",
+                mcp_pattern="grafana",
+                priority=45,
+                install_hint="Configure a Grafana MCP server (Loki) for log search.",
+            ),
+            ToolOption(
+                name="mcp__datadog__*",
+                detection="mcp:datadog",
+                mcp_pattern="datadog",
+                priority=45,
+                install_hint="Configure a Datadog MCP server for log search.",
+            ),
+            ToolOption(
+                name="mcp__elasticsearch__*",
+                detection="mcp:elastic",
+                mcp_pattern="elastic",
+                priority=55,
+                install_hint="Configure an Elasticsearch MCP server for log search.",
+            ),
+        ],
+    ),
+    "telemetry": CapabilityDef(
+        name="telemetry",
+        description="OpenTelemetry and metrics pipelines via Grafana, Prometheus, or OTel tooling.",
+        tools=[
+            ToolOption(
+                name="mcp__grafana__*",
+                detection="mcp:grafana",
+                mcp_pattern="grafana",
+                priority=45,
+                install_hint="Configure a Grafana MCP server for metrics.",
+            ),
+            ToolOption(
+                name="mcp__prometheus__*",
+                detection="mcp:prometheus",
+                mcp_pattern="prometheus",
+                priority=50,
+                install_hint="Configure a Prometheus MCP server for metrics.",
+            ),
+            ToolOption(
+                name="otel",
+                detection="cli:otel",
+                cli_binary="otel",
+                priority=70,
+                install_hint="Install the OpenTelemetry CLI (otel).",
+            ),
+        ],
+    ),
+}