ruvnet-brain 3.9.134-dev → 4.0.2

package/plugin/skills/brain-build/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: brain-build
+description: The autonomous build contract, out of the box — "/brain-build <what you want>" activates the disciplined hands-off build power users used to hand-write a standing prompt for. Use when the user says "/brain-build", "brain build", "build this autonomously", "build this hands-off", "loop until it's done", "don't ask me, just build it", or asks for an unattended/self-grading build. Phase-gated per rUv's SPARC, self-verified and self-graded /100 against a per-phase rubric (below 95 → fix and regrade, max 5 iterations), cost-tier routed with printed receipts, crash-resumable via checkpoints, questions batched into one list — the user writes the goal, not the contract.
+updated: 2026-07-10
+---
+
+<!-- Credit: this contract productizes a community field pattern — the 7-rule standing prompt
+     hand-written by the PR #8 contributor (Eva Draganova, 2026-07-10) to force the brain into
+     disciplined autonomous building. Her forcing insight: "grade 1-100, no pass under 95 →
+     forced it to loop and improve." All the machinery existed; this skill removes the 40
+     hand-written lines needed to activate it. -->
+
+# Brain-Build — the standing contract, activated by one line
+
+`/brain-build <what you want>` means: no human is watching until it's done. Run the whole build
+under the contract below. The AUTONOMOUS MODE rules injected by the grounding hook
+(`plugin/scripts/ground-ruvnet.sh`) apply in full — this skill carries them even on turns where
+that hook doesn't fire.
+
+## 1. Phases — rUv's SPARC, with a rubric per phase
+
+Structure the build as the five SPARC phases with a quality gate between each — rUv's own
+convention (phases + gates: `concepts/sparc/CARD/sparc-card`; per-phase docs:
+`sparc/specification/README.md`). Gate criteria follow rUv's ruflo-sparc gate checks
+(`ruflo/plugins/ruflo-sparc/commands/ruflo-sparc.md`):
+
+| Phase | Rubric (the /100 grade is against THIS) |
+|---|---|
+| **S** Specification | Requirements complete; ≥3 acceptance criteria; constraints explicit; edge cases identified. |
+| **P** Pseudocode | Design covers every acceptance criterion; error paths explicit; complexity annotated. |
+| **A** Architecture | Every constraint addressed; API contracts typed; no circular dependencies; every stack decision grounded (rule 4). |
+| **R** Refinement | Every acceptance criterion has a passing test; suite green; coverage adequate; self-review clean. |
+| **C** Completion | All tests green; docs match the code; deploy checklist verified; traceability criterion→test. |
+
+Scale the ceremony to the build (a small feature gets a light S and P), never skip a gate.
+
+## 2. LOOP, DON'T ASK — the ≥95 gate
+
+At each phase gate:
+
+1. **Self-verify with real instruments** — run the tests, curl the endpoint, screenshot the UI,
+   execute the quickstart. Evidence, never opinion.
+2. **Grade /100 against the phase rubric, under the brain-score rules** (see the `brain-score`
+   skill): every deduction cites evidence (file:line, command + output); a known architectural
+   flaw caps the grade at ≤70 no matter what else works; a "what I did NOT test" section is
+   mandatory; when in doubt, score lower.
+3. **Below 95 → fix the cited deductions and regrade.** Loop. **Maximum of 5 iterations per
+   phase** — if the 5th grade is still <95, stop the phase and report: the score, the remaining
+   evidence-cited deductions, and the ONE item blocking ≥95.
+4. **Report only the final result**: final score, what was fixed across iterations, and the proof
+   (the command output / artifact). Never narrate intermediate grades or ask "should I keep going?"
+
+## 3. AUTO-ADVANCE on gate pass
+
+Gate ≥95 → **commit the phase** (one commit per phase, message names the phase and score) and
+advance immediately — no permission round-trip. **Push only if the user's repo conventions allow**
+(they asked for pushes, or the workflow demonstrably expects them); otherwise commit locally and
+note the unpushed state in the final report. Production deploys, npm publish, force-push, history
+rewrites, secrets: NEVER — do everything up to that fence and name the exact click a human owes.
+
+## 4. GROUND every stack decision + the "what did I miss?" pass
+
+Every stack/tool/library decision goes through `search_ruvnet` first, and the decision cites the
+returned repo/path. Close **every phase** with one more brain pass: a `search_ruvnet` query
+describing what the phase just built ("what did I miss?"), checking for a sharper rUv primitive or
+prior art the phase overlooked. A hit worth acting on goes into the next iteration; no hit costs
+one line: "brain pass clean."
+
+## 5. PROTECT-MY-MONEY — the tier ladder
+
+- **Mechanical / plumbing text work** (summaries, classification, research digests, boilerplate
+  transforms) → route cheap via `node scripts/route-cheap.mjs --task "<task>"` (or agentic-flow
+  directly). It prints its receipt line — "⚡ MetaHarness: routed to <model> (est. $X vs $Y
+  frontier — saved ~$Z)" — and logs to `~/.claude/metaharness/routing-receipts.jsonl`. No
+  OPENROUTER_API_KEY → say so once and stay on Claude tiers; never silently pretend to route.
+- **Frontier ONLY for the authoritative gate run** — the grade that decides advancement — and for
+  architecture / security / irreversible calls. Iteration drudge work rides the cheap tier.
+- **Any operation projected >$1 or >20 paid calls → state the estimate and WAIT.** This is one of
+  the only legitimate stops in autonomous mode.
+- **Long runs print running spend** from the receipts log: `node scripts/metaharness-receipts.mjs`
+  — one line per phase gate, cumulative.
+
+## 6. BATCH questions — never block on one
+
+A question that isn't a hard blocker gets parked, and work continues on everything unblocked.
+Deliver **ONE list** at the phase gate (or the end), each question with a **recommended default**
+the user can accept with a single "defaults fine." Only a genuine hard blocker — cannot proceed
+AND >$1/irreversible — interrupts mid-phase.
+
+## 7. READY discipline
+
+Say "READY" / "done" / "deployed" **only after self-verifying the deployed or running version** —
+curl the live URL, run the installed CLI, load the real page. The real door, not an adjacent one.
+If a deploy is in flight, say exactly that: "deploy in flight — verifying before I call it READY."
+
+## 8. Interrupts
+
+- User says **"status"** → reply with ONLY a table: `done / in-flight / blocked-on-me / parked`.
+  No prose before or after.
+- **Mid-build ideas** from the user → add to the PARKED table with a one-line feasibility read and
+  keep building — unless they say "now", which reprioritizes immediately.
+
+## 9. Crash-resumable state — `scripts/loop-checkpoint.mjs`
+
+The checkpoint is the loop's spine (contract in the script header):
+
+- **Read FIRST** every iteration: `node scripts/loop-checkpoint.mjs read` — if a checkpoint
+  exists, resume from its `next`; never re-derive the plan, never repeat completed phases.
+- **Iteration 1 only**: declare done-criteria as a SHELL COMMAND and write it to the checkpoint —
+  done is an **exit code, not an opinion**.
+- **Write LAST** every iteration:
+  `node scripts/loop-checkpoint.mjs write --iteration N --done-criteria "<cmd>" --next "<one action>" --blockers "<or empty>"`
+- **Then check**: exit 3 = DONE (stop, final report); exit 4 = NO-PROGRESS (two strikes on an
+  unchanged `next`: stop, name what's stuck and the ONE thing that would unstick it).
+
+Record assumptions made under rule 2 ("cheapest-to-reverse interpretation") in the checkpoint's
+`blockers`/`next` so a resumed run inherits them.
+
+## Final report shape
+
+Goal → per-phase table (phase, final score, iterations used, what was fixed) → proof artifacts
+(commands + outputs) → "what I did NOT test" → spend summary from the receipts log → parked
+items + the batched question list with defaults.

package/plugin/skills/brain-console/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: brain-console
+description: Open the RuvNet Brain Console for "/rvbc", "/rvcb", "/brain-console", or "/ruvnet-brain:configure". Use when the user asks to open, configure, inspect, or view the Brain Console. It opens the live local page in the background; the page is read-only until the user clicks a clearly explained, reversible action.
+updated: 2026-07-28
+---
+
+# Brain Console
+
+Treat `/rvbc`, `/rvcb`, `/brain-console`, and `/ruvnet-brain:configure` as equally valid names.
+Never correct the user's spelling.
+
+1. Say one short sentence: "Opening it now; it scans live while you watch."
+2. Resolve the installed runtime at
+   `${RUVNET_BRAIN_KB:-$HOME/.cache/ruvnet-brain/kb}/.console-runtime/scripts/onboarding-console.mjs`.
+   A current-repository `scripts/onboarding-console.mjs` is allowed only for an explicit developer
+   checkout. Never fall back to a guessed `~/Code` path.
+3. Run `node <resolved-script> --serve --open` in the background.
+4. Give the URL immediately. Do not promise a duration; the page reports its own scan progress.
+
+An already-running server is success. The Console is read-only until the user chooses an action;
+every change must be explained and reversible. If the script cannot be located or the server fails,
+report the exact failure plainly instead of claiming the Console opened.

package/plugin/skills/brain-prompt/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: brain-prompt
+description: Metaprompting assistant — "/brain-prompt <rough idea>" turns a rough ask into "the right prompt": a complete, tuned master prompt with SPARC phases, per-phase rubrics, standing rules, and cost guardrails, ready to paste or run. Use when the user says "/brain-prompt", "brain prompt", "write me the right prompt for this", "turn this idea into a proper prompt", "metaprompt this", "what should I actually ask for", or hands over a vague one-liner they want expanded into a disciplined build brief. Ends by offering to execute the produced prompt with /brain-build semantics.
+updated: 2026-07-10
+---
+
+<!-- Credit: this pattern productizes community field use — the PR #8 contributor's standing
+     prompt (Eva Draganova, 2026-07-10): power users were hand-writing the phase/rubric/guardrail
+     contract around every rough ask. This skill writes that contract FOR them. -->
+
+# Brain-Prompt — from rough idea to the right prompt
+
+You are not completing the task here — you are writing the instructions for completing it. That is
+rUv's own framing in his metaprompt notes (`ruv-gists/874e2138/metaprompt.txt`,
+`ruv-gists/5dd85664/metaprompt.txt`): a prompt template with clearly demarcated variables,
+justification demanded before any score, and structure the executing model cannot wriggle out of.
+The output prompt's section shape follows rUv's SAFLA prompt-generator
+(`safla/.roo-orginal/rules-prompt-generator/rules.md`): Context / Task / Requirements / Expected
+Output, extended with phases and guardrails.
+
+## Procedure
+
+### 1. Interrogate the rough ask — silently, against a checklist
+
+Enumerate what's underspecified: **users** (who is this for?), **data** (what exists, what shape,
+how much?), **scale** (10 users or 10M?), **platform** (web/CLI/mobile? deploy target?),
+**constraints** (budget, stack, deadline, compliance), **done** (what observable behavior ends
+this?). Then:
+
+- **Infer defaults — do not interrogate the human.** For everything you can reasonably default
+  (from their repo, their stack, the obvious reading), pick the default and write it into the
+  prompt's ASSUMPTIONS block where they can veto it by editing one line.
+- **Batch the few questions that genuinely need a human** — ambiguous product intent, money,
+  irreversible choices — into ONE list, each with a recommended default. Never a
+  twenty-questions interview; usually the list is 0–3 items.
+
+### 2. Ground the stack via search_ruvnet
+
+Call `search_ruvnet` with queries describing what the build technically DOES. Which rUv tools fit
+— vectors → RuVector/RVF, orchestration → ruflo, QE → agentic-qe, memory → AgentDB, methodology →
+SPARC (`sparc/specification/README.md`)? **Cite the returned repo/path next to every tool the
+prompt prescribes.** A prompt that names tools without citations is a guess wearing a suit — don't
+ship it. No tool fits → the STACK section says so plainly rather than forcing a tie-in.
+
+### 3. Output the master prompt — Eva's shape
+
+Produce ONE complete, paste-ready prompt with exactly these sections:
+
+```
+GOAL         — the ask, sharpened to one testable sentence.
+ASSUMPTIONS  — every inferred default, one line each (veto by editing).
+STACK        — tools/libraries, each with its grounded citation (repo/path).
+PHASES       — SPARC (Specification → Pseudocode → Architecture → Refinement → Completion,
+               per concepts/sparc/CARD/sparc-card), a rubric per phase, and a GATE per phase.
+STANDING RULES — loop-don't-ask: self-verify, grade /100 against the phase rubric with
+               evidence-cited deductions, below 95 → fix and regrade, max 5 iterations,
+               report only the final score + fixes + proof; batch questions into ONE list
+               with defaults; READY only after verifying the deployed/running version;
+               "status" → table only.
+COST GUARDRAILS — tier ladder (mechanical work → cheap model via scripts/route-cheap.mjs with
+               its printed receipt; frontier only for the authoritative gate run); any
+               operation projected >$1 or >20 paid calls → state estimate and wait;
+               print running spend during long runs.
+DONE CRITERIA — shell commands, one per phase gate plus one overall.
+```
+
+**Every gate must be verifiable: done = exit code, not opinion.** A rubric line the executing
+model could grade by vibes ("code is clean") must be paired with a command that can fail
+(`npm test`, `curl -sf <url>`, `node scripts/loop-checkpoint.mjs check`). If you can't name the
+command, the criterion isn't done yet — sharpen it until you can. Long/unattended prompts should
+carry the checkpoint contract too (`scripts/loop-checkpoint.mjs`: read first, write last,
+done-criteria as the shell command).
+
+Prompt-craft rules from rUv's metaprompt notes (cited above): demarcate user-supplied variables
+with XML tags; when the prompt asks the executing model for a score, demand the justification
+BEFORE the score; give complex tasks a scratchpad step before the final answer.
+
+### 4. Offer execution
+
+End with exactly one question: **"Run this now with /brain-build semantics?"** On yes, execute
+the produced prompt under the full brain-build contract (see the `brain-build` skill) — phases,
+≥95 gates, cost ladder, checkpoints — starting immediately, no re-confirmation. On no, they walk
+away with the prompt; it must stand alone.

