skill: expose the trust layer as a consumable peltier skill

The reusable artifact here was never the vendored targets — it is the
discipline: prove equivalence, prove significance, or claim nothing. This
packages it as a Claude Code skill usable from any repo.

Two modes. `verify` works anywhere, on any two shell commands in any
language: equivalence before timing -> A/A calibration -> interleaved A/B
with a bootstrap CI -> a verdict decided by the CI lower bound, never the
median. `attempt` drives the full in-repo loop (gates, pristine-baseline
verdict, ledger row, ROI report).

It drives the real bench-runner binary and refuses rather than degrade: on
an unsupported host, or with no trust layer reachable, preflight stops and
says so instead of falling back to a hand-rolled timing loop. A second copy
of the statistics is a second thing that can lie. A refusal ends the claim,
not the work.

An adversarial review of the skill caught six high-severity defects, all
fixed here — several of them the very errors the skill exists to prevent:

- verify mode had no risk classification at all. bench-runner emits only
  accepted/rejected-bench; needs-human-review is minted by the in-repo
  verdict path, which verify does not run. A concurrency change with
  byte-identical output would have sailed through as "accepted". The skill
  now makes the agent the classifier and says so explicitly.
- the accept template exposed `pin_prefix`, which is inert for
  compare/aa/calibrate (only `verdict` reads it) — an agent would have set
  it and reported pinning that never happened. Now documents wrapping both
  sides in taskset instead.
- the equivalence gate compared stdout only, so two commands that write to
  stderr and a dist/ tree would "GOLDEN PASS" on two empty files. Now hashes
  stdout + stderr + exit code + artifact tree, and an empty diff over empty
  output is a failed gate, not a passed one.
- nothing told the agent to build two coexisting immutable artifacts, so a
  `cargo run` baseline could rebuild from the patched tree mid-bench — the
  exact trap phase1-verdict-smoke-001 recorded.
- service mode was documented as generic HTTP. It is not: the server must
  take <port> <doc> <iters>, print READY, and close the connection. A stock
  Express app hangs the harness forever. Contract now stated.
- the CI refusal test could not pass: preflight also walks up from its own
  location, so running it in-place found this very repo. The test now copies
  the skill out of the tree first.

CI job `skill-preflight` asserts the contract that matters — resolve when a
trust layer is reachable, REFUSE when it is not, and work when consumed from
another repo via PELTIER_HOME. It deliberately does not assert a statistical
outcome: a shared runner is too noisy for that, which is precisely why the
skill calibrates before it claims.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

README.md

@@ -71,6 +71,30 @@ tests, but cannot run the pipeline.
 Full command reference and reproduction steps:
 [Reproduce it yourself](https://bdbrown4.github.io/peltier.io/reproduce.html).
 
+## Use it on your own code
+
+The trust layer is not specific to these targets — it will judge any two shell
+commands. `.claude/skills/peltier/` packages it as a Claude Code skill:
+
+```sh
+# from any repo, with a peltier checkout reachable
+export PELTIER_HOME=/path/to/peltier.io
+mkdir -p .claude/skills
+cp -r /path/to/peltier.io/.claude/skills/peltier .claude/skills/
+```
+
+Then ask Claude to verify a speedup. The skill enforces the order that makes a
+performance claim mean something: **equivalence before timing** (a faster
+program that computes something different is a bug, not an optimization) →
+**A/A calibration** (a host that "finds" a speedup between a binary and itself
+cannot measure yours) → **interleaved A/B with a bootstrap CI** → a verdict
+decided by the CI *lower bound*, never the median.
+
+It drives the real `bench-runner` binary and **refuses rather than degrade**:
+on an unsupported host, or with no trust layer reachable, it stops and says so
+instead of falling back to a hand-rolled timing loop. A second copy of the
+statistics is a second thing that can lie.
+
 ## How it stays honest
 
 - The agent speaks to the trust layer through **seven read-only-plus-one-