ruvnet-brain 4.0.1 → 4.0.4

package/plugin/scripts/whats-new.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Installed What's New boundary. The executable, manifest and curated notes live in the same
+// immutable plugin payload, so a Stable Spine generation can never report another version's notes.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const pluginRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const notesPath = path.join(pluginRoot, 'docs', 'RELEASE-NOTES-4.0.md');
+const manifestCandidates = [
+  path.join(pluginRoot, '.codex-plugin', 'plugin.json'),
+  path.join(pluginRoot, '.claude-plugin', 'plugin.json'),
+];
+
+function fail(message) {
+  process.stderr.write(`RuvNet Brain What's New failed: ${message}\n`);
+  process.exitCode = 1;
+}
+
+let manifest = null;
+for (const candidate of manifestCandidates) {
+  try {
+    manifest = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+    if (manifest?.version) break;
+  } catch { /* try the other installed host manifest */ }
+}
+
+if (!manifest?.version) {
+  fail(`installed version metadata is missing from ${pluginRoot}`);
+} else if (!fs.existsSync(notesPath)) {
+  fail(`installed release notes are missing at ${notesPath}`);
+} else {
+  let notes = '';
+  try { notes = fs.readFileSync(notesPath, 'utf8'); }
+  catch (error) { fail(`installed release notes could not be read at ${notesPath}: ${error.message}`); }
+  if (notes) {
+    process.stdout.write(`RuvNet Brain ${manifest.version}\n\n`);
+    process.stdout.write(notes);
+    if (!notes.endsWith('\n')) process.stdout.write('\n');
+  }
+}

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

@@ -10,8 +10,10 @@ Treat `/rvbc`, `/rvcb`, `/brain-console`, and `/ruvnet-brain:configure` as equal
 Never correct the user's spelling.
 
 1. Say one short sentence: "Opening it now; it scans live while you watch."
-2. Locate `scripts/onboarding-console.mjs` from the current repository. If it is not present,
-   check `~/Code/ruvnet-brain/scripts/onboarding-console.mjs`. Do not invent another path.
+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.
 

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

@@ -0,0 +1,98 @@
+---
+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 source package, Claude manifest, Codex manifest, packed npm version, bundle
+   `brainVersion`/`releaseTag`, and both installed host versions to identify one exact generation.
+8. 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.
+9. Publish only through the protected release workflow. Never run `npm publish` or `gh release
+   create` locally.
+10. 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.
+11. 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.
+For generation 4.0.4, dispatch `.github/workflows/protected-release.yml` only with the full candidate
+SHA, sealed artifact SHA-256, exact version `4.0.4`, and the successful exact-SHA CI run ID whose
+named `release-qe` job produced `release-evidence-<sha>`. The workflow checks every binding before
+creating its sealed handoff and again after the production reviewer approves. Missing artifacts,
+pending/red jobs, malformed inputs, version splits, and byte mismatches stop before the publisher.
+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.
+
+`scripts/release.mjs --publish` is intentionally unusable from a local shell or another workflow.
+Its invocation guard requires GitHub Actions workflow `protected-release`, the candidate receipt,
+and matching SHA/digest/version bindings before any push, tag, release, or npm action. The workflow
+then runs `scripts/publication-receipt.mjs` after channel verification. That producer independently
+downloads the sealed package from npm and the GitHub Release, requires both copies to match the
+candidate bytes and identity, installs the npm copy into virgin Claude and Codex homes, proves the
+installed self-RVF/readiness/search deadline, and runs `published-surface-probe` on the candidate
+SHA. It refuses to overwrite an existing receipt. The workflow uploads both append-only receipts
+only after the two-receipt validator exits 0; missing evidence is red, never inferred.
+
+## 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,44 @@
+# 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`
+- `version`, `tag`, and exact-equal `sourceVersions.package`, `sourceVersions.claudePlugin`, and
+  `sourceVersions.codexPlugin`
+- `artifact.path`, `artifact.sha256`, `artifact.sourceSha`
+- exact-equal `artifact.version`, `artifact.bundle.brainVersion`, and
+  `artifact.bundle.releaseTag`
+- 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 and exact candidate version
+- 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
+- candidate `version` plus exact-equal npm version, GitHub tag, bundle `brainVersion`/`releaseTag`,
+  and installed Claude/Codex versions
+- 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, split version identity, 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.