package/plugin/skills/brain-score/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: brain-score
+description: Score ANY repository 0-100 across 8 dimensions using the exact evidence-or-it-didn't-happen scorecard RuvNet-Brain applies to itself. Use when the user says "score this repo", "score my repo", "scorecard", "brain-score", "how good is this codebase", "rate this project", "audit quality", or asks for an honest 0-100 quality assessment of a repository. Every deduction must cite evidence from the actual repo; a known architectural flaw caps its dimension at ≤70; a "what I did NOT test" section is mandatory; all scores are out of 100, never out of 10.
+updated: 2026-07-10
+---
+
+# Brain-Score — the 8-dimension repo scorecard (0–100)
+
+Score the repo in front of you the way RuvNet-Brain scores itself: **gates that could have failed,
+before scores that can be believed.** A score is only real if the evidence behind it was collected
+by running real commands against the actual repo — never from memory, never from vibes, never from
+what the README promises.
+
+These same rules are the phase-gate grader inside `/brain-build` (the autonomous build contract:
+loop each phase to ≥95 under brain-score rules, max 5 iterations — see the `brain-build` skill).
+
+## Non-negotiable scoring rules
+
+1. **Every deduction cites evidence.** Each point lost names the file/line, the command you ran and
+   its output, or the artifact you inspected. "Feels incomplete" is not a deduction; `"tests/ has 3
+   files, 2 contain zero assertions (tests/foo.test.js:1-40)"` is.
+2. **A known architectural flaw caps its dimension at ≤70** — no matter how much else in that
+   dimension works. (Example: a quality gate whose sample size cannot statistically detect the
+   regression it exists to catch caps reliability at 70, even with green CI.)
+3. **A mandatory "What I did NOT test" section.** List every claim you could not verify (didn't run
+   the app, didn't have the API key, skipped the 40-minute suite, couldn't reach the deployed URL).
+   A scorecard without this section is invalid — do not present one.
+4. **Scores are /100, never /10.** Per dimension and overall. Overall = the mean of the 8
+   dimensions, reported alongside the lowest dimension (a 95 average hiding a 40 is the headline).
+5. **When in doubt, score lower.** Unverified ≠ working.
+
+## The 8 dimensions
+
+| # | Dimension | What the evidence looks like |
+|---|---|---|
+| 1 | **Correctness-evidence** | Do claims trace to proof? Run the build/tests yourself; diff README claims against actual behavior; look for "verified" claims with no artifact behind them. |
+| 2 | **Test honesty** | Not coverage %, honesty: do tests assert anything? Can the suite fail? Any skipped/todo masquerading as green? Does a missing dependency SKIP loudly or pass silently? |
+| 3 | **Docs truthfulness** | Do docs describe the code that exists today? Stale install commands, APIs that 404, ADRs/status docs contradicting the source. Run the quickstart literally. |
+| 4 | **Security posture** | Secrets in tree, dependency audit (`npm audit` / `cargo audit` / `pip-audit`), input handling at trust boundaries, unsigned auto-update/exec paths, injection surfaces. |
+| 5 | **Token/cost efficiency** | For AI-touching repos: what is injected/spent per operation, and is it measured at all? For others: hot-path waste, N+1s, unbounded loops. "Nothing measures spend" is itself a deduction. |
+| 6 | **Reliability/CI** | Does CI exist, run, and gate merges? Was it red while people kept pushing? Flaky tests, non-required checks, error handling on the paths that actually fail. |
+| 7 | **Maintainability** | Duplication, dead code, module boundaries, dependency freshness, whether a newcomer could change one thing without breaking three. |
+| 8 | **User experience** | The consumer's first contact: install-to-working time, error messages, defaults, docs entry path. For libraries: the API surface. Run the first-run flow yourself. |
+
+## Procedure
+
+1. **Collect receipts mechanically** (never from memory): run the test suite, the linter, the
+   dependency audit; read CI config + recent run results if reachable; run the documented
+   quickstart; grep for TODO/FIXME/skip; check the license, the lockfile, the entry docs.
+2. **Use the real instruments when they're wired** (see honesty table below):
+   - **ruflo MCP present** → call `metaharness_score` (5-dim harness readiness incl.
+     `estCostPerRunUsd`) and `metaharness_oia_audit`. Both are READ-layer: **free, no API key, work
+     on any repo.** Fold their findings into dimensions 5–6 as cited evidence — they complement the
+     8 dimensions, they don't replace them.
+   - **agentic-qe present** (`aqe` / aqe-mcp) → `coverage_analyze_sublinear` for dimension 2,
+     `security_scan_comprehensive` for dimension 4, `test_generate_enhanced` to probe untested
+     paths. **WARNING: `qe_qx_analyze` hallucinates on remote URLs** — it has returned templated
+     grades in ~2ms with every claim false. Never relay its output on a URL or artifact without
+     verifying against the real thing yourself first.
+   - **Neither installed** → plain repo inspection is fully valid: read the code, run the
+     commands, cite what you saw. Offer to install the tools (`npm i -g agentic-qe@latest`), but
+     never block scoring on them and never fake their output.
+3. **Score each dimension /100** with a deduction+evidence line per point cluster lost. Apply the
+   ≤70 cap where an architectural flaw exists, and say which flaw triggered it.
+4. **Write "What I did NOT test."** Then the overall (mean + lowest dimension).
+5. If this repo has persistent memory (AgentDB / `.swarm/memory.db`), store the scorecard under
+   key `scorecard-YYYY-MM-DD` so the next score can show movement.
+
+## Output format
+
+```
+# Brain-Score: <repo> — <date>
+Overall: NN/100 (mean of 8) · lowest: <dimension> at NN
+
+| Dimension | /100 | Cap applied? |
+|---|---|---|
+...8 rows...
+
+## Deductions (every point lost, with evidence)
+- <dimension> −N: <claim> — evidence: <file:line / command + output>
+...
+
+## What I did NOT test
+- ...
+
+## Instruments used
+- metaharness_score / oia_audit: <used | not wired — plain inspection> 
+- agentic-qe: <used (which tools) | not wired>
+```
+
+## What's on by default vs what needs a key (say this honestly, never oversell)
+
+| Capability | Status |
+|---|---|
+| `metaharness_score` + `metaharness_oia_audit` (READ layer) | **Free, on by default** in any repo when the ruflo MCP is installed — no API key. |
+| agentic-qe test/coverage/security tools | **Free, on demand** when agentic-qe is installed (`npm i -g agentic-qe@latest`); `qe_qx_analyze` output must be verified against the real artifact. |
+| `metaharness_evolve` (WRITE layer — self-improves the harness, keeps only measured winners) | **Needs `OPENROUTER_API_KEY`** + a runnable test command. Without the key: say so and offer the free READ layer instead. |
+| Automatic per-task cheap-model routing | Goes through **agentic-flow `--router-mode cost-optimized`** — needs `OPENROUTER_API_KEY`. Claude-tier routing via `hooks_model-route` is free. |
+
+Never claim the evolve loop or cheap routing "just works" when the key isn't set — check
+(`printenv OPENROUTER_API_KEY` is empty?) and state which side of the line each feature is on.

