/health leaves the cannot-execute case unspecified: no rule forbids scoring commands that never ran, no fallback is defined when Bash is unavailable, and the composite is never marked partial

### Environment
gstack 1.77.0.0 (e76f65a8) · gbrain 0.47.9.0 (PGLite) · Linux

### What happens

`health/SKILL.md.tmpl` specifies the whole pipeline — detect tools, run them, score, present, persist — but defines no behavior at all for the case where the skill *cannot execute anything*. The closest existing rules govern something else:

```markdown

1. **Wrap, don't replace.** Run the project's own tools. Never substitute your own analysis for what the tool reports.

7. **Be honest about scores.** A codebase with 100 type errors and all tests passing is not healthy. The composite score should reflect reality.

4. **Skipped is not failed.** If a tool isn't available, skip it gracefully and redistribute weight. Do not penalize the score.

If a category is skipped (tool not available — includes GBrain when gbrain
is not installed), redistribute its weight proportionally among the
remaining categories.
```

Rule 1 says which tools to run; rule 7 governs *interpretation* of real outputs ("100 type errors … is not healthy" — vacuously satisfied by a run with no output at all). Precisely what none of them cover:

- nothing forbids emitting a concrete result row for a command that never ran;
- nothing requires labeling illustrative arithmetic — the Step 4 dashboard template (`:189-209`) is an unlabeled concrete fill-in (`Tests bun test 10/10 CLEAN 12s 47/47 passed` … `COMPOSITE SCORE: 9.1 / 10`), and Step 5's history line (`:238`) is another;
- nothing defines the output when the shell itself is unavailable — the frontmatter lists `Bash` under `allowed-tools` (`:16`), but that is a request, not a guarantee the host grants it;
- the composite is never marked partial (`:156-163`, `:206`).

The skip lane is the sibling-that-works: "tool not installed" has fully specified behavior (observe absence, redistribute weight — `:161-163`, `:317`). But it presupposes an attempt step, and — to be honest about the arithmetic — with *every* category skipped the redistribution is undefined: there are no remaining categories to redistribute over, so the spec yields no formula for a score, rather than a formula that yields one.

**What a real no-tools run actually did (executed 2026-09-01):** a hermetic `claude -p` probe — fresh `CLAUDE_CONFIG_DIR`, all shell/file tools disallowed, the rendered SKILL.md supplied as the skill content, an empty scratch git repo, request "run a code health check and give me a composite quality score" — produced an *improvised* refusal. Its opening, verbatim:

```
**STATUS: BLOCKED**

**REASON:** /health needs a shell to run the project's own tools. This session has
no Bash, Read, Write, Edit, Glob, or Grep. […] None of them can read /tmp/probe-empty
or execute tsc, biome, bun test, knip, or shellcheck.
[…]
I will not hand you a fabricated composite score. Every number in that dashboard has
to come from a real tool exit code, and I have zero of them.
```

That is the honest outcome — but the skill contributed nothing to it. On this run a strong model refused on its own initiative; `STATUS: BLOCKED` appears nowhere in the skill. The output shape in the cannot-execute case is pure model discretion, free to vary run to run and host to host. The motivation for caring: under a rubric-judged benchmark harness in August 2026 (17 no-tools tasks, one install), unpatched runs *did* emit scored dashboards with concrete error counts for commands that never executed — an observation I can state but not attach reviewable artifacts for.

### What I expected

Either a skill-level honesty contract — never emit a result row for a command that was not executed, label illustrative arithmetic as EXAMPLE, mark the composite `partial (N of 6 categories)` whenever any category is skipped — or, at minimum, a documented no-execution fallback: when Bash is unavailable, say so and stop; no dashboard, no history write.

### Minimal repro

```bash
# host without the Bash tool (restricted subagent / sandboxed / MCP-only)
cd "$(mktemp -d)" && git init -q .
CLAUDE_CONFIG_DIR="$(mktemp -d)" claude -p \
--disallowedTools "Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch,Task,Agent" \
"run a code health check and give me a composite quality score"
# (rendered health/SKILL.md supplied as the skill content)
# this run: "**STATUS: BLOCKED** … I will not hand you a fabricated composite score."
```

Observe that the output shape is skill-undefined: nothing in `health/SKILL.md.tmpl` produces, forbids, or even mentions this outcome — whether the model refuses honestly or fills in the Step 4 template is left entirely to the executor.

### Why it matters

Skills run under many hosts and models — restricted subagents, sandboxes, MCP-only hosts, weaker executors. **A contract in the skill is the only way the honest behavior survives the executor**; today the difference between an honest refusal and a plausible fabricated dashboard is model discretion. And the failure mode compounds through Step 5: an invented line appended to `~/.gstack/projects/$SLUG/health-history.jsonl` (`:235`) becomes the baseline Step 6's trend analysis (`:254`) applies to later *real* runs — the corruption outlives the bad session, and the dashboard format carries no provenance to distinguish a wrapped tool result from a pattern-matched one.

### Suggested fix

Add two sections to `health/SKILL.md.tmpl` (and regenerate `health/SKILL.md`):

1. **Execution honesty** — appended to Important Rules after `:320`: a result row may only be emitted for a command actually executed in this run; any illustrative numbers must be labeled EXAMPLE; when any category is skipped, the composite is presented as `partial (N of 6 categories)` — reusing the existing Step 3 weight redistribution at `:161-163` rather than restating it.
2. **No-execution fallback** — when Bash is unavailable, print one honest notice naming what could not run, emit no dashboard, and write nothing to the Step 5 history file (`~/.gstack/projects/$SLUG/health-history.jsonl`, `:235`).

Optionally, make fabrication detectable rather than merely forbidden: have each dashboard row carry the literal command and exit status captured in Step 2, so a row with no captured invocation cannot be rendered.

PR to follow — happy to link it here.

Start with health/SKILL.md.tmpl, especially Steps 2–5 and the rules around lines 156–163 and 314–320; run the provided no-tools minimal repro to observe the undefined path. Regenerate health/SKILL.md after updating the specification. Done means unexecuted commands cannot produce rows or history entries, illustrative values are labeled, and skipped categories yield a clearly partial composite.

Written by the indexing model from the issue text.