package/plugin/skills/release-proof/scripts/release-proof.mjs

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+// Fail-closed release authority. It validates evidence bound to one clean source SHA and one
+// packed-artifact digest. It never publishes and never converts UNKNOWN/SKIP/zero work into PASS.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+export const REQUIRED_CHECKS = ['ci', 'integration-linux', 'stranger-matrix', 'ux-qe', 'release-qe'];
+
+const fail = (code, detail) => ({ code, detail });
+const cleanHex = (value, length) => new RegExp(`^[a-f0-9]{${length}}$`, 'i').test(String(value || ''));
+const digestOf = (receipt) => String(receipt?.artifact?.sha256 || '').replace(/^sha256:/, '');
+const versionField = (value) => typeof value === 'string' && value.length > 0 ? value : null;
+
+function versionIdentityFailures(expectedVersion, expectedTag, fields) {
+  const mismatches = [];
+  if (!versionField(expectedVersion)) mismatches.push('version is missing');
+  if (expectedTag !== `v${expectedVersion}`) mismatches.push(`tag=${expectedTag ?? 'missing'}`);
+  for (const [name, value, expected = expectedVersion] of fields) {
+    if (value !== expected) mismatches.push(`${name}=${value ?? 'missing'}`);
+  }
+  return mismatches;
+}
+
+export function evaluateStabilizationCandidateReceipt(receipt) {
+  const failures = [];
+  const sha = String(receipt?.sha || '');
+  const digest = digestOf(receipt);
+  if (receipt?.schemaVersion !== 1 || receipt?.phase !== 'stabilization-candidate' || receipt?.mode !== 'stabilization') {
+    failures.push(fail('INVALID_STABILIZATION_RECEIPT', 'schemaVersion=1, phase=stabilization-candidate, and mode=stabilization are required'));
+  }
+  if (receipt?.targetScore !== 95 || receipt?.scoreClaimed !== false) {
+    failures.push(fail('STABILIZATION_SCORE_MISREPRESENTED', 'stabilization must preserve the 95 target and explicitly make no 95 claim'));
+  }
+  if (!cleanHex(sha, 40) || !cleanHex(receipt?.tree, 40) || receipt?.dirty !== false) {
+    failures.push(fail('INVALID_LINEAGE', 'clean candidate SHA and tree are required'));
+  }
+  if (!cleanHex(digest, 64) || receipt?.artifact?.sourceSha !== sha) {
+    failures.push(fail('INVALID_ARTIFACT_DIGEST', 'sealed package digest must be bound to the candidate SHA'));
+  }
+  const version = versionField(receipt?.version);
+  const identityMismatches = versionIdentityFailures(version, receipt?.tag, [
+    ['source package', receipt?.sourceVersions?.package],
+    ['source Claude plugin', receipt?.sourceVersions?.claudePlugin],
+    ['source Codex plugin', receipt?.sourceVersions?.codexPlugin],
+    ['packed npm artifact', receipt?.artifact?.version],
+  ]);
+  if (identityMismatches.length) failures.push(fail('VERSION_IDENTITY_MISMATCH', identityMismatches.join(', ')));
+  if (receipt?.security?.status !== 'PASS' || receipt?.security?.critical !== 0 || receipt?.security?.high !== 0) {
+    failures.push(fail('SECURITY_NOT_PASS', 'stabilization requires zero critical/high dependency findings'));
+  }
+  if (!(receipt?.qe?.total > 0) || receipt?.qe?.status !== 'PASS' || receipt?.qe?.failed !== 0
+    || receipt?.qe?.skipped !== 0 || receipt?.qe?.passed !== receipt?.qe?.total) {
+    failures.push(fail('QE_NOT_PASS', 'release QE must execute nonzero work with zero failed/skipped tests'));
+  }
+  return { verdict: failures.length === 0 ? 'PASS' : 'FAIL', sha, artifactSha256: digest, failures };
+}
+
+export function evaluateCandidateReceipt(receipt) {
+  if (receipt?.phase === 'stabilization-candidate') return evaluateStabilizationCandidateReceipt(receipt);
+  const failures = [];
+  const sha = String(receipt?.sha || '');
+  const digest = digestOf(receipt);
+
+  if (receipt?.schemaVersion !== 1 || receipt?.phase !== 'candidate') failures.push(fail('INVALID_RECEIPT', 'schemaVersion=1 and phase=candidate are required'));
+  if (!cleanHex(sha, 40) || !cleanHex(receipt?.tree, 40)) failures.push(fail('INVALID_LINEAGE', 'candidate SHA and tree must be full git object ids'));
+  if (receipt?.dirty !== false) failures.push(fail('DIRTY_WORKTREE', 'release candidates must come from a clean worktree'));
+  if (!cleanHex(digest, 64)) failures.push(fail('INVALID_ARTIFACT_DIGEST', 'artifact SHA-256 is missing or malformed'));
+  if (receipt?.artifact?.sourceSha !== sha) failures.push(fail('ARTIFACT_SOURCE_MISMATCH', 'packed artifact is not bound to the candidate SHA'));
+
+  const version = versionField(receipt?.version);
+  const tag = version ? `v${version}` : null;
+  const identityMismatches = versionIdentityFailures(version, receipt?.tag, [
+    ['source package', receipt?.sourceVersions?.package],
+    ['source Claude plugin', receipt?.sourceVersions?.claudePlugin],
+    ['source Codex plugin', receipt?.sourceVersions?.codexPlugin],
+    ['packed npm artifact', receipt?.artifact?.version],
+    ['bundle brainVersion', receipt?.artifact?.bundle?.brainVersion],
+    ['bundle releaseTag', receipt?.artifact?.bundle?.releaseTag, tag],
+    ['installed Claude host', receipt?.hosts?.claude?.version],
+    ['installed Codex host', receipt?.hosts?.codex?.version],
+  ]);
+  if (identityMismatches.length > 0) {
+    failures.push(fail('VERSION_IDENTITY_MISMATCH', `candidate surfaces must identify one generation: ${identityMismatches.join(', ')}`));
+  }
+
+  const vector = receipt?.releaseVector || {};
+  if (vector.verdict !== 'PASS' || vector.sha !== sha || vector.unknown !== 0 || vector.skipped !== 0) {
+    failures.push(fail('RELEASE_VECTOR_NOT_PASS', 'release vector must PASS on the exact SHA with zero UNKNOWN/SKIP'));
+  }
+
+  const tests = receipt?.tests || {};
+  if (!(tests.total > 0)) failures.push(fail('ZERO_TESTS', 'a zero-test run is never evidence'));
+  if (tests.failed !== 0 || tests.skipped !== 0 || tests.todo !== 0 || tests.passed !== tests.total) {
+    failures.push(fail('TESTS_NOT_ALL_EXECUTED', 'all discovered tests must execute and pass; skipped/todo are release failures'));
+  }
+  const coverage = receipt?.coverage || {};
+  if (coverage.status !== 'PASS' || !(coverage.lines >= coverage.requiredLines)) failures.push(fail('COVERAGE_NOT_PASS', 'fresh exact-SHA coverage must meet the floor'));
+  const security = receipt?.security || {};
+  if (security.status !== 'PASS' || security.critical !== 0 || security.high !== 0) failures.push(fail('SECURITY_NOT_PASS', 'security must pass with zero critical/high findings'));
+
+  const openIssues = Array.isArray(receipt?.issues?.open) ? receipt.issues.open : null;
+  if (openIssues === null || openIssues.length > 0) failures.push(fail('OPEN_ISSUES', openIssues === null ? 'open-issue evidence missing' : `${openIssues.length} issue(s) remain open`));
+
+  if (receipt?.github?.sha !== sha) failures.push(fail('GITHUB_SHA_MISMATCH', 'GitHub evidence is not bound to candidate SHA'));
+  const checks = Array.isArray(receipt?.github?.checks) ? receipt.github.checks : [];
+  for (const name of REQUIRED_CHECKS) {
+    const matches = checks.filter((check) => check?.name === name);
+    if (matches.length === 0) failures.push(fail('REQUIRED_CHECK_MISSING', `${name} has no exact-SHA result`));
+    else if (!matches.some((check) => check.status === 'completed' && check.conclusion === 'success')) failures.push(fail('REQUIRED_CHECK_NOT_GREEN', `${name} is not completed/success`));
+  }
+
+  for (const hostName of ['claude', 'codex']) {
+    const host = receipt?.hosts?.[hostName];
+    if (host?.status !== 'PASS') failures.push(fail('HOST_NOT_PASS', `${hostName} clean-install acceptance did not pass`));
+    if (host?.artifactSha256 !== digest) failures.push(fail('HOST_ARTIFACT_MISMATCH', `${hostName} did not install the sealed artifact`));
+  }
+
+  const brain = receipt?.brain || {};
+  if (brain.status !== 'PASS') failures.push(fail('BRAIN_NOT_PASS', 'installed MCP search acceptance did not pass'));
+  if (brain.selfStore !== true) failures.push(fail('BRAIN_SELF_STORE_MISSING', 'active RVF registry does not contain ruvnet-brain'));
+  if (brain.citedSelfSource !== true) failures.push(fail('BRAIN_SELF_CITATION_MISSING', 'installed Brain did not cite its own source'));
+  const deadline = Number(brain.deadlineMs);
+  const observed = Math.max(Number(brain.narrowMs), Number(brain.broadMs), Number(brain.concurrentMs));
+  if (!(deadline > 0) || !Number.isFinite(observed) || observed > deadline * 0.8) failures.push(fail('BRAIN_DEADLINE_MARGIN', 'searches must finish within 80% of deadline'));
+
+  const qe = receipt?.qe || {};
+  if (!(qe.total > 0)) failures.push(fail('QE_ZERO_TESTS', 'Agentic QE executed zero tests'));
+  if (qe.status !== 'PASS' || qe.failed !== 0 || qe.skipped !== 0 || qe.passed !== qe.total) failures.push(fail('QE_NOT_PASS', 'Agentic QE must run a nonzero fleet with zero failed/skipped tests'));
+
+  const graders = Array.isArray(receipt?.graders) ? receipt.graders : [];
+  const independent = graders.filter((grader) => grader?.independent === true);
+  if (independent.length < 2 || new Set(independent.map((grader) => grader.id)).size < 2) failures.push(fail('INDEPENDENT_GRADERS', 'two distinct independent graders are required'));
+  for (const grader of independent) {
+    if (!(grader.score >= 95)) failures.push(fail('GRADER_BELOW_95', `${grader.id || 'grader'} scored ${grader.score ?? 'UNKNOWN'}`));
+    if (grader.sha !== sha || grader.artifactSha256 !== digest) failures.push(fail('GRADER_BINDING_MISMATCH', `${grader.id || 'grader'} is not bound to the seal`));
+  }
+
+  return { verdict: failures.length === 0 ? 'PASS' : 'FAIL', sha, artifactSha256: digest, failures };
+}
+
+export function evaluatePublicationReceipt(candidate, publication) {
+  const candidateResult = evaluateCandidateReceipt(candidate);
+  const failures = [...candidateResult.failures];
+  const sha = candidateResult.sha;
+  const digest = candidateResult.artifactSha256;
+  if (publication?.schemaVersion !== 1 || publication?.phase !== 'publication') failures.push(fail('INVALID_PUBLICATION_RECEIPT', 'schemaVersion=1 and phase=publication are required'));
+  if (publication?.sha !== sha || publication?.artifactSha256 !== digest) failures.push(fail('PUBLICATION_SEAL_MISMATCH', 'publication does not reference candidate seal'));
+  const version = versionField(candidate?.version);
+  const tag = version ? `v${version}` : null;
+  const identityMismatches = versionIdentityFailures(version, candidate?.tag, [
+    ['publication version', publication?.version],
+    ['npm version', publication?.npm?.version],
+    ['GitHub release tag', publication?.githubRelease?.tag, tag],
+    ['bundle brainVersion', publication?.bundle?.brainVersion],
+    ['bundle releaseTag', publication?.bundle?.releaseTag, tag],
+    ['installed Claude host', publication?.installed?.claude?.version],
+    ['installed Codex host', publication?.installed?.codex?.version],
+  ]);
+  if (identityMismatches.length > 0) {
+    failures.push(fail('PUBLIC_VERSION_IDENTITY_MISMATCH', `public surfaces must identify candidate ${version ?? 'UNKNOWN'}: ${identityMismatches.join(', ')}`));
+  }
+  for (const surface of ['npm', 'githubRelease']) {
+    const item = publication?.[surface];
+    if (item?.sha !== sha || item?.artifactSha256 !== digest) failures.push(fail('PUBLIC_ARTIFACT_MISMATCH', `${surface} differs from candidate seal`));
+  }
+  for (const hostName of ['claude', 'codex']) {
+    const host = publication?.installed?.[hostName];
+    if (host?.status !== 'PASS' || host?.artifactSha256 !== digest) failures.push(fail('PUBLIC_HOST_NOT_PASS', `${hostName} is not running sealed public artifact`));
+  }
+  const brain = publication?.brain || {};
+  if (brain.status !== 'PASS' || brain.selfStore !== true || !(brain.broadMs <= Number(brain.deadlineMs) * 0.8)) failures.push(fail('PUBLIC_BRAIN_NOT_PASS', 'public installed Brain acceptance failed'));
+  const probes = Array.isArray(publication?.postPublicationChecks) ? publication.postPublicationChecks : [];
+  const probe = probes.find((check) => check?.name === 'published-surface-probe' && check?.sha === sha);
+  if (probe?.status !== 'completed' || probe?.conclusion !== 'success') failures.push(fail('POST_PUBLICATION_CHECK_NOT_GREEN', 'published-surface-probe is not green'));
+  return { verdict: failures.length === 0 ? 'PASS' : 'FAIL', sha, artifactSha256: digest, failures };
+}
+
+export function evaluateLivePreflight(observed) {
+  const failures = [];
+  if (observed?.dirty !== false) failures.push(fail('DIRTY_WORKTREE', 'local worktree is dirty'));
+  if (observed?.localSha !== observed?.remoteSha) failures.push(fail('REMOTE_SHA_MISMATCH', 'local HEAD is not origin/main'));
+  if (!Array.isArray(observed?.openIssues) || observed.openIssues.length > 0) failures.push(fail('OPEN_ISSUES', `${observed?.openIssues?.length ?? 'unknown'} issue(s) open`));
+  if (!Array.isArray(observed?.failedRuns) || observed.failedRuns.length > 0) failures.push(fail('GITHUB_FAILURES', `${observed?.failedRuns?.length ?? 'unknown'} recent failed run(s)`));
+  if (observed?.activeSelfStore !== true) failures.push(fail('BRAIN_SELF_STORE_MISSING', 'installed active registry lacks ruvnet-brain'));
+  if (observed?.branchEnforceAdmins !== true) failures.push(fail('ADMIN_BYPASS_ENABLED', 'main protection does not enforce required checks for admins'));
+  if (observed?.productionProtected !== true) failures.push(fail('PRODUCTION_ENV_UNPROTECTED', 'production environment has no required reviewer protection'));
+  if (observed?.releaseVector !== 'PASS') failures.push(fail('RELEASE_VECTOR_NOT_PASS', `release vector is ${observed?.releaseVector ?? 'UNKNOWN'}`));
+  return { verdict: failures.length === 0 ? 'PASS' : 'FAIL', observed, failures };
+}
+
+export function latestRunsByWorkflow(runs) {
+  const latest = new Map();
+  for (const run of Array.isArray(runs) ? runs : []) {
+    const prior = latest.get(run.workflowName);
+    if (!prior || Number(run.databaseId || 0) > Number(prior.databaseId || 0)) latest.set(run.workflowName, run);
+  }
+  return [...latest.values()];
+}
+
+function command(cmd, args, options = {}) {
+  const result = spawnSync(cmd, args, { encoding: 'utf8', ...options });
+  return {
+    status: result.status,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    error: result.error,
+  };
+}
+
+function jsonCommand(cmd, args, options = {}) {
+  const result = command(cmd, args, options);
+  if (result.status !== 0) return null;
+  try { return JSON.parse(result.stdout); } catch { return null; }
+}
+
+export function collectLivePreflight({ root = process.cwd(), repo = 'stuinfla/ruvnet-brain', includeVector = true } = {}) {
+  const git = (args) => command('git', args, { cwd: root });
+  const localSha = git(['rev-parse', 'HEAD']).stdout.trim();
+  const dirty = Boolean(git(['status', '--porcelain']).stdout.trim());
+  git(['fetch', '--quiet', 'origin', 'main']);
+  const remoteSha = git(['rev-parse', 'origin/main']).stdout.trim();
+  const openIssues = jsonCommand('gh', ['issue', 'list', '--repo', repo, '--state', 'open', '--limit', '100', '--json', 'number,title,url']) ?? null;
+  const runs = jsonCommand('gh', ['run', 'list', '--repo', repo, '--limit', '50', '--json', 'databaseId,workflowName,headSha,status,conclusion,url']) ?? null;
+  const failedRuns = Array.isArray(runs)
+    ? latestRunsByWorkflow(runs.filter((run) => run.headSha === remoteSha))
+      .filter((run) => run.status !== 'completed' || run.conclusion !== 'success')
+    : null;
+  const protection = jsonCommand('gh', ['api', `repos/${repo}/branches/main/protection`]);
+  const environments = jsonCommand('gh', ['api', `repos/${repo}/environments`]);
+  const production = environments?.environments?.find((environment) => environment.name === 'Production – ruvnet-brain');
+  let activeSelfStore = false;
+  try {
+    const source = JSON.parse(fs.readFileSync(path.join(process.env.HOME || '', '.cache/ruvnet-brain/kb/SOURCE.json'), 'utf8'));
+    const stores = source.sources || source.repos || {};
+    activeSelfStore = Boolean(stores['ruvnet-brain']);
+  } catch {}
+  let releaseVector = 'UNKNOWN';
+  if (includeVector) {
+    const vector = jsonCommand(process.execPath, [path.join(root, 'scripts/release-vector.mjs'), '--json'], { cwd: root });
+    releaseVector = vector?.verdict || 'UNKNOWN';
+  }
+  return {
+    localSha,
+    remoteSha,
+    dirty,
+    openIssues,
+    failedRuns,
+    activeSelfStore,
+    branchEnforceAdmins: protection?.enforce_admins?.enabled === true,
+    productionProtected: Array.isArray(production?.protection_rules) && production.protection_rules.length > 0 && production.can_admins_bypass === false,
+    releaseVector,
+  };
+}
+
+const readJson = (file) => JSON.parse(fs.readFileSync(path.resolve(file), 'utf8'));
+const argument = (args, flag) => {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : null;
+};
+
+export function main(args = process.argv.slice(2)) {
+  if (args.includes('--status')) {
+    const result = evaluateLivePreflight(collectLivePreflight({ includeVector: !args.includes('--quick') }));
+    console.log(JSON.stringify(result, null, 2));
+    return result.verdict === 'PASS' ? 0 : 1;
+  }
+  const candidatePath = argument(args, '--candidate');
+  const publicationPath = argument(args, '--publication');
+  if (!candidatePath) {
+    console.error('Usage: release-proof.mjs --candidate <candidate-receipt.json> [--publication <publication-receipt.json>]');
+    return 2;
+  }
+  try {
+    const candidate = readJson(candidatePath);
+    const result = publicationPath ? evaluatePublicationReceipt(candidate, readJson(publicationPath)) : evaluateCandidateReceipt(candidate);
+    console.log(JSON.stringify(result, null, 2));
+    return result.verdict === 'PASS' ? 0 : 1;
+  } catch (error) {
+    console.error(`release-proof: ${error.message}`);
+    return 2;
+  }
+}
+
+if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) process.exitCode = main();

