Peer Health

---
name: wicked-garden-platform-peer-health
description: |
  Run a health check on all wicked-* peer tools (wicked-vault,
  wicked-bus). Reports reachability, version vs. pin, and
  declared capability status for each peer. The replacement for
  `npx wicked-loom doctor` after Phase B absorption — peer-resolution now runs
  in-process via scripts/loom/, no external wicked-loom needed.

  Use when: "peer health", "check the wicked peers", "is wicked-vault
  reachable", "loom doctor", "peer version drift", "capability gap", or any
  former /wicked-garden:platform:peer-health invocation.
metadata:
  role: module
  phases: "build,review,operate,bootstrap"
  archetypes: "*"
---

# Peer Health

Check reachability and version health of wicked-* peer tools.

## Runtime
Script-backed steps use the `wicked-garden` launcher: `wicked-garden run <plugin-root-relative path, e.g. scripts/…> [args]`. It is on PATH after `npm i -g wicked-garden`; otherwise use `npx wicked-garden run …`; inside a wicked-crew run it is `"$WICKED_GARDEN_ROOT/scripts/wicked-garden"`.
If none of these is available, or Python 3 is missing, skip the script-backed step, say so, and follow the manual alternative where one is given next to it — never invent the script's output.
Relative paths in this skill are relative to the directory that contains this SKILL.md.

## Arguments

- `--peer <name>` — check a single peer (vault, bus)
- `--strict` — exit non-zero if any peer has capability-gap (status != wired)
- `--json` — emit raw JSON rows instead of the formatted table

## Instructions

Run the internal loom doctor via the absorbed scripts/loom/compose module.
No external loom process is needed — this runs in-process.

```bash
wicked-garden python -c "
import sys, os, json
sys.path.insert(0, os.path.join(os.environ["WICKED_GARDEN_ROOT"], 'scripts'))
from loom import compose, manifest

peer_arg = None
import argparse
p = argparse.ArgumentParser()
p.add_argument('--peer', default=None)
p.add_argument('--strict', action='store_true')
p.add_argument('--json', dest='as_json', action='store_true')
try:
    args = p.parse_args()
except SystemExit:
    args = p.parse_args([])

if args.peer:
    rows = [compose.check_peer(args.peer)]
else:
    rows = compose.check_all()

if args.as_json:
    print(json.dumps(rows, indent=2))
else:
    # Human-readable table
    print()
    print(f'  {\"PEER\":<16} {\"STATUS\":<10} {\"VERSION\":<12} {\"CAPABILITY\":<14} PIN')
    print('  ' + '-'*62)
    for r in rows:
        peer_name = r.get('peer', '?')
        status = r.get('status', '?')
        version = r.get('installed', '-')
        cap = r.get('capability', '-') or '-'
        cap_ok = r.get('capability_ok', False)
        pin = r.get('pin', '-') or '-'
        icon = '  ' if r.get('ok') else '!'
        cap_icon = '' if cap_ok else ' (gap)'
        print(f'{icon} {peer_name:<16} {status:<10} {version:<12} {cap:<14}{cap_ok and \"\" or \" (!gap)\"}  ^{pin}')
    print()

if args.strict:
    gaps = [r['peer'] for r in rows if not r.get('capability_ok')]
    if gaps:
        print(f'STRICT: capability gaps on: {', '.join(gaps)}')
        sys.exit(1)
" $ARGUMENTS
```

## Status reference

| Status | Meaning | Action |
|---|---|---|
| `ok` | Resolved, version meets pin | None needed |
| `drift` | Resolved, version below pin | Update peer |
| `present` | Resolved + responds, version unreadable | WARN — update or check CLI |
| `missing` | Not found anywhere | Install the peer |
| `error` | Probe raised (binary vanished, OS error) | Reinstall |

## Capability status

`capability` is distinct from reachability. A peer can be `ok` (reachable)
but `experimental` or `planned` (not trusted for gating). The gate only
trusts `wired` peers — anything else yields a `capability-gap` verdict.

**wicked-brain** was retired at S7 and removed from the peer manifest: <!-- historical -->
garden exposes its surfaces via wicked-estate (the wicked-garden-mem/search
skill domains). It is not a peer to probe, install, or gate on.

## Usage examples

```
peer-health                    # all peers, formatted table
peer-health --peer vault       # single peer
peer-health --strict           # non-zero exit on any capability gap
peer-health --json             # raw JSON rows
```