mikeparcewski/wicked-garden-integration-discovery
skills/integration-discovery/SKILL.md
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.
$ install --global
skillsauthnpx skillsauth add mikeparcewski/wicked-garden wicked-garden-integration-discoveryInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
Security Scan Results
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
3
Scanners Passed
9
Scanners in report
Clean
TrivyContainer and dependency vulnerability scanner
95%
Clean
SemgrepStatic code analysis for vulnerabilities
95%
Clean
mcp-scan (Snyk)Model Context Protocol security validation
95%
Skipped
Snyk (dep)Open source security scanning
50%
Skipped
Socket.devSupply chain security analysis
50%
Skipped
VirusTotalMulti-engine malware detection
50%
Skipped
CrowdStrikeAdvanced threat intelligence
50%
Skipped
OSV-ScannerOpen Source Vulnerability database check
50%
Skipped
OWASP Dep-Check
50%
Last scanned: Jul 12, 2026, 7:06 AM24.6s5 files scanned
SKILL.md
- name:
- wicked-garden-integration-discovery
- context:
- fork
- description:
- |
- Use when:
- planning work in an unfamiliar domain, deciding which tools or
- 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
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:
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:
## 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:
- Prefer specialized over general - Use security-engineer for security, not generic reviewer
- Prefer available integrations - Use configured MCP over manual alternatives
- Consider task scope - Simple task? Skip the heavy machinery
- Check dependencies - Some agents work better together
Output Format
Always return structured recommendations:
## 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 - Where to look and how
- Task Patterns - Common task-to-capability mappings
- MCP Capabilities - MCP server categories and patterns
- CLI Detection - CLI tool detection patterns and decision policy
Related Skills
mikeparcewski/wicked-garden-engineering-conformance-reviewer
development
VerifiedTrustedCommunity
Pattern-conformance agent-half: evaluates a produced artifact or diff against a set of architectural/design pattern rules from the conformance-rule store (wicked_governance schema). Returns structured findings with rule ID, severity, and rationale — the deterministic half (mechanical rule recall) is done by the guard pipeline; this is the semantic evaluation step. Triggered by: the guard_pipeline `outgov_pattern` check (session-close), or explicitly by an engineering review when WICKED_OUTGOV_RULES_DIR is populated. NOT a replacement for the full `engineering` review skill — focuses only on conformance to stored Pattern rules; architecture and code-quality checks live in the `engineering` skill. Semantic evaluation reuses `wicked-garden-qe-semantic-reviewer` as the designated agent-half evaluator (per garden#983 spec). This skill is the orchestrating wrapper that loads applicable Pattern rules and delegates the per-rule semantic judgment to qe-semantic-reviewer.
8SKILL.mdUpdated Jul 22, 2026
mikeparcewski/wicked-garden-domain
tools
VerifiedTrustedCommunity
The FOUNDATIONAL domain-model capability: extract a codebase's domain — testable business rules (with confidence + provenance), entities, requirements — as a schema-conformant model on the estate graph. The workers annotate the store; wicked-core reads it and builds the requirements graph, coverage-gating fail-closed. Steers three fork workers. A shared substrate, not a modernization tool. The `modernize` archetype DERIVES from it; build / migrate / review / specify / explore consume the SAME domain model — none OWN it. Understanding a codebase's domain is upstream of almost everything else garden does. Use when: "extract the business rules / domain model from this codebase", "build a requirements graph from the code", "what does this system actually require", "reverse-engineer the domain before we build/port/migrate". Works on ANY codebase (modern or legacy) — the value is the domain model, not the porting. NOT the code transform itself (that is the archetype consuming this model). This skill produces the DOMAIN MODEL, not new code.
8SKILL.mdUpdated Jul 15, 2026
mikeparcewski/wicked-garden-domain-modeler
development
VerifiedTrustedCommunity
Domain-graph fork worker for the modernize archetype. Groups the estate's Louvain communities into business domains, attaches each requirement to its cluster (advisory cluster_id provenance), and invokes wicked-core's domain-graph build (which reads the annotated estate store, recomputes coverage fail-closed, and builds the requirements graph) — then validates core's output against the vendored schema. Use when: dispatched by wicked-garden-domain after rule extraction to turn a flat rule set into cluster-keyed domains; "group these into domains", "build the requirements graph", "translate clusters into a domain model". NOT for mining the rules themselves (that is domain-extractor) or threat-modeling (that is domain-coverage).
8SKILL.mdUpdated Jul 15, 2026
mikeparcewski/wicked-garden-domain-extractor
tools
VerifiedTrustedCommunity
Rule-extraction fork worker for the FOUNDATIONAL domain-model capability. Mines testable business rules from a codebase — each with a numeric confidence and a provenance{source, ref, source_kinds} — and annotates them into the estate store so wicked-core can build the domain-model requirements graph (coverage-gated). This is a substrate, not a modernization tool: the `modernize` archetype DERIVES from it, and build / migrate / review / specify / explore can consume the same domain model — none OWN it. Use when: dispatched by wicked-garden-domain to mine the business_rules of a codebase (or a module); "extract the domain rules", "what does this system require", building the requirements half of a domain model. NOT for grouping into domains (that is domain-modeler) or judging coverage (that is domain-coverage — a seat-distinct evaluator).
8SKILL.mdUpdated Jul 15, 2026