package/plugin/skills/ruvnet-brain/PLAYBOOK.md

@@ -1,6 +1,6 @@
 # THE PLAYBOOK — the standing build playbook, in full
 
-Updated: 2026-07-27 | Version 1.0.0
+Updated: 2026-07-30 | Version 1.0.1
 Created: 2026-07-27
 
 **Read this before your first build response in a session.** `plugin/scripts/session-start.sh`
@@ -41,6 +41,10 @@ the exact lie that makes people distrust rUv's code.
   token exchange", not "does RuvNet apply") — the useful hit can be in ANY of the 32 repos, never
   trust memory about what the corpus does or doesn't have.
 - Check project memory (ruflo memory search / AgentDB) for prior decisions on this area.
+- Diagnose memory only through one canonical absolute path: store a unique key with
+  `ruflo memory store --path <project>/.swarm/memory.db`, retrieve that exact key with the same
+  `--path`, then confirm the exact row through SQLite. A semantic-search miss, DB/WAL mtime,
+  daemon startup, or `[OK] Data stored successfully` alone proves neither failure nor success.
 - Invoke Ruflo MCP tools first for capabilities they already expose. For a CLI-only interface,
   use the brain's `ruvnet_cli_help` then `ruvnet_cli_run` tools with literal argv; never guess flags
   by reconstructing a raw shell command.

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

