ruvnet-brain 4.3.26 → 4.3.27

package/plugin/scripts/codex-hook-adapter.mjs

@@ -212,6 +212,33 @@ const stdout = merge(stdouts);
 let parsed = null;
 try { parsed = JSON.parse(stdout); } catch { /* a shared body may legitimately print prose */ }
 
+function validPostToolUseOutput(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const topLevelKeys = new Set([
+    'continue', 'stopReason', 'suppressOutput', 'systemMessage',
+    'terminalSequence', 'decision', 'reason', 'hookSpecificOutput',
+  ]);
+  if (Object.keys(value).some((key) => !topLevelKeys.has(key))) return false;
+  if (value.continue !== undefined && typeof value.continue !== 'boolean') return false;
+  if (value.stopReason !== undefined && typeof value.stopReason !== 'string') return false;
+  if (value.suppressOutput !== undefined && typeof value.suppressOutput !== 'boolean') return false;
+  if (value.systemMessage !== undefined && typeof value.systemMessage !== 'string') return false;
+  if (value.terminalSequence !== undefined && typeof value.terminalSequence !== 'string') return false;
+  if (value.decision !== undefined && value.decision !== 'block') return false;
+  if (value.decision === 'block' && (typeof value.reason !== 'string' || !value.reason.trim())) return false;
+  if (value.hookSpecificOutput !== undefined) {
+    const specific = value.hookSpecificOutput;
+    if (!specific || typeof specific !== 'object' || Array.isArray(specific)) return false;
+    const specificKeys = new Set([
+      'hookEventName', 'additionalContext', 'updatedToolOutput', 'updatedMCPToolOutput',
+    ]);
+    if (Object.keys(specific).some((key) => !specificKeys.has(key))) return false;
+    if (specific.hookEventName !== 'PostToolUse') return false;
+    if (specific.additionalContext !== undefined && typeof specific.additionalContext !== 'string') return false;
+  }
+  return true;
+}
+
 if (event === 'Stop') {
   const reason = parsed?.hookSpecificOutput?.additionalContext
     || parsed?.reason
@@ -241,6 +268,16 @@ if (!parsed) {
   process.exit(0);
 }
 
+// A body can emit syntactically valid JSON that is still invalid for Codex's event-specific wire
+// schema (wrong event name, unsupported fields, or bad field types). Preserve the advisory as text
+// inside the known-good PostToolUse envelope instead of forwarding a payload the host rejects.
+if (event === 'PostToolUse' && !validPostToolUseOutput(parsed)) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { hookEventName: event, additionalContext: stdout.trim() },
+  }));
+  process.exit(0);
+}
+
 // `deny` is the only permissionDecision Codex accepts; `allow`, `ask` and the shared bodies' own
 // `defer` are all rejected by name. Strip, then drop an envelope that has nothing left to say.
 const decision = parsed?.hookSpecificOutput?.permissionDecision;

package/plugin/scripts/continuity-hook-policy.mjs

@@ -24,6 +24,7 @@
  *   session-snapshot    continuity capture    at PreCompact         claude
  *   session-snapshot    continuity capture    at SessionEnd         claude, codex
  *   ground-ruvnet       grounding injection   at UserPromptSubmit   claude, codex
+ *   capacity-aware-parallel-work coordination guidance at UserPromptSubmit claude, codex
  *   decision-gate       write authorization   at PreToolUse (write) claude, codex
  *   grounding-stamp     grounding receipt     at PostToolUse        claude, codex
  *   grounding-turn-mark grounding turn marker at UserPromptSubmit   claude, codex
