ruvnet-brain 4.5.4 → 4.5.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.5.4",
-  "description": "One-command installer for RuvNet Brain \u2014 a portable, source-grounded brain over rUv's RuvNet building blocks, delivered as a Claude Code plugin so Claude uses the stack instead of fighting it.",
+  "version": "4.5.6",
+  "description": "One-command installer for RuvNet Brain — a portable, source-grounded brain over rUv's RuvNet building blocks, delivered as a Claude Code plugin so Claude uses the stack instead of fighting it.",
   "type": "module",
   "bin": {
     "ruvnet-brain": "bin/install.mjs"
@@ -40,6 +40,8 @@
     "test:all": "npm run test:unit && npm run test:mesh && npm run test:mutation && npm run test:regression && npm run test:integration && npm test",
     "metaharness:receipts": "node scripts/metaharness-receipts.mjs",
     "route:cheap": "node scripts/route-cheap.mjs",
+    "routing:eval": "node scripts/model-routing-eval.mjs",
+    "hooks:security-guidance:compat": "node scripts/security-guidance-codex-compat.mjs",
     "route:receipt": "node scripts/dispatch-receipt.mjs",
     "trismart": "node scripts/trismart.mjs",
     "metaharness:fix": "node scripts/fix-metaharness-memretrieve.mjs --apply",
@@ -144,6 +146,7 @@
   },
   "dependencies": {
     "@metaharness/flywheel": "^0.1.7",
-    "@metaharness/router": "^0.4.0"
+    "@metaharness/router": "^0.4.0",
+    "ws": "^8.22.0"
   }
 }

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ruvnet-brain",
   "description": "RuvNet brain transplant for Claude Code — grounds every RuvNet decision in real source across 77 rUv repositories, prefers Ruflo / RuVector-RVF / AgentDB over training-prior defaults (pgvector, Pinecone, hand-rolled cosine), and can pull in any RuvNet repo on demand. Ships a UserPromptSubmit retrieve-and-inject grounding hook and a PreToolUse write gate that refuses ungrounded rUv-product code until search_ruvnet has been consulted (ADR-0012 / ADR-067).",
