wicked-garden 12.27.0

package/skills/ground/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: wicked-garden-ground
+context: fork
+description: |
+  Grounding / assumption-check: pull deeper context from brain + bus when uncertain,
+  before acting. Use when: getting mixed signals from the codebase, about to commit to a
+  non-obvious decision, prior decisions might exist for this exact problem, or you want to
+  verify an assumption before action ("am I sure about this?", "have we decided this
+  before?"). Returns relevant brain memories, recent bus events, and linked priors ranked
+  by relevance — not a wall of text. Aliases: grounding, sanity-check, verify-assumption.
+
+  NOT for: routine "what does this code do" questions (use Read or Grep), broad
+  codebase exploration (use Agent(Explore)), or fetching specific symbols (use
+  wicked-brain:search directly).
+portability: portable
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# wicked-garden:ground — Steer Yourself
+
+You are uncertain. Pull what's known into focus.
+
+## When to use
+
+- Getting mixed signals from the codebase — two things contradict each other
+- About to commit to a non-obvious decision — want to know if it's been tried before
+- Prior decisions might exist for this exact problem — avoid re-deriving what was deliberated
+- Want to verify an assumption before taking action — gut feel needs grounding
+- Picking back up on a topic after context has shifted — "let me get my bearings"
+- Asking "wait, did we already decide this?" — brain memory is the answer
+
+## When NOT to use
+
+- Routine "what does this code do" questions — use Read or Grep, they're faster
+- Broad codebase exploration without a specific question — use Agent(Explore)
+- Fetching a specific symbol you already know exists — use wicked-brain:search directly
+- During flow when you already have enough context — don't interrupt to re-ground
+
+## Mechanism
+
+1. Take the `question` argument (free text from the user / Claude's internal state)
+2. **Parallel query** — run all three simultaneously:
+   - `wicked-brain:query` — conceptual grounding ("what do we know about X")
+   - `wicked-brain:search` — specific decisions, patterns, gotchas (top 5 results)
+   - `wicked-bus:query` — recent bus events matching the question (last 50, filter by
+     relevance to question terms)
+3. **Synthesize** — rank by relevance, dedupe overlap, cap at top 5–10 signals total.
+   Priority order: brain memories > brain wiki > brain chunks > bus events.
+4. **Output** — dense, structured. For each hit:
+   - Source type: `brain/memory`, `brain/wiki`, `brain/chunk`, or `bus/event`
+   - One-line relevance statement (why this signal matters to the question)
+   - Path or event-id for follow-up
+   - Suggested follow-up tool (e.g., `wicked-brain:read {path} depth=2`)
+5. **Closing pointer**: "If you need more depth on `{most relevant path}`, use
+   `wicked-brain:read {path} depth=2`"
+6. **DO NOT** dump full file content — this is a focusing tool, not a firehose.
+   The output should be skimmable in under 30 seconds.
+
+## Implementation
+
+When invoked with a `question`:
+
+**Step 1 — Decompose the question into 3–5 search terms.** Extract noun phrases,
+named entities, and technical terms. Example: "v8 daemon projection model" →
+`["daemon", "projection", "v8 architecture", "state machine"]`.
+
+**Step 2 — Parallel execution.** Invoke all three in a single parallel batch:
+
+```bash
+# Brain conceptual query
+Skill(wicked-brain:query, question="{question}", session_id="{session}")
+
+# Brain symbol/decision search (repeat per term if ≥2 terms)
+Skill(wicked-brain:search, query="{term1}", limit=5, session_id="{session}")
+Skill(wicked-brain:search, query="{term2}", limit=5, session_id="{session}")
+
+# Bus recent events
+Skill(wicked-bus:query, query="{question}", limit=50)
+```
+
+**Step 3 — Rank and dedupe.** Collect all results. Score by:
+- Source priority (memory > wiki > chunk > bus event)
+- Recency for bus events (newer = higher)
+- Overlap with question terms (more term matches = higher)
+
+Keep the top 5–10 unique signals. Drop results where two sources say the same
+thing — keep the higher-priority source.
+
+**Step 4 — Format output.** Use this shape:
+
+```
+## Grounding: {question}
+
+### What the brain knows
+
+1. [brain/memory] {one-line relevance} — `{path}` → suggest: wicked-brain:read {path}
+2. [brain/wiki] {one-line relevance} — `{path}`
+3. [brain/chunk] {one-line relevance} — `{path}`
+
+### Recent bus activity
+
+4. [bus/event] {event_type} @ {timestamp} — {one-line relevance}
+5. [bus/event] {event_type} @ {timestamp} — {one-line relevance}
+
+### If you need more depth
+`wicked-brain:read {most relevant path} depth=2`
+```
+
+**Step 5 — If zero results from both brain and bus**, say so explicitly:
+"No prior decisions or recent events found for this question. Proceeding without
+grounding — consider storing the decision you reach with `wicked-brain:memory`."
+
+## Graceful degradation
+
+- Brain unavailable → skip brain steps, surface bus events only, note degradation
+- Bus unavailable → skip bus step, surface brain results only, note degradation
+- Both unavailable → emit: "Ground returned no context (brain and bus both unreachable).
+  Proceeding on codebase signals only."
+
+Never block progress. Ground is a focusing tool — absence of prior context is
+itself a useful signal.
+
+## After grounding
+
+If you reach a decision that others should know about:
+- Store it: `wicked-brain:memory` (store mode)
+- Emit it: `wicked-bus:emit` with the relevant event type
+
+The value of grounding compounds when decisions are written back.

package/skills/integration-discovery/SKILL.md

@@ -0,0 +1,168 @@
+---
+name: wicked-garden-integration-discovery
+context: fork
+description: |
+  Capability router that decides which tools, skills, and agents to use for a task.
+  Discovers CLI tools in PATH alongside MCP servers, skills, and agents.
+  Reduces cognitive load on the main agent by making tool selection decisions.
+
+  Use when: planning work in an unfamiliar domain, deciding which tools or
+  agents fit a task, or discovering installed CLIs / MCP servers.
+user-invocable: false
+status: experimental
+phase_relevance: ["bootstrap"]
+archetype_relevance: ["*"]
+---
+
+# Capability Router
+
+**Purpose**: Scout available capabilities and decide what to use for a task. Return actionable recommendations so the main agent can execute without discovery overhead.
+
+## Why This Matters
+
+Most agents execute with whatever tools are obvious. They don't:
+- Check what else is available
+- Consider skills that could help
+- Look for specialized agents
+- Adapt to the user's configured integrations
+
+**This skill changes that.** It scouts, evaluates, and recommends—so the main agent can focus on execution.
+
+## Quick Usage
+
+### As Inline Check
+
+```markdown
+Before executing this task, let me check what capabilities could help.
+
+**Task**: Review PR #123 for security issues
+
+**Discovery**:
+- MCP: github (PR context), atlassian (link to Jira)
+- Skills: qe (test scenarios), platform (security checks)
+- Agents: wicked-garden:platform:security-engineer
+
+**Recommendation**: Use security-engineer agent for review, github MCP for PR data.
+```
+
+### As Subagent
+
+For complex tasks, spawn integration-discovery as a subagent:
+
+```
+Task tool:
+  subagent_type: "Explore"
+  prompt: "Scout available capabilities for: [task description].
+           Return specific recommendations on which MCP servers,
+           skills, and agents to use."
+```
+
+## The Discovery Process
+
+### Step 1: Understand the Task
+
+What does this task need?
+- **Information sources**: Where does data come from?
+- **Actions**: What operations are required?
+- **Quality concerns**: Security, testing, compliance?
+- **Output**: Where do results go?
+
+### Step 2: Scout Available Capabilities
+
+Check these sources (see refs/discovery-sources.md for details):
+
+| Source | How to Check | What You Get |
+|--------|--------------|--------------|
+| **MCP Servers** | `ListMcpResourcesTool` | External integrations |
+| **CLI Tools** | `command -v {tool}` | Installed binaries in PATH |
+| **Skills** | Check Skill tool description | Methodology/expertise |
+| **Agents** | Check Task tool agent list | Specialized workers |
+| **Built-in Tools** | Known set | File ops, search, web |
+
+### Step 3: Match Capabilities to Needs
+
+For each task need, find matching capabilities:
+
+```markdown
+Task: "Implement user authentication"
+
+| Need | Capability | Recommendation |
+|------|------------|----------------|
+| Security review | wicked-garden:platform:security-engineer | Use for auth review |
+| Test strategy | wicked-garden:crew:gate-adjudicator | Use for test planning |
+| Store decisions | wicked-brain:memory | Store auth decisions |
+| Track work | MCP:atlassian or native TaskCreate | Track implementation |
+```
+
+### Step 4: Return Recommendations
+
+Output a clear recommendation the main agent can act on:
+
+```markdown
+## Capability Recommendations for: [Task]
+
+**Use these**:
+1. **wicked-garden:platform:security-engineer** - Review for security issues
+2. **MCP:atlassian** - Link work to Jira ticket AUTH-123
+
+**Available but optional**:
+- wicked-garden:crew:gate-adjudicator - If test planning needed
+- wicked-brain:memory - Store decisions for future reference
+
+**Not available** (consider installing):
+- No analytics MCP found - can't check auth failure metrics
+```
+
+## Common Task Patterns
+
+Quick mappings for common tasks (see refs/task-patterns.md for full list):
+
+| Task Type | Likely Capabilities |
+|-----------|---------------------|
+| Code review | engineering agents, github MCP |
+| Security audit | platform agents, qe |
+| Architecture design | engineering agents, wicked-brain:memory |
+| Bug investigation | engineering agents, error tracking MCP |
+| Feature planning | product agents, project management MCP |
+| Documentation | engineering agents, confluence MCP |
+
+## Decision Principles
+
+When multiple options exist:
+
+1. **Prefer specialized over general** - Use security-engineer for security, not generic reviewer
+2. **Prefer available integrations** - Use configured MCP over manual alternatives
+3. **Consider task scope** - Simple task? Skip the heavy machinery
+4. **Check dependencies** - Some agents work better together
+
+## Output Format
+
+Always return structured recommendations:
+
+```markdown
+## Capability Recommendations
+
+**Task**: [one-line task description]
+
+### Recommended
+| Capability | Type | Use For |
+|------------|------|---------|
+| name | MCP/Skill/Agent | specific purpose |
+
+### Optional
+| Capability | Type | Use If |
+|------------|------|--------|
+| name | type | condition |
+
+### Not Available
+| Need | Suggestion |
+|------|------------|
+| what's missing | how to get it |
+```
+
+## References
+
+- [Discovery Sources](refs/discovery-sources.md) - Where to look and how
+- [Task Patterns](refs/task-patterns.md) - Common task-to-capability mappings
+- [MCP Capabilities](refs/capabilities.md) - MCP server categories and patterns
+- [CLI Detection](refs/cli-detection.md) - CLI tool detection patterns and decision policy

package/skills/integration-discovery/refs/capabilities.md

@@ -0,0 +1,282 @@
+---
+phase_relevance: ["bootstrap"]
+archetype_relevance: ["*"]
+---
+# Capability Definitions
+
+Detailed patterns for discovering integrations by capability category.
+
+## Project Management
+
+**Purpose**: Task tracking, sprints, boards, issue management
+
+**Discovery patterns** (check server names/descriptions for):
+- `issue`, `task`, `ticket`, `bug`
+- `project`, `board`, `sprint`, `backlog`
+- `jira`, `linear`, `asana`, `github`, `gitlab`
+- `trello`, `monday`, `clickup`, `notion`
+
+**Common operations**:
+- Create/update issues
+- Query project status
+- Link code to issues
+- Track progress
+
+**Fallback**: Use native TaskCreate/TaskUpdate for local task management
+
+---
+
+## Analytics & Metrics
+
+**Purpose**: User behavior, product metrics, event tracking
+
+**Discovery patterns**:
+- `analytics`, `metrics`, `events`, `tracking`
+- `posthog`, `mixpanel`, `amplitude`, `segment`
+- `google-analytics`, `plausible`, `matomo`
+
+**Common operations**:
+- Query user behavior
+- Analyze funnels
+- Track feature usage
+- Generate reports
+
+**Fallback**: Use data for local data analysis
+
+---
+
+## Error Tracking & Monitoring
+
+**Purpose**: Exception tracking, crash reports, APM
+
+**Discovery patterns**:
+- `error`, `exception`, `crash`, `sentry`
+- `monitoring`, `observability`, `apm`
+- `rollbar`, `bugsnag`, `datadog`, `newrelic`
+
+**Common operations**:
+- Query recent errors
+- Analyze error trends
+- Link errors to code
+- Track release health
+
+**Fallback**: Search logs via wicked-garden:search
+
+---
+
+## Design Systems
+
+**Purpose**: Design tokens, components, visual assets
+
+**Discovery patterns**:
+- `design`, `figma`, `sketch`, `adobe`
+- `component`, `storybook`, `chromatic`
+- `token`, `theme`, `style`
+
+**Common operations**:
+- Export design tokens
+- Query component specs
+- Sync design decisions
+- Access visual assets
+
+**Fallback**: Manual design system documentation
+
+---
+
+## Data Warehouses
+
+**Purpose**: Large-scale data queries, BI, transformations
+
+**Discovery patterns**:
+- `warehouse`, `lakehouse`, `dbt`
+- `snowflake`, `databricks`, `bigquery`, `redshift`
+- `sql`, `query`, `etl`
+
+**Common operations**:
+- Execute SQL queries
+- Access data models
+- Query lineage
+- Generate reports
+
+**Fallback**: Use data for local file analysis
+
+---
+
+## Documentation & Knowledge
+
+**Purpose**: Wikis, docs, knowledge bases
+
+**Discovery patterns**:
+- `wiki`, `docs`, `documentation`
+- `confluence`, `notion`, `coda`
+- `knowledge`, `kb`
+
+**Common operations**:
+- Search documentation
+- Create/update pages
+- Link code to docs
+- Export content
+
+**Fallback**: Use wicked-garden:search for local doc search
+
+---
+
+## Communication
+
+**Purpose**: Team chat, notifications, collaboration
+
+**Discovery patterns**:
+- `chat`, `message`, `slack`, `teams`
+- `discord`, `mattermost`, `rocket`
+- `notification`, `alert`
+
+**Common operations**:
+- Send notifications
+- Query conversations
+- Create channels
+- Share updates
+
+**Fallback**: Manual communication
+
+---
+
+## CI/CD & DevOps
+
+**Purpose**: Pipelines, deployments, infrastructure
+
+**Discovery patterns**:
+- `pipeline`, `ci`, `cd`, `deploy`
+- `github-actions`, `gitlab-ci`, `jenkins`
+- `terraform`, `kubernetes`, `docker`
+
+**Common operations**:
+- Trigger builds
+- Check pipeline status
+- Deploy applications
+- Manage infrastructure
+
+**Fallback**: Use platform CLI skills
+
+---
+
+## Security & Compliance
+
+**Purpose**: Vulnerability scanning, secrets, compliance
+
+**Discovery patterns**:
+- `security`, `vulnerability`, `scan`
+- `snyk`, `trivy`, `vault`, `secrets`
+- `compliance`, `audit`, `sast`, `sca`
+
+**Common operations**:
+- Run security scans
+- Manage secrets
+- Check compliance
+- Generate SBOMs
+
+**Fallback**: Use platform local checks
+
+---
+
+## Feature Flags
+
+**Purpose**: Feature toggles, experiments, gradual rollouts
+
+**Discovery patterns**:
+- `feature`, `flag`, `toggle`
+- `launchdarkly`, `unleash`, `split`
+- `experiment`, `ab-test`, `rollout`
+
+**Common operations**:
+- Check flag status
+- Create experiments
+- Query rollout progress
+- Manage targeting
+
+**Fallback**: Config-based flags in code
+
+---
+
+## Customer Feedback
+
+**Purpose**: Support tickets, surveys, user feedback
+
+**Discovery patterns**:
+- `support`, `ticket`, `zendesk`
+- `intercom`, `freshdesk`, `helpscout`
+- `survey`, `feedback`, `nps`
+
+**Common operations**:
+- Query support tickets
+- Analyze feedback trends
+- Link bugs to reports
+- Track satisfaction
+
+**Fallback**: Manual feedback review
+
+---
+
+## CLI Detection
+
+**Purpose**: Discover installed CLI tools in the system PATH
+
+**Detection method**: `command -v {tool}` (POSIX-portable, works on macOS, Linux, WSL)
+
+**CLI categories**:
+- AI CLIs: claude, codex, copilot, gemini, opencode, pi
+- Browser: playwright, puppeteer, cypress, chrome-devtools-protocol
+- Cloud: aws, gcloud, az, heroku, vercel, fly
+- Observability: datadog-agent, newrelic, dynatrace
+- Data: duckdb, psql, mysql, mongosh, redis-cli
+- CI/CD: gh, glab, circleci
+- Package managers: npm, pip, cargo, go, uv, bun
+
+**Decision policy**:
+- Low stakes (e.g., package manager): auto-decide silently
+- Medium stakes (e.g., browser tool): auto-decide, inform user
+- High stakes (e.g., cloud provider): always ask user
+
+**Fallback**: Recommend installation of the preferred tool for the category
+
+See [cli-detection.md](cli-detection.md) for full detection patterns and decision policy.
+
+---
+
+## Discovery Implementation
+
+```python
+# Pseudo-code for capability discovery
+
+def discover_capability(capability_name):
+    """Discover integrations matching a capability."""
+    patterns = CAPABILITY_PATTERNS[capability_name]
+
+    # Get available MCP servers
+    servers = list_mcp_resources()
+
+    # Match by patterns
+    matches = []
+    for server in servers:
+        for pattern in patterns:
+            if pattern in server.name.lower() or pattern in server.description.lower():
+                matches.append(server)
+                break
+
+    return matches or None
+```
+
+## Usage in Skills
+
+```markdown
+## Integration Discovery
+
+This skill can leverage external integrations:
+
+| Capability | Purpose | Discovery |
+|------------|---------|-----------|
+| project-management | Link work to issues | Check for jira, linear, github |
+| analytics | User behavior data | Check for posthog, mixpanel |
+
+Run `ListMcpResourcesTool` and match against capability patterns.
+If no match found, use standalone mode with local alternatives.
+```