@@ -125,6 +126,9 @@ export const CONTINUITY_EVENTS = Object.freeze({
   UserPromptSubmit: Object.freeze([
     registration('unprompted-speech', '*', ['claude', 'codex']),
     registration('ground-ruvnet', '*', ['claude', 'codex']),
+    // Context-only recommendation for clearly substantial, independently splittable work. The
+    // body samples bounded local pressure signals; it never starts workers or reports that it did.
+    registration('capacity-aware-parallel-work', '*', ['claude', 'codex']),
     // The "answered without searching" gate, half 1 of 2 (2026-09-12) — see grounding-turn-gate.mjs's
     // header for the full rationale. Records that ground-ruvnet's Gate 1 fired for this turn, since
     // Stop's own payload carries no prompt text for grounding-turn-gate to test.

package/plugin/scripts/coverage-integrity.mjs

@@ -89,6 +89,23 @@ export function validateGistAggregateReceipt({ receipt, passagesFile, expectedId
       || row.contentDigest !== digest(files)) {
       throw new Error(`gist ${id} receipt is incomplete or internally inconsistent`);
     }
+    const proofs = files.map((file) => file?.sourceGit).filter(Boolean);
+    if (proofs.length && (proofs.length !== files.length || proofs.some((proof) =>
+      !HEX40.test(String(proof.headSha || '')) || !HEX40.test(String(proof.treeSha || ''))
+      || !HEX40.test(String(proof.blobSha || '')) || proof.captureMethod !== 'public-bare-git-v1'
+      || proof.revisionKind !== 'git-commit' || proof.headSha !== row.versionSha
+      || proof.sourceObservationSha256 !== receipt.sourceObservationSha256
+      || !HEX64.test(String(proof.observedRowsSha256 || ''))
+      || !Number.isSafeInteger(proof.treeFileCount) || proof.treeFileCount !== files.length
+      || proof.observedTruncated !== false || proof.observedFileCount !== proof.treeFileCount
+      || proof.observed !== true || !HEX40.test(String(proof.observedRawRevisionSha || ''))
+      || !['blob', 'commit'].includes(proof.observedRawRevisionKind)
+      || proof.observedRawBlobSha !== proof.blobSha
+      || proofs.some((other) => other.headSha !== proof.headSha || other.treeSha !== proof.treeSha
+        || other.sourceObservationSha256 !== proof.sourceObservationSha256
+        || other.observedRowsSha256 !== proof.observedRowsSha256)))) {
+      throw new Error(`gist ${id} Git tree proof is incomplete or inconsistent`);
+    }
     const { receiptSha256, ...payload } = row;
     if (!HEX64.test(String(receiptSha256 || '')) || receiptSha256 !== digest(payload)) {
       throw new Error(`gist ${id} receipt digest differs`);

package/plugin/scripts/hook-shim.mjs

@@ -86,6 +86,7 @@ catch (e) { BRAIN_OFF = !(e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')); }
 const TABLE = {
   'session-start':    { file: 'session-start-core.mjs', interpreter: 'node', mode: 'advisory', offBehavior: 'partial' },
   'ground-ruvnet':    { file: 'ground-ruvnet.sh',    interpreter: 'bash', mode: 'advisory', offBehavior: 'silence', stdinBytes: 32768 },
+  'capacity-aware-parallel-work': { file: 'capacity-aware-parallel-work.mjs', interpreter: 'node', mode: 'advisory', offBehavior: 'run', stdinBytes: 32768 },
   // ADR-063 / issue #103: `blocking` so an opt-in refusal can actually reach the host. The hook
   // still exits 0 for every user at the shipped default (managedMemoryBoundary=advise), so this
   // changes the CEILING of what it may do, not what it does.

package/plugin/scripts/lesson-gate.mjs

@@ -203,7 +203,10 @@ const GATE_STATE_PATH = process.env.RUVNET_LESSON_GATE_STATE
   || path.join(CONFIG_ROOT, 'lesson-gate-state.json');
 const MAX_SHOWS = (() => {
   const n = Number(process.env.RUVNET_LESSON_MAX_SHOWS);
-  return Number.isInteger(n) && n > 0 ? n : 3;
+  // A user-correction advisory is useful once in a session; repeating identical prose on each
+  // matching edit trains the recipient to ignore it. Keep an explicit override for installations
+  // that want a different cadence. Actual opted-in refusals remain exempt below.
+  return Number.isInteger(n) && n > 0 ? n : 1;
 })();
 const KEEP_SESSIONS = 20;   // bound the state file to the most-recent sessions, same as anticipate.sh
 const SID = (typeof session === 'string' && session.trim())

package/plugin/scripts/project-progression-reader.mjs

@@ -91,6 +91,13 @@ const SCHEMA_FINGERPRINT = Object.freeze({
   ]),
 });
 
+// The current managed store on the host also carries `session_id` on memory_entries, although the
+// installed Ruflo memory_entries DDL does not declare it. This reader has no reason to attribute
+// that column to Ruflo: it is an observed local compatibility shape only. It is safe for this
+// projection because the reader never selects or interprets it; every required column must still
+// match, and every other addition remains a hard fallback to the managed CLI.
+const OBSERVED_COMPATIBILITY_COLUMNS = Object.freeze(['session_id']);
+
 /** The fingerprint this module requires, so the doctor and tests can name it exactly. */
 export function expectedSchemaFingerprint() {
   return { userVersion: SCHEMA_FINGERPRINT.userVersion, columns: [...SCHEMA_FINGERPRINT.columns] };
@@ -110,7 +117,11 @@ function assertSchemaFingerprint(database) {
     throw new ProgressionReaderUnavailable(
       `schema fingerprint mismatch: user_version ${userVersion} is not ${SCHEMA_FINGERPRINT.userVersion}`);
   }
-  if (columns.join(',') !== SCHEMA_FINGERPRINT.columns.join(',')) {
+  const required = SCHEMA_FINGERPRINT.columns;
+  const compatibleObservedShape = columns.length === required.length + 1
+    && OBSERVED_COMPATIBILITY_COLUMNS.every((name) => columns.includes(name))
+    && required.every((name) => columns.includes(name));
+  if (columns.join(',') !== required.join(',') && !compatibleObservedShape) {
     const missing = SCHEMA_FINGERPRINT.columns.filter((name) => !columns.includes(name));
     const added = columns.filter((name) => !SCHEMA_FINGERPRINT.columns.includes(name));
     throw new ProgressionReaderUnavailable('schema fingerprint mismatch: memory_entries columns differ'

package/plugin/scripts/project-progression-session-start.mjs

@@ -4,11 +4,15 @@ import { spawnSync } from 'node:child_process';
 import { ProjectProgressionStore } from './project-progression-store.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
 import { withProgressionReader } from './project-progression-reader.mjs';
+import { STAGE_BUDGETS_MS } from './session-start-budget.mjs';
 
 const PROGRESSION_NAMESPACE = 'project-progression';
 
 export const SESSION_CONTINUITY_LIMIT_BYTES = 8 * 1024;
-export const SESSION_CONTINUITY_DEADLINE_MS = 2_500;
+// Keep the restore's enforced wall-clock ceiling identical to the SessionStart latency contract.
+// The fast path normally completes in milliseconds; when the managed CLI fallback cannot fit this
+// stage, the caller reports UNKNOWN with its reason instead of consuming the rest of the hook budget.
+export const SESSION_CONTINUITY_DEADLINE_MS = STAGE_BUDGETS_MS.restore;
 
 const RESTORED_HEADER = '[RuvNet Brain — PROJECT CONTINUITY RESTORED]';
 const UNKNOWN_HEADER = '[RuvNet Brain — PROJECT CONTINUITY UNKNOWN]';
@@ -21,7 +25,7 @@ const UNKNOWN_EXPLANATIONS = Object.freeze({
   'malformed-store': 'Structural AgentDB output is malformed or internally inconsistent.',
   'exact-readback': 'An exact-listed AgentDB row could not be read back by its exact key.',
   'outbox-replay': 'The durable progression outbox could not be replayed safely.',
-  'output-bound': 'The verified resume payload exceeds the host context bound.',
+  'output-bound': 'The full checkpoint and a goal/action-preserving bounded summary do not fit the host context; no checkpoint state was injected.',
   'no-coherent-state': 'No coherent progression head survived validation.',
   'restore-failed': 'The exact structural restore did not complete.',
   // MEASURED, and named rather than hidden. The in-process read path costs ~15ms for six snapshots;
@@ -198,7 +202,9 @@ export function restoreProgressionForSession({
   const miss = (reason) => unknown(reason, { rowCount });
 
   const prefix = `${RESTORED_HEADER}\n`;
-  const payloadLimit = maxOutputBytes - Buffer.byteLength(prefix, 'utf8');
+  // Reserve room for the status prefix, the bounded-summary explanation, and any pending-outbox
+  // notice appended after the payload. The final complete context is still checked below.
+  const payloadLimit = maxOutputBytes - Buffer.byteLength(prefix, 'utf8') - 400;
   if (!Number.isSafeInteger(payloadLimit) || payloadLimit < 1) return miss('output-bound');
 
   let store;
@@ -226,11 +232,23 @@ export function restoreProgressionForSession({
     // COMMITTED ROWS ONLY (ADR-073 §5). Replay is a write, a write is a `ruflo memory store`
     // process, and one of those costs more than this entire boundary's budget. Pending durable
     // snapshots are REPORTED below and replayed at the next capture boundary or by /checkpoint.
-    const restored = store.restoreLatest({ maxOutputBytes: payloadLimit, replayPending: false });
+    const restored = store.restoreLatest({ maxOutputBytes: payloadLimit, replayPending: false, projectToBound: true });
     if (!validResume(restored)) return miss('malformed-store');
-    const context = `${prefix}${restored.rendered}${pendingNotice(restored.pendingReplay)}`;
+    const summaryNotice = restored.projected
+      ? '\n[BOUNDED CONTINUITY SUMMARY] The merged current goal and next action are preserved exactly; '
+        + 'a null value means the journal heads conflict. '
+        + 'Other omitted details remain in the canonical AgentDB records; consult the listed head keys '
+        + 'and omission digests. Omitted fields are marked and are not empty.'
+      : '';
+    const context = `${prefix}${summaryNotice}\n${restored.rendered}${pendingNotice(restored.pendingReplay)}`;
     if (Buffer.byteLength(context, 'utf8') > maxOutputBytes) return miss('output-bound');
-    return { status: 'restored', severity: 'info', pendingReplay: restored.pendingReplay, context };
+    return {
+      status: restored.projected ? 'restored-summary' : 'restored',
+      severity: restored.projected ? 'warning' : 'info',
+      degraded: restored.projected === true,
+      pendingReplay: restored.pendingReplay,
+      context,
+    };
   } catch (error) {
     // A structurally enumerated, genuinely empty namespace is normal for a newly adopted project.
     if (/no coherent progression state/i.test(String(error?.message ?? ''))

package/plugin/scripts/project-progression-store.mjs

@@ -40,6 +40,70 @@ function requirePositiveInteger(value, label) {
   if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${label} must be a positive safe integer`);
 }
 
+function omissionSummary(value) {
+  return {
+    count: Array.isArray(value) ? value.length : 1,
+    sha256: digestCanonical(value),
+  };
+}
+
+/**
+ * Deterministically reduce a verified resume payload to fit the host context without pretending
+ * omitted evidence is empty. The canonical snapshots remain in AgentDB; the projection retains the
+ * merged goal/action values, head keys and per-omission digests so the omitted values stay addressable.
+ * Returns null when the required resume identity and goal/action alone cannot fit.
+ */
+export function projectResumePayloadToBound(payload, maxOutputBytes) {
+  requirePositiveInteger(maxOutputBytes, 'maxOutputBytes');
+  const summary = structuredClone(payload);
+  const omissions = [];
+  summary.projection = { mode: 'bounded-summary', omitted: omissions };
+  const recordOmission = (target, key, pathName) => {
+    const value = target[key];
+    if (value === undefined) return;
+    const digest = omissionSummary(value);
+    omissions.push({ path: pathName, ...digest });
+    target[key] = { omitted: true, ...digest };
+  };
+  const size = () => Buffer.byteLength(JSON.stringify(summary), 'utf8');
+
+  // Conflicts are important facts, but their full competing values can dominate the resume context.
+  // Keep each conflicting field, its count, and a digest of the exact competing values; top-level
+  // head keys remain, and canonical snapshots retain the source values. No winner is chosen.
+  if (size() > maxOutputBytes && Array.isArray(summary.state?.resumeConflicts)) {
+    const originals = summary.state.resumeConflicts;
+    summary.state.resumeConflicts = originals.map((conflict) => ({
+      field: conflict.field,
+      valueCount: (conflict.values ?? []).length,
+      valuesDigest: digestCanonical(conflict.values ?? []),
+    }));
+    omissions.push({
+      path: 'state.resumeConflicts[].values',
+      ...omissionSummary(originals.flatMap((conflict) => conflict.values ?? []).map((row) => row.value)),
+    });
+  }
+
+  if (size() > maxOutputBytes) recordOmission(summary.state, 'journalHeads', 'state.journalHeads');
+  // Least central detail first. currentGoal and nextAction are deliberately absent from this list.
+  const stateFields = [
+    'commands', 'proofArtifacts', 'changedFiles', 'completed', 'untested', 'decisions',
+    'plan', 'inProgress', 'blockers', 'failures', 'acceptanceContract', 'provenance',
+    'evidence', 'activeStep', 'activeProcess', 'sourceIdentity',
+  ];
+  for (const field of stateFields) {
+    if (size() <= maxOutputBytes) break;
+    recordOmission(summary.state, field, `state.${field}`);
+  }
+  if (size() > maxOutputBytes && summary.evidence) {
+    recordOmission(summary, 'evidence', 'evidence');
+  }
+
+  // Never clip or replace the user goal or next action. If those plus the identity/omission ledger
+  // do not fit, refuse to call this a restore and let SessionStart emit explicit UNKNOWN.
+  if (size() > maxOutputBytes) return null;
+  return { payload: summary, rendered: JSON.stringify(summary), projected: true };
+}
+
 function validatePage(page, { offset, pageSize, total }) {
   if (!plainRecord(page) || !Array.isArray(page.entries)
     || !Number.isSafeInteger(page.total) || page.total < 0
@@ -326,7 +390,8 @@ export class ProjectProgressionStore {
    *   boundaries that already own a write budget. The outbox's fsync-then-commit ordering and its
    *   replay-required semantics are untouched: nothing is dropped, only deferred.
    */
-  restoreLatest({ pageSize = 100, maxEntries = 10_000, maxOutputBytes = 64 * 1024, replayPending = true } = {}) {
+  restoreLatest({ pageSize = 100, maxEntries = 10_000, maxOutputBytes = 64 * 1024,
+    replayPending = true, projectToBound = false } = {}) {
     requirePositiveInteger(maxOutputBytes, 'maxOutputBytes');
     if (replayPending) this.replay();
     const pendingReplay = replayPending ? 0 : this.pendingReplayCount();
@@ -361,10 +426,17 @@ export class ProjectProgressionStore {
         pendingReplay,
       },
     };
-    const rendered = JSON.stringify(payload);
+    let rendered = JSON.stringify(payload);
+    let finalPayload = payload;
+    let projected = false;
     if (Buffer.byteLength(rendered, 'utf8') > maxOutputBytes) {
-      throw new Error(`resume payload exceeds the ${maxOutputBytes}-byte output bound`);
+      const bounded = projectToBound ? projectResumePayloadToBound(payload, maxOutputBytes) : null;
+      if (!bounded) {
+        throw new Error(`resume payload${projectToBound ? ' and mandatory bounded summary' : ''}`
+          + ` exceeds the ${maxOutputBytes}-byte output bound`);
+      }
+      ({ payload: finalPayload, rendered, projected } = bounded);
     }
-    return { payload, rendered, pendingReplay };
+    return { payload: finalPayload, rendered, pendingReplay, projected };
   }
 }

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

@@ -1,7 +1,7 @@
 ---
 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 labeled release blockers, exact-SHA GitHub success, nonzero no-skip QE, packed-artifact host tests, installed Brain/RVF proof, and post-publication byte verification.
-updated: 2026-09-07
+updated: 2026-09-20
 ---
 
 # Release Proof
@@ -37,9 +37,28 @@ green.
 ## Candidate seal
 
 Generate the candidate receipt in `.github/workflows/release-candidate-preflight.yml`; do not
-hand-author it. The preflight runs the long CI, integration, UX, and stranger lanes once on
-`release/**`, then emits the source-bound package and aggregate as
-`release-candidate-<exact SHA>`. Fast-forward that unchanged SHA to `main`.
+hand-author it. Push the exact candidate commit to `release/<version>` to run the long CI,
+integration, UX, and stranger lanes once. Require the successful exact-SHA artifact
+`release-candidate-<SHA>` before promotion.
+
+Then open a PR from that `release/**` branch to `main`. The release-branch `canonical-qa` and
+`integration` consumers verify the producer receipt and report the required checks on the exact
+candidate SHA. Wait for both required checks to pass on that SHA. Do **not** use the GitHub PR merge
+button: merge, squash, and rebase all create a different commit identity and invalidate the sealed
+artifact. Promote only with an ordinary non-force fast-forward push after confirming current `main`
+is an ancestor of the candidate:
+
+```bash
+git fetch origin main
+git merge-base --is-ancestor origin/main "$CANDIDATE_SHA"
+git push origin "$CANDIDATE_SHA:refs/heads/main"
+test "$(git ls-remote origin refs/heads/main | cut -f1)" = "$CANDIDATE_SHA"
+```
+
+If the normal push is rejected, stop and repair branch-policy or required-check configuration; never
+force-push, use an admin bypass, or substitute a merge-created SHA. Any source change requires a new
+candidate preflight and artifact. The PR is review context; its merge button is not the promotion
+mechanism.
 
 Dispatch `.github/workflows/protected-release.yml` only after the fast-forward. It is the sole
 publication controller: it proves current `origin/main` is the preflight SHA, selects the artifact
@@ -78,6 +97,11 @@ Only exit 0 permits “shipped,” “deployed,” “green,” or “ready.”
 seal fails, say `PUBLICATION DEGRADED`, preserve the previous known-good release, and repair or
 roll back through the release workflow.
 
+`npm run release:proof -- --status --quick` is a live local/main diagnostic only. It deliberately
+does not evaluate the release vector and therefore reports `INCOMPLETE` when that is its only
+missing evidence. It is never a candidate receipt or publication authority. Use the exact candidate
+receipt and workflow artifacts for release decisions.
+
 `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

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

@@ -195,24 +195,42 @@ export function evaluatePublicationReceipt(candidate, publication) {
 
 export function evaluateLivePreflight(observed) {
   const failures = [];
+  const incomplete = [];
   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)`));
+  const blockers = observed?.releaseBlockers;
+  if (!Array.isArray(blockers)) failures.push(fail('RELEASE_BLOCKERS_UNKNOWN', 'could not verify open issues labeled release-blocker'));
+  else if (blockers.length > 0) failures.push(fail('RELEASE_BLOCKERS_OPEN', `${blockers.length} release-blocker issue(s) remain open`));
+  const requiredChecks = observed?.requiredChecks;
+  if (!Array.isArray(requiredChecks) || requiredChecks.length === 0) {
+    failures.push(fail('REQUIRED_CHECKS_UNKNOWN', 'could not verify the required main-branch checks on the exact remote SHA'));
+  } else {
+    for (const check of requiredChecks) {
+      if (check?.status !== 'PASS') failures.push(fail('REQUIRED_CHECK_NOT_GREEN', `${check?.context || 'unknown'} is ${check?.status || 'UNKNOWN'} on the exact remote SHA`));
+    }
+  }
   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 };
+  if (observed?.productionProtected !== true) failures.push(fail('PRODUCTION_ENV_UNPROTECTED', 'production environment lacks an enforced protection rule'));
+  if (observed?.releaseVector === 'NOT_EVALUATED') incomplete.push(fail('RELEASE_VECTOR_NOT_EVALUATED', 'quick status skipped the release vector; run full status for that evidence'));
+  else if (observed?.releaseVector !== 'PASS') failures.push(fail('RELEASE_VECTOR_NOT_PASS', `release vector is ${observed?.releaseVector ?? 'UNKNOWN'}`));
+  return {
+    verdict: failures.length > 0 ? 'FAIL' : incomplete.length > 0 ? 'INCOMPLETE' : 'PASS',
+    observed,
+    failures,
+    incomplete,
+  };
 }
 
-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()];
+export function resolveRequiredChecks(requiredContexts, checkRuns, statuses) {
+  if (!Array.isArray(requiredContexts) || !Array.isArray(checkRuns) || !Array.isArray(statuses)) return null;
+  return requiredContexts.map(({ context, app_id: appId }) => {
+    const checkRun = checkRuns.find((row) => row.name === context && (appId == null || row.app?.id === appId));
+    const status = appId == null ? statuses.find((row) => row.context === context) : null;
+    const passed = (checkRun?.status === 'completed' && checkRun.conclusion === 'success') || status?.state === 'success';
+    const pending = checkRun?.status === 'queued' || checkRun?.status === 'in_progress' || status?.state === 'pending';
+    return { context, appId, status: passed ? 'PASS' : pending ? 'PENDING' : checkRun || status ? 'FAIL' : 'MISSING' };
+  });
 }
 
 function command(cmd, args, options = {}) {
@@ -235,15 +253,21 @@ export function collectLivePreflight({ root = process.cwd(), repo = 'stuinfla/ru
   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 fetched = git(['fetch', '--quiet', 'origin', 'main']);
+  const remoteSha = fetched.status === 0 ? git(['rev-parse', 'origin/main']).stdout.trim() : null;
+  const releaseBlockers = jsonCommand('gh', ['issue', 'list', '--repo', repo, '--state', 'open', '--label', 'release-blocker', '--limit', '100', '--json', 'number,title,url']) ?? null;
   const protection = jsonCommand('gh', ['api', `repos/${repo}/branches/main/protection`]);
+  const requiredChecksConfig = protection?.required_status_checks?.checks;
+  const requiredContexts = Array.isArray(requiredChecksConfig)
+    ? requiredChecksConfig
+    : protection?.required_status_checks?.contexts?.map((context) => ({ context, app_id: null }));
+  const checkRuns = remoteSha
+    ? jsonCommand('gh', ['api', `repos/${repo}/commits/${remoteSha}/check-runs?per_page=100`])?.check_runs
+    : null;
+  const statuses = remoteSha
+    ? jsonCommand('gh', ['api', `repos/${repo}/commits/${remoteSha}/status`])?.statuses
+    : null;
+  const requiredChecks = resolveRequiredChecks(requiredContexts, checkRuns, statuses);
   const environments = jsonCommand('gh', ['api', `repos/${repo}/environments`]);
   const production = environments?.environments?.find((environment) => environment.name === 'Production – ruvnet-brain');
   let activeSelfStore = false;
@@ -256,13 +280,13 @@ export function collectLivePreflight({ root = process.cwd(), repo = 'stuinfla/ru
   if (includeVector) {
     const vector = jsonCommand(process.execPath, [path.join(root, 'scripts/release-vector.mjs'), '--json'], { cwd: root });
     releaseVector = vector?.verdict || 'UNKNOWN';
-  }
+  } else releaseVector = 'NOT_EVALUATED';
   return {
     localSha,
     remoteSha,
     dirty,
-    openIssues,
-    failedRuns,
+    releaseBlockers,
+    requiredChecks,
     activeSelfStore,
     branchEnforceAdmins: protection?.enforce_admins?.enabled === true,
     productionProtected: Array.isArray(production?.protection_rules) && production.protection_rules.length > 0 && production.can_admins_bypass === false,
@@ -280,7 +304,7 @@ 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;
+    return result.verdict === 'PASS' ? 0 : result.verdict === 'INCOMPLETE' ? 2 : 1;
   }
   const candidatePath = argument(args, '--candidate');
   const publicationPath = argument(args, '--publication');

package/scripts/brain-novice-50.mjs

@@ -69,23 +69,21 @@ function percentile(values, fraction) {
   return sorted[Math.max(0, Math.ceil(sorted.length * fraction) - 1)];
 }
 
-function grade(spec, text, elapsedMs, transportOk) {
-  const repo = spec.repo.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const expectedRepoCited = new RegExp(
-    `(?:repo\\s*=\\s*["']?${repo}\\b|path\\s*:\\s*${repo}/|capability-cards\\.md#${repo}\\b)`,
-    'i',
-  ).test(text);
-  const cited = /(?:#\d+\s+repo=[a-z0-9._-]+|path\s*:\s*[a-z0-9._-]+\/|capability-cards\.md#[a-z0-9._-]+)/i
-    .test(text);
-  const useful = spec.required.test(text);
+export function grade(spec, text, elapsedMs, transportOk) {
+  const top = /^#1\s+repo=(\S+)(?:\s+ce=(-?[\d.]+))?/m.exec(text);
+  const expectedRepoCited = [...String(text).matchAll(/^#\d+\s+repo=(\S+)/gm)]
+    .some((match) => match[1].toLowerCase() === spec.repo.toLowerCase());
+  const cited = /^#\d+\s+repo=[a-z0-9._-]+/im.test(text);
+  const abstained = !top || (top[2] !== undefined && Number(top[2]) < 0);
+  // This regex is retained as a visible keyword signal only. It is not semantic accuracy and it
+  // cannot make a row effective without a citation from the independently expected owner.
+  const keywordSignal = spec.required.test(text);
   const unsupportedAbsence = /\b(?:does not exist|must be built|you need to build it)\b/i.test(text);
   const evidenceQualified = /EVIDENCE:\s*THIN|NOT PROVEN|PROPOSED|curated-capability-card|THIS QUERY found nothing/i.test(text);
   const honest = !unsupportedAbsence || evidenceQualified;
   const latencyPoints = elapsedMs <= 4000 ? 10 : elapsedMs <= 8000 ? 5 : 0;
-  const score = (transportOk ? 20 : 0) + (text.length > 200 ? 20 : 0)
-    + (cited ? 20 : 0) + (useful ? 20 : 0) + (honest ? 10 : 0) + latencyPoints;
-  const effective = transportOk && cited && useful && honest && elapsedMs <= 4000;
-  return { score, cited, expectedRepoCited, useful, honest, effective, latencyPoints };
+  const effective = transportOk && cited && expectedRepoCited && honest && !abstained && elapsedMs <= 4000;
+  return { cited, expectedRepoCited, keywordSignal, honest, abstained, effective, latencyPoints };
 }
 
 async function main() {
@@ -153,7 +151,7 @@ async function main() {
         answer: text,
         ...grade(spec, text, elapsedMs, transportOk),
       };
-      process.stdout.write(`${String(spec.id).padStart(2, '0')} ${String(results[index].score).padStart(3)} ${String(elapsedMs).padStart(6)}ms ${spec.category.padEnd(14)} ${spec.query}\n`);
+      process.stdout.write(`${String(spec.id).padStart(2, '0')} ${results[index].effective ? 'ELIGIBLE' : 'MISS    '} ${String(elapsedMs).padStart(6)}ms ${spec.category.padEnd(14)} ${spec.query}\n`);
     }
   }));
 
@@ -170,17 +168,17 @@ async function main() {
     readinessMs,
     passed: results.filter((result) => result.effective).length,
     under4s: results.filter((result) => result.elapsedMs <= 4000).length,
-    averageScore: Math.round(results.reduce((sum, result) => sum + result.score, 0) / results.length),
     averageMs: Math.round(times.reduce((sum, value) => sum + value, 0) / times.length),
     medianMs: percentile(times, 0.5),
     p95Ms: percentile(times, 0.95),
     longestMs: Math.max(...times),
     stderr: stderr.trim(),
+    gradingScope: 'Operational eligibility only: transport, citation presence, expected-owner citation, honest uncertainty, and latency. keywordSignal is diagnostic only; this report does not measure semantic answer accuracy.',
     results,
   };
   const output = path.join(ROOT, 'data/novice-50-report.json');
   fs.writeFileSync(output, JSON.stringify(report, null, 2) + '\n');
-  console.log(`SUMMARY ${report.passed}/50 effective · ${report.under4s}/50 under 4s · score ${report.averageScore}/100 · avg ${report.averageMs}ms · p95 ${report.p95Ms}ms · max ${report.longestMs}ms`);
+  console.log(`SUMMARY ${report.passed}/50 eligible · ${report.under4s}/50 under 4s · avg ${report.averageMs}ms · p95 ${report.p95Ms}ms · max ${report.longestMs}ms`);
   console.log(`REPORT ${output}`);
 }
 

package/scripts/build-bundle.mjs

@@ -66,6 +66,7 @@ import { validateCoverageLedger } from './coverage-integrity.mjs';
 // The org total is DERIVED, never a literal: it was hardcoded 248 in this file and in its
 // sibling while the account actually had 200 — one stale fact, restated twice (2026-08-12).
 import { orgRepoCount } from './org-repo-count.mjs';
+import { assertCapabilityOnlyStore } from '../kb/capability-only.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -742,6 +743,7 @@ async function assembleBundleImpl({ corpusDir, runtimeRoot, outDir, identity = {
   }
 
   const selectedResults = discovered.map((name) => {
+    assertCapabilityOnlyStore(corpus, name);
     const folded = name.toLowerCase();
     const generation = ledgerIn.stores?.[name]
       || Object.entries(ledgerIn.stores || {}).find(([key]) => key.toLowerCase() === folded)?.[1];

package/scripts/corpus-dispatch-receipt.mjs

@@ -0,0 +1,22 @@
+// Correlation is not authorization: protected-release still enforces its own release authority.
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+export function selectCorpusDispatch(runs, { sha, dispatchId, notBefore }) {
+  if (!/^[a-f0-9]{40}$/.test(sha || '') || !/^corpus-\d+-\d+$/.test(dispatchId || '')
+    || !Number.isFinite(Date.parse(notBefore))) throw new Error('invalid corpus dispatch identity');
+  const matches = runs.filter(run => run.event === 'workflow_dispatch' && run.head_sha === sha
+    && run.head_branch === 'main' && run.display_title === `protected-release corpus ${dispatchId}`
+    && Date.parse(run.created_at) >= Date.parse(notBefore));
+  if (matches.length > 1) throw new Error('multiple runs claim the corpus dispatch identity');
+  return matches[0] || null;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const response = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+  const run = selectCorpusDispatch(response.workflow_runs || [], {
+    sha: process.env.CANDIDATE_SHA, dispatchId: process.env.CORPUS_DISPATCH_ID,
+    notBefore: process.env.DISPATCHED_AT,
+  });
+  if (run) console.log(JSON.stringify(run));
+}