@@ -1,7 +1,7 @@
 ---
 name: ruvnet-brain
 description: Use whenever a task involves the RuvNet / rUv ecosystem (Ruflo, RuVector/RVF, AgentDB, RuLake, RuView, agentic-flow, agenticow, SAFLA, QuDAG, DAA, ruv-fann, FACT, SynthLang, SPARC, or any of rUv's 20+ repos) — OR whenever you are asked to build, implement, add, refactor, enhance, or fix ANYTHING, in any repo, on any stack. Grounds every RuvNet capability claim in real source via search_ruvnet before asserting, actively considers the FULL toolkit (not just the 2-3 most-cited tools) for whichever one or two would genuinely help THIS project, and TAKES THE LEAD the Ruv way on every build regardless of stack — proposes the right architecture + why, gets one go/no-go, then orchestrates end-to-end (SPARC, parallel swarms, persistent memory, QA gates, proof) instead of acting like a passive answer-bot.
-updated: 2026-07-28
+updated: 2026-08-01
 ---
 
 # RuvNet Brain
@@ -127,7 +127,10 @@ When asked to build, implement, add, refactor, enhance, or fix anything, do NOT
 
 **2. On a yes (or when clearly authorized / low-risk), orchestrate end-to-end:**
    - **SPARC** the non-trivial features: Specification → Pseudocode → Architecture → Refinement → Completion, with a QA gate between phases.
-   - **Parallelize** with Ruflo: `swarm_init` + `agent_spawn` to register tracked agents, then execute — Claude Code Task for hands-on file work, `agent_execute` for research/reasoning. Run independent streams concurrently; don't serialize what can be parallel.
+   - **Parallelize** with Ruflo: use `swarm_init` + `agent_spawn` to coordinate and register tracked agents; those calls do not select the execution billing path. Execute every normal swarm task through the active host's subscription-backed native agents — Claude Code's native Task tool or Codex's native collaboration agents — for research, reasoning, and hands-on file work. Run independent streams concurrently; don't serialize what can be parallel.
+   - **Isolate every non-trivial fix:** give each writing lane one dedicated git worktree and a scoped branch rooted at the current integration base. Never let two writers share a worktree. A read-only lane may share a checkout. Preserve any dirty or failed worktree as recovery evidence; never force-remove it to make the status look clean.
+   - **Promote through one rail:** require the lane's focused tests and failure-path mutant first, then hand its exact diff and evidence to one clean integration owner. The integration owner reconciles dependency order, runs the impacted regression gate, and creates one reviewable commit per fix. A passing lane is not shipped, and a dirty shared checkout is never a release candidate.
+   - **Seal before publication:** run the installed `release-proof` skill against an immutable packed artifact from the clean integration SHA. Only the protected release workflow may publish; only the post-publication seal permits `shipped` or `verified`. If any source, test, issue, host, grader, digest, or workflow evidence is absent, report the exact status (`NOT READY`, `SEALED, NOT SHIPPED`, or `PUBLISHED, NOT VERIFIED`) and keep working from the preserved workstream.
    - **Persist** decisions + state to AgentDB (`memory_store` / `memory_search`) so nothing is lost across sessions or compaction. Recall before deciding — and write memory AT THE MOMENT a decision lands (an ADR accepted, a correction from the user, an architecture call), not reactively when someone asks why memory is empty. "I hadn't been writing memory, only checking it" is a real field failure; proactive capture is the fix.
    - **Ground** every RuvNet capability claim via `search_ruvnet` before asserting, and prefer RuvNet building blocks over generic defaults — but only when the build actually touches the RuvNet stack. For a build with no RuvNet angle, ground in the user's own codebase and official docs instead, the normal way, without mentioning search_ruvnet or RuvNet at all.
    - **Capture** key decisions as ADRs; QA each gate.
@@ -137,9 +140,13 @@ When asked to build, implement, add, refactor, enhance, or fix anything, do NOT
 
 **4. Keep the user confident.** Say what you're doing and why as you go, signal progress, and explain any esoteric concept in one plain line before you lean on it. Narrate *decisions and progress* — never your own compliance with an internal rule (e.g. don't announce that a rule "doesn't apply here"; just proceed as if it were never mentioned). The user should always feel a sharp engineer is in charge and moving — never stalled, never guessing, and never explaining its own instructions to itself out loud.
 