-  "version": "4.5.4",
+  "version": "4.5.6",
   "author": {
     "name": "Stuart Kerr"
   },

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.5.4",
+  "version": "4.5.6",
   "description": "Source-grounded RuvNet knowledge, lifecycle enforcement, and learning for Codex.",
   "author": {
     "name": "Stuart Kerr"

package/plugin/mcp/managed-cli-interface.mjs

@@ -253,9 +253,10 @@ export function normalizeManagedExecution(execution) {
   const output = [execution?.stdout, execution?.stderr].filter(Boolean)
     .join(execution?.stdout && execution?.stderr ? '\n' : '');
   const contradictoryFailure = /(?:^|\n)\s*(?:❌|\[ERROR\])|invalid pragma command|key not found/i.test(output);
+  if (execution?.error) return { outcome: 'failure', output, contradictoryFailure };
   if (execution?.signal) return { outcome: 'interrupted', output, signal: execution.signal, contradictoryFailure };
-  if (execution?.error || contradictoryFailure || execution?.code === null || execution?.code === undefined) {
-    return { outcome: execution?.error || contradictoryFailure ? 'failure' : 'unknown', output, contradictoryFailure };
+  if (contradictoryFailure || execution?.code === null || execution?.code === undefined) {
+    return { outcome: contradictoryFailure ? 'failure' : 'unknown', output, contradictoryFailure };
   }
   return { outcome: execution.code === 0 ? 'success' : 'failure', output, contradictoryFailure };
 }
@@ -296,15 +297,19 @@ function managedProgressionCapture({ executable, argv, projectRoot, env, event,
 function resultOf(executable, argv, result) {
   const output = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? '\n' : '');
   const normalized = normalizeManagedExecution(result);
+  const terminal = { outcome: normalized.outcome, code: result.code ?? null, signal: result.signal ?? null,
+    error: result.error ?? null, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
   if (normalized.outcome !== 'success') {
-    const reason = result.error || (normalized.contradictoryFailure ? 'fatal output despite exit 0' : result.code == null ? 'no terminal exit status' : `exit ${result.code}`);
+    const reason = result.error || (result.signal ? `signal ${result.signal}` : result.code != null && result.code !== 0 ? `exit ${result.code}` : normalized.contradictoryFailure ? 'fatal output without successful completion' : 'no terminal exit status');
     return {
-      content: [{ type: 'text', text: output || `${executable} ${argv.join(' ')} failed: ${reason}` }],
+      content: [{ type: 'text', text: [output, `${executable} ${argv.join(' ')} failed: ${reason}`].filter(Boolean).join('\n') }],
+      structuredContent: terminal,
       isError: true,
     };
   }
   return {
     content: [{ type: 'text', text: output || `${executable} ${argv.join(' ')} completed successfully` }],
+    structuredContent: terminal,
     isError: false,
   };
 }

package/plugin/scripts/capability-claim-evidence.mjs

@@ -3,6 +3,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { redactText } from './continuity-events.mjs';
 
 const HEX40 = /^[a-f0-9]{40}$/;
 const HEX64 = /^[a-f0-9]{64}$/;
@@ -157,7 +158,13 @@ export function recordManagedCliObservation({ toolName, executable, argv, execut
   observedAt = new Date().toISOString() } = {}) {
   try {
     const output = [execution?.stdout, execution?.stderr].filter(Boolean).join('\n');
-    const reachable = execution?.code === 0 && !execution?.error;
+    const contradictoryFailure = /(?:^|\n)\s*(?:❌|\[ERROR\])|invalid pragma command|key not found/i.test(output);
+    const reachable = execution?.code === 0 && !execution?.error && !execution?.signal && !contradictoryFailure;
+    const outcome = execution?.error ? 'failure' : execution?.signal ? 'interrupted' : contradictoryFailure ? 'failure'
+      : Number.isSafeInteger(execution?.code) ? execution.code === 0 ? 'success' : 'failure' : 'unknown';
+    const terminal = { outcome, exitCode: Number.isSafeInteger(execution?.code) ? execution.code : null,
+      error: typeof execution?.error === 'string' ? redactText(execution.error).slice(0, 4096) : null,
+      signal: typeof execution?.signal === 'string' ? redactText(execution.signal).slice(0, 100) : null };
     const version = VERSION.exec(output)?.[1] || null;
     let observationClass = null;
     let fields = {};
@@ -169,7 +176,7 @@ export function recordManagedCliObservation({ toolName, executable, argv, execut
       observationClass = 'health';
       const negative = /\b(?:critical|degraded|error|failed|failure|unhealthy)\b/i.test(output);
       const positive = /\b(?:all checks passed|healthy|overall\s*[:=-]?\s*(?:ok|pass)|status\s*[:=-]\s*(?:ok|pass|healthy))\b/i.test(output);
-      fields = { healthVerdict: negative ? 'FAIL' : reachable && positive ? 'PASS' : 'UNKNOWN', reachable };
+      fields = { healthVerdict: negative || ['failure', 'interrupted'].includes(outcome) ? 'FAIL' : reachable && positive ? 'PASS' : 'UNKNOWN', reachable, terminal };
     }
     if (!observationClass) return null;
     const payload = {

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

@@ -216,21 +216,20 @@ 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',
+    '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',
+      'hookEventName', 'additionalContext',
     ]);
     if (Object.keys(specific).some((key) => !specificKeys.has(key))) return false;
     if (specific.hookEventName !== 'PostToolUse') return false;
@@ -268,13 +267,23 @@ 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.
+// Codex 0.160.0 post-tool-use.command.output (extracted from the installed binary on
+// 2026-10-04) rejects terminalSequence, updatedToolOutput, and telemetry fields. The
+// host additionally rejects updatedMCPToolOutput semantically after schema parsing. Keep
+// supported control fields even when a shared body includes incompatible metadata: wrapping
+// the whole output as context alone would silently discard a security block.
 if (event === 'PostToolUse' && !validPostToolUseOutput(parsed)) {
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: { hookEventName: event, additionalContext: stdout.trim() },
-  }));
+  const normalized = {};
+  for (const key of ['continue', 'stopReason', 'suppressOutput', 'systemMessage', 'reason']) {
+    const type = ['continue', 'suppressOutput'].includes(key) ? 'boolean' : 'string';
+    if (typeof parsed[key] === type) normalized[key] = parsed[key];
+  }
+  if (parsed.decision === 'block') {
+    normalized.decision = 'block';
+    if (!normalized.reason?.trim()) normalized.reason = stdout.trim();
+  }
+  normalized.hookSpecificOutput = { hookEventName: event, additionalContext: stdout.trim() };
+  process.stdout.write(JSON.stringify(normalized));
   process.exit(0);
 }
 

package/plugin/scripts/project-capture-queue.mjs

@@ -6,6 +6,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { developmentHooksSuspended } from './development-maintenance.mjs';
 import { resolveTurnDb } from './turn-outcome-capture.mjs';
+import { enrichStateWithObservation } from './project-progression-hook.mjs';
 import { buildProjectProgression } from './project-progression-producer.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
 import { redactProgression } from './project-progression-contract.mjs';
@@ -57,6 +58,10 @@ export function queueCapture({ projectDir, originProjectDir = projectDir, event,
   if (!progression && !payload?.normalizedTransition) {
     try { progression = buildProjectProgression({ resolution: resolveProjectStore({ projectDir: originProjectDir }), projectDir: originProjectDir, payload, host, trigger: event }).projectProgression; } catch { return null; }
   }
+  // Freeze the bounded native observation before discarding raw host input. Replay receives no
+  // tool fields, so the native writer cannot append it twice.
+  if (progression && (payload?.tool_name || payload?.tool_input)) progression = { ...progression,
+    completeProjectState: enrichStateWithObservation(progression.completeProjectState, { ...payload, hook_event_name: event }) };
   // This queue is durable: never serialize arbitrary host prompts, tool input or output.
   const minimized = { session_id: payload?.session_id, hook_event_name: event,
     ...(progression ? { projectProgression: progression } : {}),
@@ -273,7 +278,8 @@ export function runOutboxReplay({ projectDir, token = process.env.RUVNET_REPLAY_
       for (const snapshot of store.outbox.pendingSnapshots()) {
         if (now() >= deadlineAt) return replayed;
         if (!refreshReplayLock(projectDir, held)) return replayed;
-        store.outbox.markCommitted(store.appendExact(snapshot));
+        store.captureFrozen(snapshot, { canCommit: () => refreshReplayLock(projectDir, held) });
+        // captureFrozen commits only the verified key, retaining conflicting original history.
         replayed += 1;
       }
       for (const file of queuedCaptures(projectDir)) {

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

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createProgressionSnapshot } from './project-progression-contract.mjs';
 import { ProjectProgressionStore } from './project-progression-store.mjs';
+import { redactText } from './continuity-events.mjs';
 
 const HOSTS = new Set(['claude', 'codex']);
 const CAPTURE_TRIGGERS = new Set([
@@ -105,15 +106,17 @@ function toolAction(payload) {
   const exitCode = Number.isSafeInteger(explicitCode)
     ? explicitCode
     : textualCode ? Number(textualCode[1]) : undefined;
-  const interrupted = responseRecord?.interrupted === true || responseRecord?.signal === 'SIGINT';
+  const error = boundedText(typeof responseRecord?.error === 'string' ? redactText(responseRecord.error) : undefined);
+  const signal = boundedText(typeof responseRecord?.signal === 'string' ? redactText(responseRecord.signal) : undefined);
+  const interrupted = responseRecord?.interrupted === true || Boolean(signal);
   const explicitError = responseRecord?.isError === true || payload.is_error === true;
   const declaredOutcome = ['success', 'failure', 'interrupted', 'unknown'].includes(responseRecord?.outcome)
     ? responseRecord.outcome : null;
-  const failed = explicitError || (Number.isSafeInteger(exitCode) && exitCode !== 0);
+  const failed = explicitError || Boolean(error) || (Number.isSafeInteger(exitCode) && exitCode !== 0);
   const terminal = failed || Number.isSafeInteger(exitCode)
     || responseRecord?.success === true || responseRecord?.ok === true;
   const outcome = payload.hook_event_name === 'PostToolUse'
-    ? (interrupted ? 'interrupted' : failed ? 'failure' : declaredOutcome || (terminal ? 'success' : 'unknown'))
+    ? (error ? 'failure' : interrupted ? 'interrupted' : failed ? 'failure' : declaredOutcome || (terminal ? 'success' : 'unknown'))
     : 'pending';
   const observation = {
     trigger: payload.hook_event_name,
@@ -121,7 +124,9 @@ function toolAction(payload) {
     ...(command ? { command } : {}),
     ...(filePath && !command ? { filePath } : {}),
     outcome,
-    ...(Number.isSafeInteger(exitCode) ? { exitCode } : {}),
+    ...(Number.isSafeInteger(exitCode) ? { exitCode } : responseRecord?.exit_code === null || responseRecord?.exitCode === null ? { exitCode: null } : {}),
+    ...(error ? { error } : {}),
+    ...(signal ? { signal } : {}),
     ...(interrupted ? { interrupted: true } : {}),
     ...(explicitError ? { isError: true } : {}),
   };
@@ -137,7 +142,7 @@ function toolAction(payload) {
   return observation;
 }
 
-function enrichStateWithObservation(state, payload) {
+export function enrichStateWithObservation(state, payload) {
   requireRecord(state, 'completeProjectState');
   const observation = toolAction(payload);
   if (!observation) return state;
@@ -164,6 +169,8 @@ export function captureProjectTransition({
   payload,
   projectDir,
   adapterVersion = readProgressionAdapterVersion(),
+  recoverFrozen = false,
+  canCommit,
   storeFactory = (options) => new ProjectProgressionStore(options),
 } = {}) {
   const normalizedHost = requireString(host, 'host').toLowerCase();
@@ -191,7 +198,7 @@ export function captureProjectTransition({
     aliased(progression, 'sourceIdentity', 'source_identity'),
     store.resolution.checkoutRoot, projectDir,
   );
-  const snapshot = createProgressionSnapshot({
+  let snapshot = createProgressionSnapshot({
     projectIdentity: store.resolution.projectIdentity,
     sourceIdentity,
     hostIdentity: { host: normalizedHost, adapterVersion },
@@ -206,7 +213,9 @@ export function captureProjectTransition({
       payload,
     ),
   });
-  const receipt = store.capture(snapshot);
+  let receipt;
+  if (recoverFrozen) ({ snapshot, receipt } = store.captureFrozen(snapshot, { canCommit }));
+  else receipt = store.capture(snapshot);
   verifyReceipt(snapshot, receipt);
   return { snapshot, receipt };
 }

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

@@ -2,6 +2,66 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 const OUTBOX_NAME = 'project-progression-outbox.jsonl';
+const READ_CHUNK_BYTES = 64 * 1024;
+
+// Decode only complete records, so a multibyte character crossing reads stays intact.
+function* readJsonl(file) {
+  let fd;
+  try { fd = fs.openSync(file, 'r'); } catch (error) { if (error.code === 'ENOENT') return; throw error; }
+  const chunk = Buffer.alloc(READ_CHUNK_BYTES);
+  let parts = [];
+  let line = 0;
+  const parse = (bytes, terminated) => {
+    if (!bytes.length) return undefined;
+    const text = bytes.toString('utf8');
+    if (!text.trim()) return undefined;
+    try { return JSON.parse(text); } catch {
+      if (!terminated) return undefined;
+      throw new Error(`malformed outbox record at line ${line}`);
+    }
+  };
+  try {
+    let length;
+    while ((length = fs.readSync(fd, chunk, 0, chunk.length, null))) {
+      let start = 0;
+      for (let end = 0; end < length; end += 1) {
+        if (chunk[end] !== 10) continue;
+        parts.push(Buffer.from(chunk.subarray(start, end)));
+        line += 1;
+        const record = parse(Buffer.concat(parts), true);
+        if (record !== undefined) yield record;
+        parts = []; start = end + 1;
+      }
+      if (start < length) parts.push(Buffer.from(chunk.subarray(start, length)));
+    }
+    if (parts.length) {
+      line += 1;
+      const record = parse(Buffer.concat(parts), false);
+      if (record !== undefined) yield record;
+    }
+  } finally { fs.closeSync(fd); }
+}
+
+// Inspect only the final record; preceding history is never decoded or copied.
+function finalRecord(fd, size) {
+  const parts = [];
+  let position = size;
+  while (position > 0) {
+    const length = Math.min(READ_CHUNK_BYTES, position);
+    position -= length;
+    const chunk = Buffer.alloc(length);
+    let read = 0;
+    while (read < length) {
+      const count = fs.readSync(fd, chunk, read, length - read, position + read);
+      if (!count) throw new Error('outbox tail changed during inspection');
+      read += count;
+    }
+    const delimiter = chunk.lastIndexOf(10);
+    parts.unshift(delimiter < 0 ? chunk : chunk.subarray(delimiter + 1));
+    if (delimiter >= 0) break;
+  }
+  return Buffer.concat(parts).toString('utf8');
+}
 
 function requireIdentity(value, label) {
   if (typeof value !== 'string' || !value) throw new TypeError(`${label} must be a non-empty string`);
@@ -31,8 +91,7 @@ export class ProgressionOutbox {
         const last = Buffer.alloc(1);
         fs.readSync(fd, last, 0, 1, size - 1);
         if (last[0] !== 10) {
-          const content = fs.readFileSync(fd, 'utf8');
-          try { JSON.parse(content.slice(content.lastIndexOf('\n') + 1)); }
+          try { JSON.parse(finalRecord(fd, size)); }
           catch { throw new Error('incomplete outbox final record; preserve and recover the torn tail before appending'); }
           separator = '\n';
         }
@@ -66,18 +125,23 @@ export class ProgressionOutbox {
     return this.appendRecord({ type: 'commit', ...receipt });
   }
 
-  records() {
-    if (!fs.existsSync(this.path)) return [];
-    const content = fs.readFileSync(this.path, 'utf8');
-    const lines = content.split('\n');
-    if (lines.at(-1) === '') lines.pop();
-    else {
-      // A missing delimiter is not a missing record; only a crash-torn JSON suffix is incomplete.
-      try { JSON.parse(lines.at(-1)); } catch { lines.pop(); }
+  /** Disposition of one frozen payload, never a commit for its conflicting original key. */
+  markRecovered(snapshot, receipt) {
+    for (const [label, value] of Object.entries({ eventKey: snapshot?.eventKey,
+      payloadDigest: snapshot?.payloadDigest, recoveryEventKey: receipt?.eventKey,
+      recoveryPayloadDigest: receipt?.payloadDigest, readbackDigest: receipt?.readbackDigest,
+      committedAt: receipt?.committedAt })) requireIdentity(value, label);
+    if (receipt.eventKey === snapshot.eventKey || receipt.readbackDigest !== receipt.payloadDigest) {
+      throw new Error('unverified recovery disposition');
     }
-    return lines.filter(Boolean).map((line, index) => {
-      try { return JSON.parse(line); } catch { throw new Error(`malformed outbox record at line ${index + 1}`); }
-    });
+    return this.appendRecord({ type: 'recovery', eventKey: snapshot.eventKey,
+      payloadDigest: snapshot.payloadDigest, recoveryEventKey: receipt.eventKey,
+      recoveryPayloadDigest: receipt.payloadDigest, readbackDigest: receipt.readbackDigest,
+      committedAt: receipt.committedAt });
+  }
+
+  records() {
+    return [...readJsonl(this.path)];
   }
 
   /**
@@ -92,7 +156,8 @@ export class ProgressionOutbox {
     const snapshots = new Map();
     const committed = new Map();
     const quarantined = new Map();
-    for (const record of this.records()) {
+    const recoveries = [];
+    for (const record of readJsonl(this.path)) {
       requireIdentity(record?.eventKey, 'outbox eventKey');
       requireIdentity(record?.payloadDigest, 'outbox payloadDigest');
       if (record.type === 'snapshot') {
@@ -103,6 +168,13 @@ export class ProgressionOutbox {
         const prior = committed.get(record.eventKey);
         if (prior && prior !== record.payloadDigest) quarantined.set(record.eventKey, 'outbox commit collision');
         committed.set(record.eventKey, record.payloadDigest);
+      } else if (record.type === 'recovery') {
+        requireIdentity(record.recoveryEventKey, 'recovery event key');
+        requireIdentity(record.recoveryPayloadDigest, 'recovery payload digest');
+        if (record.eventKey === record.recoveryEventKey || record.readbackDigest !== record.recoveryPayloadDigest) {
+          throw new Error('unverified recovery disposition');
+        }
+        recoveries.push(record);
       } else {
         throw new Error('unsupported outbox record');
       }
@@ -113,9 +185,18 @@ export class ProgressionOutbox {
         quarantined.set(record.eventKey, 'outbox commit digest mismatch');
       }
     }
+    const recovered = new Set(recoveries.filter((record) => {
+      const target = snapshots.get(record.recoveryEventKey)?.snapshot;
+      return !quarantined.has(record.recoveryEventKey)
+        && committed.get(record.recoveryEventKey) === record.recoveryPayloadDigest
+        && target?.payloadDigest === record.recoveryPayloadDigest
+        && target.recoveryDiagnostics?.originalEventKey === record.eventKey
+        && target.recoveryDiagnostics?.frozenPayloadDigest === record.payloadDigest;
+    }).map((record) => `${record.eventKey}:${record.payloadDigest}`));
     this.quarantine = [...quarantined].map(([eventKey, reason]) => ({ eventKey, reason }));
     return [...snapshots.values()]
-      .filter((record) => !quarantined.has(record.eventKey) && !committed.has(record.eventKey))
+      .filter((record) => !quarantined.has(record.eventKey) && !committed.has(record.eventKey)
+        && !recovered.has(`${record.eventKey}:${record.payloadDigest}`))
       .sort((left, right) => left.eventKey.localeCompare(right.eventKey))
       .map((record) => record.snapshot);
   }

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

@@ -29,6 +29,7 @@
  * within those bounds.
  */
 import crypto from 'node:crypto';
+import { enrichStateWithObservation } from './project-progression-hook.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import { digestCanonical, fieldAuthorityAllows, redactProgression, restoreProjectProgression } from './project-progression-contract.mjs';
@@ -250,6 +251,16 @@ export function buildProjectProgression({
     completeProjectState,
   });
   const projectProgression = redactedProgression;
+  // Compare the same redacted observation the native writer will append, without returning it
+  // twice. Tool input and terminal evidence must participate before the no-op decision.
+  const observedState = redactProgression(enrichStateWithObservation(
+    projectProgression.completeProjectState, { ...payload, hook_event_name: trigger },
+  )).value;
+  // A committed sequence is not an event identity: several boundaries may freeze before replay.
+  // Bind all immutable captured fields (including the native observation and occurrence time).
+  projectProgression.dedupId += `:${digestCanonical({
+    ...projectProgression, completeProjectState: observedState,
+  })}`;
 
   // RETENTION (ADR-073). Three capture boundaries per session times every session is unbounded
   // growth unless a capture that changes nothing writes nothing. Compare what a snapshot MEANS —
@@ -257,7 +268,7 @@ export function buildProjectProgression({
   // differ (sequence, timestamp, dedup id, the trigger that happens to be firing, and the evidence
   // block's own timestamps), because comparing those would make every capture look novel.
   const meaning = digestCanonical({
-    state: { ...projectProgression.completeProjectState, activeStep: null, evidence: null },
+    state: { ...observedState, activeStep: null, evidence: null },
     source: projectProgression.sourceIdentity,
   });
   const priorMeaning = heads.length === 1 ? digestCanonical({

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

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { ProgressionOutbox } from './project-progression-outbox.mjs';
 import {
+  createProgressionSnapshot,
   digestCanonical,
   restoreProjectProgression,
   validateProgressionSnapshot,
@@ -87,10 +88,26 @@ export function projectResumePayloadToBound(payload, maxOutputBytes) {
     });
   }
 
+  if (size() > maxOutputBytes && Array.isArray(summary.state?.resumeConflicts)) {
+    const groups = new Map();
+    for (const conflict of payload.state.resumeConflicts) {
+      if (!groups.has(conflict.field)) groups.set(conflict.field, []);
+      groups.get(conflict.field).push(conflict);
+    }
+    if (groups.size < payload.state.resumeConflicts.length) {
+      summary.state.resumeConflicts = [...groups].map(([field, conflicts]) => ({
+        field, conflictCount: conflicts.length,
+        valueCount: conflicts.reduce((count, conflict) => count + (conflict.values ?? []).length, 0),
+        conflictsDigest: digestCanonical(conflicts),
+      }));
+      omissions.push({ path: 'state.resumeConflicts', ...omissionSummary(payload.state.resumeConflicts) });
+    }
+  }
+
   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',
+    'observations', 'commands', 'proofArtifacts', 'changedFiles', 'completed', 'untested', 'decisions',
     'plan', 'inProgress', 'blockers', 'failures', 'acceptanceContract', 'provenance',
     'evidence', 'activeStep', 'activeProcess', 'sourceIdentity',
   ];
@@ -450,6 +467,41 @@ export class ProjectProgressionStore {
     return receipt;
   }
 
+  /** Frozen queue recovery never rewrites the conflicting row or marks its key committed. */
+  captureFrozen(snapshot, { canCommit } = {}) {
+    if (typeof canCommit !== 'function') throw new Error('frozen recovery requires replay fencing');
+    const fenced = () => { if (!canCommit()) throw new Error('progression recovery lost replay fencing'); };
+    fenced();
+    try { return { snapshot, receipt: this.capture(snapshot, { onPhase: fenced }) }; } catch (error) {
+      if (error.message !== 'progression readback digest mismatch') throw error;
+    }
+    // An independently retrieved exact canonical value must be valid for this project. A failed,
+    // absent, malformed or foreign read is never evidence that the immutable key collided.
+    const exact = this.retrieveSnapshots([snapshot.eventKey]);
+    if (exact.rejected.length || exact.snapshots.length !== 1) throw new Error('immutable collision is not verified');
+    const existing = exact.snapshots[0];
+    this.validateSnapshot(existing);
+    if (existing.eventKey !== snapshot.eventKey || existing.payloadDigest === snapshot.payloadDigest) {
+      throw new Error('immutable collision is not verified');
+    }
+    const identity = { originalEventKey: snapshot.eventKey,
+      frozenPayloadDigest: snapshot.payloadDigest, existingPayloadDigest: existing.payloadDigest };
+    const created = createProgressionSnapshot({ ...snapshot,
+      dedupId: `immutable-recovery:${digestCanonical(identity)}` });
+    // Preserve the frozen state and source exactly; diagnostics carry no instruction authority.
+    const { payloadDigest: _digest, ...body } = created;
+    body.redactions = snapshot.redactions;
+    body.recoveryDiagnostics = { kind: 'immutable-event-key-collision', authoritative: false, ...identity };
+    const recovered = Object.freeze({ ...body, payloadDigest: digestCanonical(body) });
+    this.validateSnapshot(recovered);
+    this.requireCaptureConsent(recovered);
+    fenced();
+    const receipt = this.capture(recovered, { onPhase: fenced });
+    fenced();
+    this.outbox.markRecovered(snapshot, receipt);
+    return { snapshot: recovered, receipt };
+  }
+
   replay() {
     const receipts = [];
     for (const snapshot of this.outbox.pendingSnapshots()) {

package/plugin/scripts/project-transition-hook.mjs

@@ -75,20 +75,25 @@ export function normalizeTransition(payload, event, { now = () => new Date().toI
   const toolInput = input.tool_input ?? {};
   const response = input.tool_response && typeof input.tool_response === 'object' ? input.tool_response : {};
   const exitCode = [response.exit_code, response.exitCode, response.status].find(Number.isSafeInteger);
-  const failure = event === 'PostToolUseFailure' || response.isError === true || input.is_error === true || (Number.isSafeInteger(exitCode) && exitCode !== 0);
-  const interrupted = response.interrupted === true || response.signal === 'SIGINT';
+  const error = typeof response.error === 'string' && response.error ? redactText(response.error).slice(0, 4096) : undefined;
+  const signal = typeof response.signal === 'string' && response.signal ? redactText(response.signal).slice(0, 100) : undefined;
+  const failure = Boolean(error) || event === 'PostToolUseFailure' || response.isError === true || input.is_error === true || (Number.isSafeInteger(exitCode) && exitCode !== 0);
+  const interrupted = response.interrupted === true || Boolean(signal);
+  const declaredOutcome = ['success', 'failure', 'interrupted', 'unknown'].includes(response.outcome) ? response.outcome : null;
   // Measured native Claude Bash PostToolUse has no exit code. Its completion envelope
   // is host-reported success, never an inferred exit-code zero. Other hosts stay unknown.
   const claudeBashCompletion = host === 'claude' && input.tool_name === 'Bash' && event === 'PostToolUse'
     && typeof response.stdout === 'string' && typeof response.stderr === 'string'
     && response.interrupted === false && typeof response.isImage === 'boolean'
     && typeof response.noOutputExpected === 'boolean';
-  const outcome = event === 'PreToolUse' ? 'pending' : interrupted ? 'interrupted' : failure ? 'failure'
-    : Number.isSafeInteger(exitCode) || response.success === true || response.ok === true || claudeBashCompletion ? 'success' : 'unknown';
+  const outcome = event === 'PreToolUse' ? 'pending' : error ? 'failure' : interrupted ? 'interrupted' : failure ? 'failure'
+    : declaredOutcome || (Number.isSafeInteger(exitCode) || response.success === true || response.ok === true || claudeBashCompletion ? 'success' : 'unknown');
   return { ...common, kind: 'tool-observation', tool: String(input.tool_name).split('__').at(-1).slice(0, 100),
     intent: semanticIntent(toolInput.description ?? toolInput.command ?? toolInput.cmd ?? toolInput.file_path), outcome,
     ...(outcome === 'success' && claudeBashCompletion ? { outcomeEvidence: 'claude-bash-completion' } : {}),
-    ...(event !== 'PreToolUse' && Number.isSafeInteger(exitCode) ? { exitCode } : {}) };
+    ...(event !== 'PreToolUse' && Number.isSafeInteger(exitCode) ? { exitCode } : event !== 'PreToolUse' && (response.exit_code === null || response.exitCode === null) ? { exitCode: null } : {}),
+    ...(event !== 'PreToolUse' && error ? { error } : {}),
+    ...(event !== 'PreToolUse' && signal ? { signal } : {}) };
 }
 
 export function readTransitionHistory(resolution, { deadlineAt = Infinity } = {}) {
@@ -107,6 +112,11 @@ export function readTransitionHistory(resolution, { deadlineAt = Infinity } = {}
 export function buildTransitionProgression({ resolution, observation, snapshots = [], sessionIdentity, host, sourceIdentity: originalSourceIdentity }) {
   const restored = restoreProjectProgression(snapshots, { expectedProjectIdentity: resolution.projectIdentity });
   if (snapshots.length && !restored.ok) throw new Error('nonempty transition journal has no coherent ancestry');
+  return buildRestoredTransitionProgression({ resolution, observation, snapshots, sessionIdentity, host, sourceIdentity: originalSourceIdentity }, restored);
+}
+
+// Only the validated result computed in this module can reach this private builder.
+function buildRestoredTransitionProgression({ resolution, observation, snapshots, sessionIdentity, host, sourceIdentity: originalSourceIdentity }, restored) {
   const heads = snapshots.filter((snapshot) => restored.heads.includes(snapshot.eventKey));
   const prior = restored.state;
   const empty = Object.fromEntries(['plan', 'completed', 'inProgress', 'blockers', 'failures', 'decisions', 'changedFiles', 'commands', 'proofArtifacts', 'untested', 'resumeConflicts'].map((key) => [key, []]));
@@ -145,7 +155,8 @@ export function captureNormalizedTransition(job, { readHistory = readTransitionH
   if (!normalized || normalized.observation?.authoritative !== false || !normalized.observation?.id
     || normalized.sourceIdentity?.checkoutPath !== resolution.checkoutRoot) throw new Error('invalid normalized transition binding');
   const snapshots = readHistory(resolution, { deadlineAt });
-  if (snapshots.length && !restoreProjectProgression(snapshots, { expectedProjectIdentity: resolution.projectIdentity }).ok) {
+  const restored = restoreProjectProgression(snapshots, { expectedProjectIdentity: resolution.projectIdentity });
+  if (snapshots.length && !restored.ok) {
     throw new Error('nonempty transition journal has no coherent ancestry');
   }
   // A failed first store already fsynced a snapshot to the outbox. If startup/replay committed
@@ -159,9 +170,9 @@ export function captureNormalizedTransition(job, { readHistory = readTransitionH
   if (committed) return { progressionCaptured: true, eventId: normalized.observation.id,
     receipt: { eventKey: committed.eventKey, payloadDigest: committed.payloadDigest,
       readbackDigest: committed.payloadDigest, readPath: 'canonical progression reader' } };
-  const progression = buildTransitionProgression({ resolution, observation: normalized.observation,
+  const progression = buildRestoredTransitionProgression({ resolution, observation: normalized.observation,
     snapshots, sessionIdentity: job.payload.session_id, host: job.host,
-    sourceIdentity: normalized.sourceIdentity });
+    sourceIdentity: normalized.sourceIdentity }, restored);
   const result = capture(job.originProjectDir, job.event, { host: job.host, budgetMs: Math.max(0, deadlineAt - now()),
     ...(makeStoreFactory ? { makeStoreFactory } : {}), writeMetadata: false,
     rawInput: JSON.stringify({ session_id: job.payload.session_id, hook_event_name: job.event, projectProgression: progression }),

package/plugin/scripts/session-snapshot-hook.mjs

@@ -163,7 +163,8 @@ export function runSessionSnapshotHook(projectDir, event, {
     if (payload.hook_event_name !== event) {
       throw new Error(`progression boundary mismatch: expected ${event}, received ${payload.hook_event_name}`);
     }
-    const result = captureProgression({ host, payload, projectDir, storeFactory: (options) => makeStoreFactory(now() + budgetMs)({ ...options, env }) });
+    const result = captureProgression({ host, payload, projectDir, recoverFrozen: Boolean(ordered),
+      canCommit: () => Boolean(ordered) && refreshReplayLock(resolveProjectStore({ projectDir }).projectRoot, ordered), storeFactory: (options) => makeStoreFactory(now() + budgetMs)({ ...options, env }) });
     return { ...idle, progressionCaptured: true, receipt: result.receipt };
   }