ruvnet-brain 4.3.25 → 4.3.27

package/plugin/scripts/capacity-aware-parallel-work.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit advisory for substantial work with independent workstreams.
+ *
+ * This hook classifies only the submitted prompt and samples local pressure signals. It NEVER
+ * creates agents or claims that agents are running. The coordinator still has to check the live
+ * agent tools and runtime concurrency ceiling, then spawn real workers and inspect their results.
+ * Missing or malformed input, unavailable probes, and unexpected errors are silent and fail open.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const UNKNOWN_RUNTIME_TOTAL_AGENT_CEILING = 4;
+const INPUT_LIMIT = 32 * 1024;
+const PROBE_TIMEOUT_MS = 450;
+const GIB = 1024 ** 3;
+
+const ACTION = /\b(?:build|implement|refactor|migrate|investigate|audit|review|design|fix|add|remove|optimi[sz]e|plan|execute|ship)\b/i;
+const EXPLICIT_FANOUT = /\b(?:parallel(?:ize|ise)?|swarm|delegate|spawn (?:real )?agents?|independent workstreams?|separate owners?)\b/i;
+const BROAD_SCOPE = /\b(?:cross[- ]cutting|end[- ]to[- ]end|multi[- ]step|large[- ]scale|whole (?:repo|repository|codebase|system)|entire (?:repo|repository|codebase|system)|full (?:repo|repository|codebase|system)|across (?:the )?(?:repo|repository|codebase|system)|multiple (?:modules|files|packages|components|services)|several (?:modules|files|packages|components|services|workstreams))\b/i;
+const TRIVIAL_SCOPE = /\b(?:tiny|trivial|simple|single[- ]line|one[- ]line|small typo|rename (?:one|a|single) variable|format one file|just (?:a )?quick fix)\b/i;
+const COMPONENTS = [
+  /\bapi\b/i, /\bcli\b/i, /\bui\b|\bfront[- ]end\b|\binterface\b/i,
+  /\btests?\b|\bqa\b/i, /\bdocs?\b|\bdocumentation\b/i,
+  /\bdata(?:base| layer| model)?\b|\bschema\b/i, /\bsecurity\b/i,
+  /\binfra(?:structure)?\b|\bdeployment\b/i, /\bhooks?\b/i,
+  /\binstaller\b|\bpackaging\b/i, /\bruntime\b/i,
+];
+
+function estimateWorkUnitCount(prompt) {
+  const componentCount = COMPONENTS.reduce((n, re) => n + Number(re.test(prompt)), 0);
+  if (componentCount >= 2) return componentCount;
+  const numberedItems = [...prompt.matchAll(/(?:^|\n)\s*(?:\d+[.)]|[-*])\s+\S/g)].length;
+  return numberedItems >= 2 ? numberedItems : null;
+}
+
+export function isSubstantialParallelWork(prompt) {
+  const text = typeof prompt === 'string' ? prompt.trim() : '';
+  if (!text || TRIVIAL_SCOPE.test(text) || !ACTION.test(text)) return false;
+  if (EXPLICIT_FANOUT.test(text)) return true;
+  const breadth = BROAD_SCOPE.test(text);
+  const componentCount = COMPONENTS.reduce((n, re) => n + Number(re.test(text)), 0);
+  const numberedItems = [...text.matchAll(/(?:^|\n)\s*(?:\d+[.)]|[-*])\s+\S/g)].length;
+  return (breadth && componentCount >= 2) || componentCount >= 3 || numberedItems >= 3;
+}
+
+function parseUsedBytes(text) {
+  const match = String(text).match(/\bused\s*=\s*([\d.]+)\s*([KMGT]?)B?\b/i);
+  if (!match) return null;
+  const scale = { '': 1, K: 1024, M: 1024 ** 2, G: GIB, T: 1024 ** 4 }[match[2].toUpperCase()];
+  const value = Number(match[1]) * scale;
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+export function parseMacPressureOutput(text, { totalMemoryBytes, normalizedLoad }) {
+  const source = String(text || '');
+  const freeMatch = source.match(/System-wide memory free percentage:\s*(\d+(?:\.\d+)?)%/i);
+  const pageSizeMatch = source.match(/page size of\s+([\d,]+)\s+bytes/i);
+  const compressorMatch = source.match(/Pages occupied by compressor:\s*([\d,]+)/i);
+  const swapMatch = source.match(/vm\.swapusage:.*?used\s*=\s*([\d.]+)\s*([KMGT]?)B?\b/i);
+  if (!freeMatch || !pageSizeMatch || !compressorMatch || !swapMatch) return null;
+  const pageSize = Number(pageSizeMatch[1].replaceAll(',', ''));
+  const compressedPages = Number(compressorMatch[1].replaceAll(',', ''));
+  const swapUsedBytes = parseUsedBytes(`used = ${swapMatch[1]}${swapMatch[2]}B`);
+  const freePct = Number(freeMatch[1]);
+  const compressorBytes = pageSize * compressedPages;
+  if (![pageSize, compressedPages, swapUsedBytes, freePct, totalMemoryBytes, normalizedLoad]
+    .every(Number.isFinite) || pageSize <= 0 || compressedPages < 0 || totalMemoryBytes <= 0
+    || freePct < 0 || freePct > 100 || normalizedLoad < 0) return null;
+  return { freePct, swapUsedBytes, compressorBytes, totalMemoryBytes, normalizedLoad };
+}
+
+/** Classify measured pressure. Unknown or incomplete measurements recommend serial work. */
+export function pressureRecommendation(sample) {
+  if (!sample || ![
+    sample.freePct, sample.swapUsedBytes, sample.compressorBytes,
+    sample.totalMemoryBytes, sample.normalizedLoad,
+  ].every(Number.isFinite) || sample.totalMemoryBytes <= 0) {
+    return { tier: 'unknown', totalAgents: 1, reason: 'capacity signals unavailable' };
+  }
+  const compressedRatio = sample.compressorBytes / sample.totalMemoryBytes;
+  if (sample.freePct < 45 || sample.swapUsedBytes > 0 || compressedRatio >= 0.4
+    || sample.normalizedLoad >= 1) {
+    return { tier: 'constrained', totalAgents: 1, reason: 'resource pressure is high' };
+  }
+  // The local load-per-logical-core signal is a bounded CPU-pressure proxy, not a claim to a
+  // precise CPU utilization sample. Above 75% it trims fan-out to three total agents.
+  if (sample.normalizedLoad >= 0.75) {
+    return { tier: 'high-cpu', totalAgents: 3, reason: 'CPU pressure is high' };
+  }
+  if (sample.freePct < 75 || compressedRatio >= 0.2 || sample.normalizedLoad >= 0.55) {
+    return { tier: 'moderate', totalAgents: 2, reason: 'resource headroom is partial' };
+  }
+  return { tier: 'available', totalAgents: null, reason: 'measured headroom is available' };
+}
+
+/**
+ * Apply lower configured/runtime caps after pressure sizing. A configured worker ceiling never
+ * proves runtime availability; an authoritative runtime cap, when supplied by the host, wins.
+ */
+export function effectiveAgentRecommendation(sample, {
+  configuredMaxChildren = null,
+  runtimeTotalAgentCap = null,
+  workUnitCount = null,
+} = {}) {
+  const pressure = pressureRecommendation(sample);
+  const runtimeCapKnown = Number.isInteger(runtimeTotalAgentCap) && runtimeTotalAgentCap >= 1;
+  const limits = [pressure.totalAgents ?? (runtimeCapKnown ? runtimeTotalAgentCap : UNKNOWN_RUNTIME_TOTAL_AGENT_CEILING)];
+  if (Number.isInteger(configuredMaxChildren) && configuredMaxChildren >= 0) {
+    limits.push(configuredMaxChildren + 1); // configured workers plus the coordinating agent
+  }
+  if (runtimeCapKnown) {
+    limits.push(runtimeTotalAgentCap);
+  }
+  if (Number.isInteger(workUnitCount) && workUnitCount >= 0) limits.push(workUnitCount + 1);
+  const totalAgents = Math.min(...limits);
+  return {
+    ...pressure,
+    totalAgents,
+    workers: Math.max(0, totalAgents - 1),
+    runtimeCapKnown,
+  };
+}
+
+function readInput() {
+  const chunks = [];
+  const buffer = Buffer.alloc(4096);
+  let total = 0;
+  while (total < INPUT_LIMIT) {
+    const count = fs.readSync(0, buffer, 0, Math.min(buffer.length, INPUT_LIMIT - total), null);
+    if (!count) break;
+    chunks.push(Buffer.from(buffer.subarray(0, count)));
+    total += count;
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+function collectMacPressure() {
+  if (process.platform !== 'darwin') return null;
+  try {
+    // One bounded subprocess gathers pressure, swap, and compressor bytes. Never use raw free RAM
+    // as the capacity signal; memory_pressure, actual swap, compression, and normalized load drive
+    // the tier. The hook intentionally does not wait for a timed CPU sample.
+    const probe = spawnSync('/bin/sh', ['-c', '/usr/bin/memory_pressure -Q; /usr/sbin/sysctl vm.swapusage; /usr/bin/vm_stat'], {
+      encoding: 'utf8', timeout: PROBE_TIMEOUT_MS, maxBuffer: 24 * 1024,
+      env: { PATH: '/usr/bin:/bin:/usr/sbin:/sbin' },
+    });
+    if (probe.error || probe.status !== 0) return null;
+    const cpuCount = os.cpus().length;
+    const load = os.loadavg()[0];
+    if (!cpuCount || !Number.isFinite(load) || load < 0) return null;
+    return parseMacPressureOutput(probe.stdout, {
+      totalMemoryBytes: os.totalmem(), normalizedLoad: load / cpuCount,
+    });
+  } catch {
+    return null;
+  }
+}
+
+export function formatAdvisory(recommendation) {
+  const n = recommendation.totalAgents;
+  const runtime = recommendation.runtimeCapKnown
+    ? 'Do not exceed the host-reported runtime cap; configured concurrency is only a ceiling.'
+    : `This hook cannot see the live runtime/tool cap; ${UNKNOWN_RUNTIME_TOTAL_AGENT_CEILING} total is only a conservative ceiling until the coordinator checks it. Configured concurrency is not proof of available slots.`;
+  const workerPlan = recommendation.workers > 0
+    ? `At most ${recommendation.workers} worker agent${recommendation.workers === 1 ? '' : 's'}`
+    : 'No additional worker agents';
+  return [
+    'Capacity-aware parallel-work advisory (context only; no workers were started).',
+    `This prompt appears to contain independent work. Resource tier: ${recommendation.tier}; recommend no more than ${n} total agent${n === 1 ? '' : 's'} including the coordinator (${workerPlan}).`,
+    `${runtime} Treat configured concurrency as a ceiling only; never infer that configured slots are available.`,
+    'If a real agent-spawn/task tool is available and slots remain, launch actual workers now with non-overlapping deliverables and collect their results. If tools or slots are unavailable, continue serially and do not claim parallel workers exist.',
+  ].join('\n');
+}
+
+export function runCapacityHook(rawInput, sample) {
+  let input;
+  try { input = JSON.parse(String(rawInput || '')); } catch { return ''; }
+  const prompt = input?.prompt ?? input?.user_prompt ?? input?.input;
+  if (!isSubstantialParallelWork(prompt)) return '';
+  return formatAdvisory(effectiveAgentRecommendation(sample === undefined ? collectMacPressure() : sample, {
+    configuredMaxChildren: input?.configured_max_children,
+    runtimeTotalAgentCap: input?.runtime_total_agent_cap,
+    workUnitCount: input?.independent_workstream_count ?? estimateWorkUnitCount(prompt),
+  }));
+}
+
+function main() {
+  try {
+    const output = runCapacityHook(readInput());
+    if (output) process.stdout.write(`${output}\n`);
+  } catch {
+    // This advisory has no authority to block or delay user work when anything is unavailable.
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main();

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