-## Cost-optimal model routing — the verified default (not aspirational)
+## Cost-optimal model routing — subscription execution is the default
 
-Two separate questions, don't conflate them: (1) which Claude tier for a subagent you're about to dispatch, (2) whether a task can skip Claude entirely and go to a cheap third-party model. Both verified live, end-to-end, on 2026-07-07 — by reading the actual source across `ruflo`, `agentic-flow`, and `agent-harness-generator` (not their ADRs, which drift from the code in both directions), then running real commands. Apply both by default whenever you dispatch a subagent — this is the standard way the brain works, not an opt-in per project.
+Two separate questions, don't conflate them: (1) which tier to use inside the active Claude Code or
+Codex subscription, and (2) whether the user has explicitly chosen a separately billed provider.
+The first is the default. Provider-backed execution requires explicit user opt-in; it is never an
+implicit fallback. Never ask for an API key for normal swarm work. Ruflo coordinates the swarm;
+the active host's native subscription agents execute it.
 
 **0. HARD RULE — mechanical work does not run in the main loop (2026-07-13, replaces the advisory version).**
 
@@ -154,7 +161,7 @@ The first version of this rule said "consult the engine before dispatching." Adv
 | Mechanical | grep/glob sweeps, reading CI logs, mechanical edits (rename, path fix, import swap), test-fixture rewrites, file inventories | Subagent, `model: haiku` |
 | Analytical | tracing a bug across files, summarizing a subsystem, drafting tests from a spec | Subagent, `model: sonnet` |
 | Judgment | architecture, root-cause reasoning, security/correctness calls, anything user-facing | Main loop (whatever the user chose) |