package/plugin/skills/release-proof/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: release-proof
+description: Fail-closed exact-artifact release and deployment authority. Use before saying a release is ready, pushing a release commit, publishing npm packages, creating GitHub releases, deploying production, closing release-blocking issues, or claiming all gates are green. Requires clean immutable lineage, zero open issues, exact-SHA GitHub success, nonzero no-skip QE, packed-artifact host tests, installed Brain/RVF proof, independent graders, and post-publication byte verification.
+---
+
+# Release Proof
+
+Treat release as a two-seal transaction. Never publish from a source checkout merely because its
+tests pass. Never turn `UNKNOWN`, `SKIP`, `todo`, `0 tests`, dirty state, or an agent report into
+green.
+
+## Non-bypassable rules
+
+1. Use the exact source SHA and one packed-artifact SHA-256 everywhere.
+2. Require zero open GitHub issues for RuvNet Brain. A local fix is not a closed issue.
+3. Require every named GitHub workflow to complete successfully on the exact candidate SHA.
+4. Reject any test/QE result with zero tests, skips, todos, unknowns, pending jobs, or failures.
+5. Require two distinct independent graders scoring at least 95, each bound to the SHA and digest.
+6. Install the sealed artifact into virgin Claude Code and Codex homes; test their real entrypoints.
+7. Require the active Brain registry to contain the `ruvnet-brain` RVF store and require narrow,
+   broad, and concurrent cited searches to complete within 80% of their deadline.
+8. Publish only through the protected release workflow. Never run `npm publish` or `gh release
+   create` locally.
+9. After publication, download npm and GitHub artifacts, compare their bytes with the seal, install
+   both hosts again, query the active MCP again, and require `published-surface-probe` green.
+10. Close an issue only after posting its acceptance evidence. Never close from source inspection.
+
+## Candidate seal
+
+Generate the receipt from commands in the protected candidate workflow. Do not hand-author it.
+Validate it from the repository with:
+
+```bash
+node scripts/release-proof.mjs --candidate release-evidence/candidate-receipt.json
+```
+
+From an installed Claude plugin, run:
+
+```bash
+node "$CLAUDE_PLUGIN_ROOT/skills/release-proof/scripts/release-proof.mjs" \
+  --candidate release-evidence/candidate-receipt.json
+```
+
+Exit 0 is the only candidate seal. Read every failure code; repair the system, regenerate evidence,
+and rerun. Do not edit the receipt to remove a failure.
+
+## Publication seal
+
+After the protected publisher completes, validate both receipts:
+
+```bash
+node scripts/release-proof.mjs \
+  --candidate release-evidence/candidate-receipt.json \
+  --publication release-evidence/publication-receipt.json
+```
+
+Only exit 0 permits “shipped,” “deployed,” “green,” or “ready.” If publication occurred but this
+seal fails, say `PUBLICATION DEGRADED`, preserve the previous known-good release, and repair or
+roll back through the release workflow.
+
+## Evidence and issue handling
+
+For each issue:
+
+1. Reproduce the original symptom against the old/public artifact.
+2. Run its acceptance criteria against the sealed candidate.
+3. Disable or mutate the fix; the regression must fail.
+4. Post SHA, artifact digest, commands, results, and untested limits to the issue.
+5. Close only after the GitHub evidence is visible and exact-SHA required checks are green.
+
+Read [references/receipt-contract.md](references/receipt-contract.md) for receipt fields and failure
+semantics. Store the protocol and final release receipt in Ruflo/AgentDB only after the publication
+seal passes.
+
+## Status language
+
+- Candidate seal absent or failed: `NOT READY`.
+- Candidate sealed, not published: `SEALED, NOT SHIPPED`.
+- Published, publication seal pending: `PUBLISHED, NOT VERIFIED`.
+- Publication seal failed: `PUBLICATION DEGRADED`.
+- Both seals exit 0: `SHIPPED AND VERIFIED`.

