- name
SKILL.md
File skill tetap berada di repositori penerbit.
Tempel perintah yang disalin di terminal. Perintah itu memasang SKILL.md ini ke agen tersebut.
npx skills add BlackBeltTechnology/pi-agent-dashboard --skill ship-it -a cursor -yTempel perintah yang disalin di terminal. Perintah itu memasang SKILL.md ini ke agen tersebut.
npx skills add BlackBeltTechnology/pi-agent-dashboard --skill ship-it -a claude-code -yTempel perintah yang disalin di terminal. Perintah itu memasang SKILL.md ini ke agen tersebut.
npx skills add BlackBeltTechnology/pi-agent-dashboard --skill ship-it -a codex -yTempel perintah yang disalin di terminal. Perintah itu memasang SKILL.md ini ke agen tersebut.
npx skills add BlackBeltTechnology/pi-agent-dashboard --skill ship-it -a grok -yKirim pesan yang disalin di chat Grok Bot. Bot mengambil SKILL.md ini dari GitHub dan menambahkannya ke skill yang dipakai bersama oleh semua Bot Anda.
Install this skill: https://github.com/BlackBeltTechnology/pi-agent-dashboard/tree/HEAD/.pi/skills/ship-itDari penerbit
Orchestrates the implementation phase of an OpenSpec change inside its git
worktree. Twin of plan-proposal (which runs the planning phase on develop).
Composes existing skills — openspec-apply-change, the docker harness, and
ship-change — and adds the wiring they lack. Runnable headless.
flowchart LR
P["plan-proposal (develop)"] -->|"boundary: spawn worktree"| S
subgraph Worktree ["IMPLEMENTATION — worktree (this skill)"]
S["ship-it"] --> A["apply"] --> M["merge develop (2.5)"] --> T["docker-harness test"] --> E["enforcers (4.4)"] --> Q["CodeQL ratchet (4.4b)"] --> R["local review (4.5)"] --> C["ship-change"]
end
S -.->|"reverse: SHIP_IT_BLOCKED.md on design issue"| P
Pure decision logic lives in this skill's own scripts/ directory and is
unit-tested (.pi/skills/ship-it is a vitest project):
scripts/manifest.ts (parseManifest, deferDecision, filesystemRealityCheck),
scripts/no-weakening.ts (assertNoWeakening),
scripts/review-gate.ts (reviewRoundDecision, parseReviewReply,
resolveReviewer, classifyFindings, REVIEW_TIMEOUT_MS),
scripts/fix-ledger.ts (validateFixLedger), scripts/review-state.ts
(deriveReviewState), and scripts/review-prompt.ts (buildReviewPrompt + the
step-4.5 CLI), and scripts/openspec-deps-gate.ts (runGate, the step-1.5
dependency gate). The CodeQL ratchet of step 4.4b is the repo script
scripts/codeql-local.mjs (see docs/code-quality.md).
.worktrees/os-<change>, branch
os/<change>). Resolve the change name from the worktree dir basename.docker available (the e2e harness); openspec CLI resolves from the parent
repo root when inside a worktree (per AGENTS.md).<change> (worktree implementation phase)."openspec status, but gate on filesystem reality (idempotent)Entry gate — a previous hand-back. If
openspec/changes/<change>/SHIP_IT_BLOCKED.md already exists, a previous
invocation handed the change to a human. A run is interactive exactly when
the ask_user tool is available; otherwise it is headless.
SHIP_IT_BLOCKED.md. No fix loop, no
review round, no ship-change step.ask_user resume / abort. On
abort, stop without changes. On resume, create this invocation's run dir
(step 4.5), copy SHIP_IT_BLOCKED.md into it (evidence kept), then remove
the file from the change dir.Removing the file, or answering resume, is the human decision that starts a
new review budget — re-invoking ship-it alone never does. A hand-back written
by step 4.4b (new CodeQL alerts, a script error, a baseline-diff violation) lists
the alerts and how to resolve them; resume re-runs 4.4 and 4.4b, which then ask
per alert.
Read openspec status --change <change> --json for orientation only. Do not
trust the tasks.md checkbox as proof an automated scenario is done — a
hand-checked or prior-partial - [x] can lie.
Parse test-plan.md (parseManifest). For each automated row, resolve its
folded test file and run filesystemRealityCheck: a scenario is satisfied only
when its test file exists AND passes in the harness (step 3). Any automated
row whose test file is absent → NOT done → author it (step 2) regardless of the
checkbox. This makes re-invocation genuinely idempotent: fresh run and re-run
reach the same all-green end state.
Runs on every invocation, after the SHIP_IT_BLOCKED.md entry gate and the
orientation above, and before any implementation step. From the worktree
root, with a 60 s overall timeout on the tool call:
npx tsx .pi/skills/ship-it/scripts/openspec-deps-gate.ts --change <change>
The script owns all logic (dashboard query with a bounded retry, offline parser
fallback, origin/develop archive lookup) and prints one JSON verdict
{ status: ok|warn|blocked, mode: online|offline, blockers: [{ change, state: open|satisfied|unknown, source }], issues: [{ code, severity, message }], notes }.
Act on it — do not re-derive it:
status: blocked (an error issue: invalid-file, self-reference, a
declared cycle) → write SHIP_IT_BLOCKED.md naming the issue(s) and stop via
the step-5 escape hatch. No fix loop, no review round.state: open) → a warning. Interactive → ask_user
continue / stop (with the situation brief below, listing the open blockers);
on stop write SHIP_IT_BLOCKED.md naming them and stop. Headless →
continue and carry the open blockers into the final report.satisfied, unknown names and
the script's notes never interrupt; report them. A blocker the script counted
as satisfied because it is archived on origin/develop is a pending merge,
not a blocker (step 2.5 brings it in).mode: offline checked this change's own dependencies.yaml only: say in the
report that cycles and inferred edges were not checked.kb-first, even as an executor. You know which files the tasks name, so your
reflex is grep/cat/Read on them directly. The docs-first gate still applies:
before you grep/rg for a symbol, Read a file to learn its purpose, or chase
an import, run kb_search / kb agents <path> / kb_neighbors FIRST. Knowing
the file does not exempt you — kb the symbol/file, then edit.
If non-manual-only tasks remain (real code + the test files the fold tasked),
run openspec-apply-change for the change. apply writes code and marks tasks.
apply has no "copy from exemplar" capability of its own. For each folded test
task, resolve the harness-exemplar pointer (the nearest existing spec of that
category named in the task) and inject its path into the task context you hand
apply — or author the spec yourself in the fix loop (step 4). Bare
"author X.spec.ts" with no exemplar is forbidden.
develop — merge before the harness (primary integration point)The harness (step 3) is the strongest gate on the ship-it path, so integration
must sit upstream of it: the harness must validate the merged tree T1, not
the pre-merge tree T0. Merge origin/develop — the remote ref, never local
develop (checked out in the parent repo → worktree branch-collision pitfall):
git fetch origin develop
git merge --no-edit origin/develop
Idempotent: up-to-date → "Already up to date", no merge commit, safe to always
run. Merge, not rebase — step 9 squash-merges anyway, so rebase's linear
history is moot while its force-push is a documented ship-change footgun.
Conflict → abort + STOP. On an unresolved conflict, git merge --abort,
report, and do not enter the harness — never run the gate on a half-merged
tree. Resolve trivial conflicts with ship-change's existing recipes (AGENTS.md
union-keep; pnpm-lock.yaml → git checkout --theirs +
pnpm install --lockfile-only), then re-run the merge. A conflict you cannot
resolve mechanically → escape hatch (step 5).
Obtain the harness and its port from docker/test-up.sh (allocator on first run,
reuser on re-up — do NOT add port code). Read the derived port from
.pi-test-harness.json (dashboardPort) — never hardcode :18000.
Wrap the whole run so teardown ALWAYS happens (red test, abort, or a partial
test-up.sh start):
cleanup() { docker/test-down.sh || true; }
trap cleanup EXIT
docker/test-up.sh -d --build # allocates + records .pi-test-harness.json
port=$(jq -r '.dashboardPort' .pi-test-harness.json) # jq is present in the harness env
# run the relevant suite against $port:
PW_E2E_USE_RUNNING=1 npm run test:e2e # L3; or the L1/L2 suite for other levels
test-down.sh is safe against a partially-created compose project (compose down -v + best-effort rm). Isolation is no longer silent, though: a second
worktree's harness saturates the daemon (two 4 GiB limits on an 8 GB VM), so
test-up.sh refuses when (n+1) × MEM_LIMIT >= MemTotal — n = other running
pi-dash-test-* projects, MEM_LIMIT default 4g — naming them and the
arithmetic, and warns (once) when the limits fit but a peer is up, because a red
run is then not attributable. Free the peer with its own test-down.sh, or set
PI_HARNESS_ALLOW_OVERSUBSCRIBE=1. The harness emits no committed whole-run
timeout (#450): bound a local run with --global-timeout, never a config edit.
apply marks - [ ] → - [x] and never revisits a checked task, so re-invoking
apply on a red-but-checked test no-ops. On a red test, ship-it drives the
fix itself — edit the code or the test, re-run the harness. Never re-invoke
apply on an already-checked task.
Bound the loop by progress-making cycles, not a fixed count:
No-weakening guardrail (mechanical, enforced every cycle): before accepting a
change to a test file, run assertNoWeakening on its diff
(git diff -- <test-file>). If it reports ok:false (added .only/skip,
deleted assertion, or a strong→permissive matcher swap), REJECT the change —
you may not reach green by degrading the test. Fix the code instead.
Run the enforcers from the worktree root. Each is already the sole owner of its rule; this step only invokes them:
node scripts/check-conventions.mjs --base origin/develop
node scripts/check-plugin-boundary.mjs # core/plugin import ratchet: NEW edge or STALE allowlist row fails
node scripts/check-client-sinks.mjs # raw navigation / HTML / script sinks outside the chokepoints
node scripts/dox-byte-gate.mjs
node scripts/i18n-lint.mjs --strict # --strict, else it exits 0 regardless
node scripts/i18n-parity.mjs
node scripts/knip-config.mjs # knip.json still roots every manifest entry
node scripts/knip-ratchet.mjs # per-class dead-code ratchet (~8s)
node scripts/knip-ratchet.mjs --check-baseline-diff origin/develop # ceiling not raised
node scripts/codeql-local.mjs --check-baseline-diff origin/develop # CodeQL baseline grew only with a reason (static, instant)
The plugin-boundary gate (npm run check:plugin-boundary) fails on a core→plugin
or plugin→plugin edge with no row in scripts/plugin-boundary-allowlist.json
(NEW) and on a row whose edge is gone (STALE). A fix PR deletes the rows it
removes; --write-baseline re-seeds and is a reviewed maintainer step, never a
way to make this check green. A failure routes to the step-4 fix loop.
The knip pair is the preventive half of the dead-code oracle: the nightly
job runs after merge and can only report. Order matters — knip-config.mjs
first, because an unrooted graph reports live files as dead, and a ratchet over
that number gates noise (measured: unrooted 723 findings / 90 unused files vs
rooted 437 / 10). Fix a ratchet failure by deleting the dead code; raising a
baseline is rejected by the third command — which must stay wired, or "never
raise the ceiling" is aspirational: the plain ratchet passes happily against a
raised number. It also rejects a DELETED class, the cheaper bypass.
The CodeQL baseline-diff check is static (no analysis, no CodeQL needed): it
compares codeql-baseline.json with origin/develop's — untriaged never grows,
growth needs a typed reason. A violation here is handled like one in 4.4b's
closing check (below), never by the red-test fix loop. The analysis itself is too
slow for 4.4 and runs in step 4.4b.
They are placed here, after the harness and before the review, because they are deterministic, offline and near-instant: a mechanically-failing tree must never spend a model call. A non-zero exit routes to the step-4 fix loop; step 4.5 does not run.
--base is mandatory for gating: without it the touched set is undefined and
the Discipline-Skills and Mermaid rules report without gating. The touched set
unions the committed diff with the working tree, so fixes still uncommitted in
the fix loop are inspected.
These do NOT move into quality:changed. That script is the dev-loop oracle and
has no automated caller; the ship gate is here.
Runs between 4.4 and 4.5, on every invocation. It analyses a content-addressed
snapshot of the worktree with the pinned query packs (~1.5 min) and compares the
results with the committed codeql-baseline.json. No model call is made here.
A run is interactive exactly when ask_user is available, otherwise headless.
npm run codeql -- --json # exit 0 pass/skipped · 1 new alerts · 2 error
CODEQL SKIPPED: <cause> (no codeql, packs neither cached
nor downloadable) → record the skip in the step report, run the closing check
(step 6 below; static only) and continue. A machine without CodeQL never blocks
shipping — the PR's GitHub analysis is the backstop.staleEntries in the JSON (fewer current results than
recorded) → node scripts/codeql-local.mjs --prune, then
git add codeql-baseline.json so the lowered baseline ships with the change.
--prune exit 1 only means new alerts remain — go on to step 3. Show any
removed github-dismissed entry it prints when asking about its replacement.SHIP_IT_BLOCKED.md listing each new alert
(rule, file, line, message) and how to resolve it: resume ship-it
interactively (the entry gate asks resume/abort, then 4.4b asks per alert), or
re-run npm run codeql, fix or --accept by hand, and delete the report. Exit
non-zero; no ask_user, no 4.5, no ship-change.ask_user per alert (more than 5 → one batch,
one sub-question each): fix, accept with a typed reason
(accepted-risk: …, false-positive: …), and — only for
js/path-injection, js/command-line-injection and
js/shell-command-constructed-from-input — the operator-authz preset, a
template the answer fills in with the gate that bounds this sink:
operator-authz: gate: <symbol> <repo-path>:<line>; <basis> (≤ 236 chars,
gate first). Only git-operations.ts, process-manager.ts and
spawn-preflight.ts may use operator-authz: control-tier: <basis> instead.
No gate bounds the sink → it is a finding, not an operator-authz accept.
codeql-baseline-gates.test.ts enforces the form. The preset is never offered
for any other rule (the argument does not hold for them). Accept with
node scripts/codeql-local.mjs --accept <ruleId> <file> <lineHash> --reason "<reason>"
then git add codeql-baseline.json.
Accepts before fixes within one batch of answers: a fix changes the
snapshot and makes later --accept refuse. Then route the fixes to the step-4
fix loop and re-run 4.4 and 4.4b.Baseline edits go only through --prune and --accept. Never edit
codeql-baseline.json by hand in this step; seeding (--write-baseline) and
--triage are implementation / maintenance steps outside 4.4b.
Runs on every invocation, but only after step 4.4b passes or skips. There is no triviality escape: no diff-size, path,
or changed-file-count condition skips it. A run is interactive exactly when
the ask_user tool is available in the session; otherwise it is headless.
CLI below is npx tsx .pi/skills/ship-it/scripts/review-prompt.ts. Records
live in this invocation's run dir, created once with
RUN=$(CLI --new-run --change <change>) →
$(git rev-parse --git-dir)/ship-it/<change>/<run-id>/ (per worktree, never
committed, <run-id> = invocation start timestamp):
review-r<N>.md (well-formed reply of round N), review-r<N>.attempt-<k>.md
(malformed attempt), fix-ledger-r<N>.json (answers review-r<N>.md),
ledger-failures.log (written by the CLI), approvals.log (one line per human
"one more round" answer — written only right after an ask_user answer).
resolveReviewer from scripts/review-gate.ts.
@review is REQUIRED. Unconfigured → hard fail naming update_roles / the
dashboard Roles panel. There is deliberately no fallback to the session
default model: that model is the author, so falling back turns the gate into
self-review. Interactive runs may offer the bootstrap prompt; a headless run
fails.CLI --state "$RUN" → round,
approvedExtraRounds, malformedRetries, ledgerFailures. Feed exactly
those values (plus interactive and the last round's blocking ids) to
reviewRoundDecision. Never supply a counter from memory; never relabel a
round as round 1 of a new budget.git status --short, then stage the
change's own paths explicitly and commit exactly that list with
git commit -- <paths> (a bare git commit takes everything in the index),
so files already staged before this step stay out; unrelated local edits
(e.g. a worktree-local .pi/settings.json) stay unstaged and never enter
the change. Record the commit as the round's sha.CLI --change <change> --round 1. Round N ≥ 2 (a verification round):
CLI --change <change> --round N --prior "$RUN/review-r<N-1>.md" --ledger "$RUN/fix-ledger-r<N-1>.json" --since <round N-1 sha>.
Pass its stdout to the reviewer verbatim — no added framing, summary, or
claim about the fixes; keep its header line. The generated prompt carries the
review-code rubric, the diff range git diff origin/develop...HEAD
(three-dot, so the step-2.5 merge is not attributed to this change), every
intent artifact present (proposal.md, tasks.md, design.md, delta specs,
test-plan.md), and the defect-class sweep. Known limitation: a verification
round carries each prior B finding up to its first unindented paragraph
(indented continuations are kept) — the price of keeping the prior reply
bounded (#E24); the prompt asks the reviewer to indent continuations.Agent call with model: "@review"
and subagent_type: "CodeReviewer" (the definition in
.pi/agents/CodeReviewer.md disables context inheritance; no other agent
type may be used here). Never an in-context self-review, never the
CodeRabbit CLI (that is 's remote gate, later and different).Every escape decision carries a reason; write it into SHIP_IT_BLOCKED.md
together with the run dir path.
The worktree boundary is not one-way. Trigger the reverse path when ANY of:
apply reports a design issue (NL prose — implementation reveals the design is
wrong), ORescape (including a human choosing
hand back at the cap), ORThen, do NOT headlessly rewrite proposal.md/design.md:
openspec/changes/<change>/SHIP_IT_BLOCKED.md naming the failing
scenario / design gap and what was tried.plan-proposal /
doubt-driven-review on develop.Once every automated scenario is green (harness-verified), ship. Execute
ship-change's procedure inline (not as a black-box subagent) so you keep
step-level control for the teardown ordering below.
Defer rule (deferDecision, manifest-aware):
test-plan.md exists → a leftover - [ ] is deferrable only if it maps to a
manual-only manifest row (inline (test-plan: manual-only) or a
(test-plan #<id>) reference resolved against the manifest). Any other leftover
= real work = STOP (return to step 2, or the escape hatch).test-plan.md absent (legacy change) → ship-change's current keyword defer
applies unchanged.Archive+sync gate before the destructive steps (load-bearing): do not let
ship-change merge the PR, delete the branch, or remove the worktree while the
proposal is not archived and specs are not synced. ship-change step 8.5 is that
hard gate — driving ship-change inline, hold at step 8.5 until the change is
archived (source dir moved to openspec/changes/archive/, move committed) and
specs synced. Failed/skipped archive → STOP (return to step 2 or the escape hatch),
never proceed to steps 9/10.
Teardown-before-removal ordering (load-bearing): the harness MUST be torn down
(test-down.sh, already wired via the step-3 trap) before ship-change step
10 removes the worktree. A leaked container makes the worktree "busy" and stalls
removal. Run the harness teardown, then let ship-change archive → commit → PR →
CI → CodeRabbit → (archive+sync gate) → squash-merge → remove worktree.
CI watching is fail-fast (ship-change step 6): never block on
gh pr checks --watch until every job ends. Poll in short bounded calls; the
moment any check reports fail, diagnose it while the remaining jobs keep
running, and batch the round's failures into one push.
ask_userEvery ask_user call this skill makes MUST carry a self-contained situation
brief in its message — at least 240 characters (the dashboard's
questions.minBriefChars default; shorter and the server generates a brief with
the @fast model instead). The answer may be given from the global question
stack by someone who has not seen this chat. State, in 2–4 lines:
A bare question ("Resume or hand back?") is never enough. See change:
add-pending-question-stack.
- [x] is never proof; the
test file must exist and pass in the harness.apply on a checked task.assertNoWeakening rejects it.codeql-baseline.json except through
--prune / --accept, never routes a baseline-diff violation or a script
error to the red-test fix loop, and a headless run never grows the baseline
(--no-growth).@review is
required; never fall back to the session default model (that is self-review).ask_user, recorded in approvals.log) adds a round — exactly
+1 round per human approval. The orchestrator never renews its own
budget: no self-reset, no "fresh two-round budget", no relabelled round.
Headless runs and hand-backs take the boundary-reverse (step-5) escape hatch.review-prompt.ts output, passed
verbatim to subagent_type: "CodeReviewer"; never hand-written, never
carrying the author's conclusions.SHIP_IT_BLOCKED.md at entry stops the run — headless exits non-zero;
interactive asks resume/abort.develop before the harness (step 2.5) — the strong gate validates
the integrated tree T1; merge origin/develop (remote ref), never rebase.
Conflict → abort + STOP, never enter the harness on a half-merged tree.ship-change step 8.5 (archive+sync gate) until it passes; failed archive → STOP.:18000 — read dashboardPort from .openspec-apply-change · docker/test-up.sh + lib-ports.sh + test-down.sh ·
review-code (its rubric is what the step-4.5 reviewer applies) ·
ship-change (driven inline, manifest-aware defer). Handoff back to
plan-proposal via SHIP_IT_BLOCKED.md.
Worktree-side implementation orchestrator for an OpenSpec change. Idempotent: gates automated scenarios on filesystem reality, owns the red-test fix loop, runs the docker harness with always-teardown,
---name: ship-itdescription: Worktree-side implementation orchestrator for an OpenSpec change. Idempotent: gates automated scenarios on…---# .pi/skills/ship-it/SKILL.mdRingkasan umum
Worktree-side implementation orchestrator for an OpenSpec change. Idempotent: gates automated scenarios on filesystem reality, owns the red-test fix loop, runs the docker harness with always-teardown, then drives ship-change inline. Escape hatch writes SHIP_IT_BLOCKED.md. Runnable headless. Triggers: "ship it", "build and ship this change", "run ship-it", "implement + test + land in the worktree".
FAQ
Unduh .pi/skills/ship-it/SKILL.md dari penerbit, atau salin path-nya dan buka repositori. PlugMCP hanya mendaftar skill ini dan tidak meng-host filenya.
Penerbit menyimpannya di https://github.com/BlackBeltTechnology/pi-agent-dashboard.
Claude, Cursor, Codex, dan Grok Build bisa membaca SKILL.md yang Anda tambahkan dari repositori penerbit. Grok Bot memasangnya saat Anda mengirim tautan folder GitHub skill tersebut di chat.
ask_userSHIP_IT_BLOCKED.mdnode scripts/codeql-local.mjs --check-baseline-diff origin/develop
(add --no-growth when headless, so a headless run never grows the baseline).
Exit 0 → continue to 4.5. Exit 1/2 → interactive: show the violation, ask_user
revert / abort; headless: write SHIP_IT_BLOCKED.md naming the entry. A
baseline-diff violation (here or in step 4.4) never enters the red-test fix
loop.ship-changeREVIEW_TIMEOUT_MS (300s). A timeout is neither a pass
nor a blocking finding — it is a checkpoint failure.parseReviewReply. Well-formed → save it as
$RUN/review-r<N>.md. Malformed (empty, no or duplicate
BLOCKING_COUNT/VERDICT line, or self-contradictory) → save it as
$RUN/review-r<N>.attempt-<k>.md; it is never a pass and never a round.
Retry once: re-invoke the same round; a second malformed reply halts like
a timeout. A missing sweep table is noted in the round record and the step
report, not a failure.issue(blocking) (B<n> ids) re-enters the fix
loop. Everything else is reported and shipped.B id (the review-code fix protocol): reproducing
test first (or a ≥20-char reason no automated test can observe it) →
smallest fix → sibling sweep of the same pattern across the change → re-read
the fix hunk against the finding's defect class. After each review fix,
re-run the harness (step 3) and the step-4.4 enforcers before anything
else; a failure re-enters the fix loop first.$RUN/fix-ledger-r<N>.json, one entry per B id — { id, test: {path} | {untestable}, siblings: {searched, sites}, fixedIn }, no status field, no
verdict language. Then
CLI --validate-ledger --prior "$RUN/review-r<N>.md" --ledger "$RUN/fix-ledger-r<N>.json".
Non-zero → complete the listed entries (each failure is recorded; the third
for a round routes as unsatisfiable). An entry the fix loop cannot complete
→ unsatisfiable. No verification round while validation fails.reviewRoundDecision. The base cap is two rounds —
review, fix, re-review. This is a hard numeric cap, NOT step 4's
no-progress rule, because a reviewer can emit a fresh finding every round
and each fix changes the worktree, so a no-progress bound would never fire.
review → next round (step 3).proceed → step 6.ask (interactive, cap reached) → one ask_user select naming the
remaining B ids: one more verification round / hand back to
planning. One more → append one line to $RUN/approvals.log and record
the answer in the round file, then run exactly one verification round.
Hand back → escape hatch. If the ask_user call fails, treat the run as
headless and take the escape hatch.escape → the boundary-reverse (step-5) escape hatch.assertNoWeakening still governs every test edit a review fix makes. A
finding that can only be satisfied by weakening a test is unsatisfiable →
escape hatch (step 5), naming both the finding and the guardrail. The
guardrail is never relaxed to reach green..pi-test-harness.json