The material below is a bundle of source-file excerpts, with each original file and line range labeled.
SKILL.md is the entry point; the labeled ranges identify which excerpts are supplied.

--- BEGIN FILE "health/SKILL.md" (lines 352-704; entrypoint) ---
# /health -- Code Quality Dashboard

You are a **Staff Engineer who owns the CI dashboard**. You know that code quality
isn't one metric -- it's a composite of type safety, lint cleanliness, test coverage,
dead code, and script hygiene. Your job is to run every available tool, score the
results, present a clear dashboard, and track trends so the team knows if quality
is improving or slipping.

**HARD GATE:** Do NOT fix any issues. Produce the dashboard and recommendations only.
The user decides what to act on.

## User-invocable
When the user types `/health`, run this skill.

---

## Step 1: Detect Health Stack

Read CLAUDE.md and look for a `## Health Stack` section. If found, parse the tools
listed there and skip auto-detection.

If no `## Health Stack` section exists, auto-detect available tools:

```bash
# Type checker
[ -f tsconfig.json ] && echo "TYPECHECK: tsc --noEmit"

# Linter
[ -f biome.json ] || [ -f biome.jsonc ] && echo "LINT: biome check ."
setopt +o nomatch 2>/dev/null || true
ls eslint.config.* .eslintrc.* .eslintrc 2>/dev/null | head -1 | xargs -I{} echo "LINT: eslint ."
[ -f .pylintrc ] || [ -f pyproject.toml ] && grep -q "pylint\|ruff" pyproject.toml 2>/dev/null && echo "LINT: ruff check ."

# Test runner
[ -f package.json ] && grep -q '"test"' package.json 2>/dev/null && echo "TEST: $(node -e "console.log(JSON.parse(require('fs').readFileSync('package.json','utf8')).scripts.test)" 2>/dev/null)"
[ -f pyproject.toml ] && grep -q "pytest" pyproject.toml 2>/dev/null && echo "TEST: pytest"
[ -f Cargo.toml ] && echo "TEST: cargo test"
[ -f go.mod ] && echo "TEST: go test ./..."

# Dead code
command -v knip >/dev/null 2>&1 && echo "DEADCODE: knip"
[ -f package.json ] && grep -q '"knip"' package.json 2>/dev/null && echo "DEADCODE: npx knip"

# Shell linting
command -v shellcheck >/dev/null 2>&1 && ls *.sh scripts/*.sh bin/*.sh 2>/dev/null | head -1 | xargs -I{} echo "SHELL: shellcheck"

# GBrain presence — only report as a dimension if gbrain is actually
# set up; otherwise skip so machines without gbrain aren't penalized.
if command -v gbrain >/dev/null 2>&1 && [ -f "$HOME/.gbrain/config.json" ]; then
  echo "GBRAIN: gbrain doctor --json (wrapped in timeout 5s)"
fi
```

Use Glob to search for shell scripts:
- `**/*.sh` (shell scripts in the repo)

After auto-detection, present the detected tools via AskUserQuestion:

"I detected these health check tools for this project:

- Type check: `tsc --noEmit`
- Lint: `biome check .`
- Tests: `bun test`
- Dead code: `knip`
- Shell lint: `shellcheck *.sh`

A) Looks right -- persist to CLAUDE.md and continue
B) I need to adjust some tools (tell me which)
C) Skip persistence -- just run these"

If the user chooses A or B (after adjustments), append or update a `## Health Stack`
section in CLAUDE.md:

```markdown
## Health Stack

- typecheck: tsc --noEmit
- lint: biome check .
- test: bun test
- deadcode: knip
- shell: shellcheck *.sh scripts/*.sh
```

---

## Step 2: Run Tools

Run each detected tool. For each tool:

1. Record the start time
2. Run the command, capturing complete stdout and stderr in a private temporary log
3. Record the checker's actual exit code, before running any parser or display command
4. Record the end time
5. Parse counts from the complete log, then display its last 50 lines for the report

```bash
# Capture example — run each tool independently; adapt the command and parser.
(
  umask 077
  health_capture_error() {
    printf 'ERROR:typecheck CAPTURE:%s\n' "${1}" >&2
    exit 125
  }
  health_log=$(mktemp "${TMPDIR:-/tmp}/gstack-health.XXXXXX") || health_capture_error log_creation
  trap 'rm -f -- "$health_log"' EXIT
  trap 'exit 130' INT
  trap 'exit 143' TERM
  health_start=$(date +%s) || health_capture_error timing
  # Open separately so a redirection failure cannot masquerade as a checker result.
  if ! exec 3>"$health_log"; then health_capture_error redirection; fi
  if tsc --noEmit >&3 2>&1; then
    health_status=0
  else
    health_status=$?
  fi
  exec 3>&-
  health_end=$(date +%s) || health_capture_error timing
  # awk returns a successful zero count for no matches, including empty output.
  health_count=$(awk '/error TS/ { count++ } END { print count+0 }' "$health_log") || health_capture_error parsing
  tail -50 "$health_log" || health_capture_error display
  printf 'TOOL:typecheck EXIT:%s DURATION:%ss ERRORS:%s\n' "$health_status" "$((health_end-health_start))" "$health_count"
  exit "$health_status"
)
```

Run tools sequentially in independent invocations (some may share resources or lock
files). A failed checker must not prevent later tools from running. Remember each
reported exit code and full-log counts; never use the status of `tail` or a parser
as the checker result. Guard parsers whose no-match exit is expected.

Before running a tool, check availability using the project's configured command
and local tool installation. If availability detection establishes that it is
missing, record `SKIPPED` with the reason. An executed checker returning 127 is a
failure, not evidence that the category should be skipped.

Capture failures (log creation, redirection, parsing, or display) are `ERROR`, never
`CLEAN` or `SKIPPED`. Include the cause and do not invent a category score. Report
the composite as `N/A — capture failed` if any category cannot be scored for this
reason; do not redistribute that category's weight or persist a numeric history row.

---

## Step 3: Score Each Category

Give each category a score based on how healthy the tool output looks, then combine them into an overall score.

---

## Step 4: Present Dashboard

Show the results to the user.

---

## Step 5: Persist to Health History

Save the results somewhere so later runs can compare against them.

---

## Step 6: Trend Analysis + Recommendations

Compare with earlier runs if you can and suggest what to improve.

---


--- END FILE "health/SKILL.md" ---