package/plugin/skills/release-proof/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Release Proof"
+  short_description: "Fail-closed exact-artifact release authority"
+  default_prompt: "Prove this release candidate end to end and refuse publication unless every required gate is green."

package/plugin/skills/release-proof/references/receipt-contract.md

@@ -0,0 +1,38 @@
+# Receipt contract
+
+The authority accepts schema version 1 JSON. Receipts are append-only evidence artifacts generated
+by protected workflows, never editable status documents.
+
+## Candidate receipt
+
+Required bindings:
+
+- `sha`, `tree`, `dirty:false`
+- `artifact.path`, `artifact.sha256`, `artifact.sourceSha`
+- exact-SHA release-vector verdict with zero unknown/skipped
+- aggregate tests with nonzero total, all passed, zero failed/skipped/todo
+- fresh coverage floor and zero critical/high security findings
+- zero open GitHub issues
+- required GitHub workflow results on the same SHA
+- virgin-home Claude and Codex results on the same artifact digest
+- installed Brain self-RVF plus narrow, broad, and concurrent cited search timings
+- nonzero Agentic QE totals with zero failed/skipped
+- two distinct independent grader receipts at 95 or higher, bound to SHA and digest
+
+## Publication receipt
+
+Required bindings:
+
+- candidate SHA and artifact digest
+- npm and GitHub release bytes matching the candidate digest
+- clean installed Claude and Codex results from the public package
+- installed Brain self-RVF and broad search within 80 percent of deadline
+- successful exact-SHA `published-surface-probe`
+
+## Failure semantics
+
+Any missing field, malformed digest, mismatched SHA, dirty tree, open issue, absent/pending/red
+workflow, skipped/todo/zero-test result, missing RVF store, uncited search, deadline-margin breach,
+low/missing grader, or public byte mismatch is `FAIL`. There is no warning state and no score
+average. The authority never publishes; publication belongs to the protected workflow after the
+candidate seal.