-| Pure text, no repo access | research, summarize, classify, transform | `scripts/route-cheap.mjs` → OpenRouter |
+| Pure text, no repo access | research, summarize, classify, transform | Native subscription subagent on the active host |
 
 **Every dispatch leaves a receipt — no exceptions, or this is decorative again.** Subagent dispatches were invisible until `dispatch-receipt.mjs` existed (route-cheap only logged OpenRouter calls), which is why the log looked dead even when routing happened. After the Agent returns, with the REAL sizes:
 
@@ -192,13 +199,21 @@ If `profile.json` is missing, ask the two subscription questions (Claude Pro/Max
 
 Don't expect this specific tool to ever reach GLM/DeepSeek/anything non-Anthropic: its handler never computes an embedding, the one thing that unlocks Ruflo's separate neural router (`neural-router.ts`) — that router is real, well-built code (verified by installing its native FastGRNN backend and watching real training run), with real 2026-06-15 measured benchmark data, but its candidate pool is Ling-2.6-Flash / Gemini-2.5-Flash-Lite / GPT-4.1 / Llama-3.3-70B (not GLM/DeepSeek), it's reachable only via `agent_spawn`, gated behind an off-by-default env var, and has a live NaN bug on sparse per-candidate scoring. Don't wire around those gates — the payoff on rUv's own dataset is thin (n=20, near-tied margins), and a separate rUv benchmark (`ROUTER-PILOT.md`, 2026-06-28) found this whole class of embedding-based difficulty routing scores at chance (ROC-AUC 0.38) on real data. Not the lever to reach for.
 
-**2. True cheap-model delegation.** `mcp__ruflo__agent_execute` cannot do this — its own description says it runs "via the Anthropic Messages API," Anthropic-only, no provider override. The real, working path is agentic-flow's own CLI (genuinely wired OpenRouter integration, real HTTP client):
+**2. Explicit provider-backed delegation (opt-in only).** This section is inactive unless the user
+explicitly asks to spend through an external provider for the current task. It is never selected
+because a subscription is missing, logged out, quota-limited, or temporarily unavailable; those
+conditions degrade or stop the native run without requesting a provider key. `mcp__ruflo__agent_execute`
+is also provider-API execution, not a subscription-backed Ruflo worker, and must follow the same
+explicit-consent boundary. For a user-authorized OpenRouter run, agentic-flow's CLI is the working
+provider path:
 
 ```bash
 npx agentic-flow@latest --agent researcher --model "deepseek/deepseek-chat" --task "<task>"
 npx agentic-flow@latest --agent researcher --model "z-ai/glm-4.6" --task "<task>"
 ```
-Any `--model` containing `/` auto-routes through OpenRouter. Verified live: both returned correct answers in ~5s using the key already in `.env`.
+Any `--model` containing `/` routes through OpenRouter. Invoke it only after the explicit opt-in
+above and only when the required provider credential is already configured; do not request one as
+part of routine swarm setup.
 
 Use this for read-only work with no file mutation — research, summarization, classification, simple text transforms — where a cheap model is good enough. Real, current pricing (pulled live from the OpenRouter API):
 

package/plugin/skills/rvbc/SKILL.md

@@ -1,17 +1,20 @@
 ---
 name: rvbc
-description: Open the RuvNet Brain Console in Codex when the user mentions "rvbc", asks for the Brain Console, or wants to configure or inspect RuvNet Brain. This is the native Codex alias for the Claude-only /rvbc command.
-updated: 2026-07-29
+description: Open the RuvNet Brain Console in Claude Code and Codex when the user says "Configure RuvNet Brain", mentions "rvbc", asks for the Brain Console, or wants to configure or inspect RuvNet Brain. Claude Code supports /rvbc; Codex invokes the native $ruvnet-brain:rvbc skill.
+updated: 2026-07-30
 ---
 
 # RuvNet Brain Console
 
-Codex invokes this skill as `$ruvnet-brain:rvbc`; custom plugin slash commands are not part of the
-Codex CLI slash-command surface.
+“Configure RuvNet Brain” opens this Console in Claude Code and Codex. Claude Code also supports
+`/rvbc`; Codex invokes this skill as `$ruvnet-brain:rvbc` because custom plugin slash commands are
+not part of the Codex CLI slash-command surface.
 
 1. Say one short sentence: "Opening it now; it scans live while you watch."
-2. Locate `scripts/onboarding-console.mjs` from the current repository. If it is not present,
-   check `~/Code/ruvnet-brain/scripts/onboarding-console.mjs`. Do not invent another path.
+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.
 

package/plugin/skills/whats-new/SKILL.md

@@ -8,10 +8,10 @@ updated: 2026-07-28
 
 Ground the answer in files that exist now; do not recite release claims from memory.
 
-1. Read the installed plugin version from `.codex-plugin/plugin.json` relative to this skill's
-   plugin root. If that is unavailable, read the current checkout's `plugin/.codex-plugin/plugin.json`.
-2. Locate `docs/RELEASE-NOTES-4.0.md` in the current repository, then
-   `~/Code/ruvnet-brain/docs/RELEASE-NOTES-4.0.md`. Read it before summarizing.
+1. Run the installed plugin's `scripts/whats-new.mjs` executable. It reads the version manifest and
+   curated notes from the same immutable plugin payload and exits nonzero if either asset is missing.
+   Do not substitute a checkout, download, or another installed version when it fails.
+2. Read that command's output before summarizing it.
 3. State the installed version exactly. Do not say the user is on 4.0 unless it starts with `4.`.
    For a 3.9 development version, describe verified items as "4.0-line enhancements landing in
    3.9.x", using the release note's own status language.