@piagent/platform 1.6.0 → 1.7.1

package/packages/piagent-core/extensions/acceptance-receipt.js

@@ -1,22 +1,33 @@
-import crypto from "node:crypto";
+import { inferAcceptanceObligations } from "./acceptance-obligations.js";
+export { inferAcceptanceObligations };
 import path from "node:path";
 import { changedFileAcceptanceCorpus, emptyAcceptanceCorpus, isAcceptanceTestPath } from "./acceptance-language-adapters.js";
 import { durableContextEvidenceEntries, hasDurableContextEvidence } from "./context-evidence.js";
 import { matchesAnyPath, normalizePathCandidate } from "./policy-core.js";
 import { baselineReturnRepresentationConflicts, returnRepresentationGuidance } from "./return-contract.js";
 import { hasLengthPrefixedIdentityKey, tenantAssertionSignals } from "./tenant-contract.js";
-import { latestObservedVerificationEvidence, meaningfulVerificationCommands, verificationEvidenceProvesStableTree } from "./verification-intelligence.js";
+import { acceptanceTextHash as sha256, acceptanceEvidenceKey as evidenceKey, compoundAcceptanceCriterion, acceptanceCriterionBindingValid, resetUnprovenCriterion, criterionBehaviorProofDisposition, criterionRequiresBehavioralProof, durableBehaviorProofRequired, genericCriterionEvidence, genericFallbackEvidence, isVerificationOnlyCriterion, verifierCommandsCoverTests } from "./acceptance-behavior-proof.js";
+import { allConfiguredVerifierEvidenceCurrent as hasCurrentPassingVerifier, latestObservedVerificationEvidence, meaningfulVerificationCommands, verificationEvidenceProvesStableTree, verificationProjectionWorkspaceRevision } from "./verification-intelligence.js";
 import {
   acceptanceContractProofGuidance,
   acceptanceContractSemanticConflicts,
   acceptanceInvalidInputEvidence
 } from "./acceptance-contract-semantics.js";
+import { malformedIdentifierCriterionText } from "./acceptance-identifier-criteria.js";
+import { contextualTemporalCriterion } from "./acceptance-temporal-contract.js";
+import { temporalProofReasonGuidance } from "./acceptance-boundary-guidance.js";
+import { acceptancePrecedenceContractGuidance, acceptancePrecedenceReceiptEvidence } from "./acceptance-precedence-contract.js";
 import { isCurrentWorkingTreeDigest, WORKING_TREE_DIGEST_ALGORITHM } from "./working-tree-digest.js";
-
+import { independentAcceptanceState, applyIndependentCriterionAssessment } from "./acceptance-independent-registry.js";
+import { missingAcceptanceProofCapabilities } from "./acceptance-proof-capability.js";
+import { boundAcceptanceClauseGroup, allClauseEvidence } from "./acceptance-clause-group.js";
+import { documentContentCriterionEvidence } from "./acceptance-document-content.js";
+import { invalidInputReceiptProof } from "./acceptance-invalid-input-receipt.js";
+import { boundaryTargetHasLiveSuccess } from "./acceptance-boundary-binding.js";
+import { apiBaselineCriterionEvidence, apiBaselineRecoveryProjection } from "./acceptance-api-baseline.js";
 export const ACCEPTANCE_RECEIPT_SCHEMA_VERSION = 1;
 export const ACCEPTANCE_STATUSES = new Set(["pending", "satisfied", "blocked"]);
 export const ACCEPTANCE_PRIORITIES = new Set(["normal", "critical"]);
-
 const CRITICAL_OBLIGATIONS = new Set([
   "authorization-deny-case",
   "tenant-boundary",
@@ -25,7 +36,6 @@ const CRITICAL_OBLIGATIONS = new Set([
   "boundary-case",
   "read-only-evidence"
 ]);
-
 const MAX_CRITERIA = 12;
 const MAX_EVIDENCE_PER_CRITERION = 8;
 const RECEIPT_FIELDS = new Set(["schemaVersion", "source", "promptHash", "generatedAt", "criteria", "provenance", "helperUsage"]);
@@ -34,7 +44,7 @@ const EVIDENCE_FIELDS = new Set(["kind", "summary", "paths", "command", "exitCod
 const PROVENANCE_FIELDS = new Set(["assurance", "disposition", "repairCount", "retryCount", "finalRecoveryDisposition", "failureRef", "recoveryRef", "handoffRef", "recordedAt"]);
 const FAILURE_REF_FIELDS = new Set(["evidenceDigest", "category", "captureRef"]);
 const RECOVERY_REF_FIELDS = new Set(["policyVersion", "action", "reasonCodes"]);
-const HELPER_USAGE_FIELDS = new Set(["mode", "used", "reasonCodes", "helpers", "recordedAt"]);
+const HELPER_USAGE_FIELDS = new Set(["mode", "used", "decision", "projectedSavingsRatio", "reasonCodes", "helpers", "recordedAt"]);
 const HELPER_ENTRY_FIELDS = new Set(["role", "disposition", "requestRef", "outputDigest", "calls", "tokens"]);
 const HELPER_ROLES = new Set(["retriever", "scout", "planner", "worker", "reviewer", "oracle", "researcher"]);
 const RECEIPT_DISPOSITIONS = new Set(["first-pass-success", "repaired-success", "blocked", "partial", "failed", "pending"]);
@@ -43,12 +53,7 @@ const RECOVERY_ACTIONS = new Set(["repair", "retry", "fresh-session", "ask-opera
 const FAILURE_CATEGORIES = new Set(["passed", "compile-typecheck", "test-assertion", "lint-format", "dependency-config", "environment", "provider-network", "permission-policy", "scope-protected-path", "flaky-infrastructure", "unknown"]);
 const HASH = /^[a-f0-9]{64}$/;
 const SAFE_REF = /^[a-z0-9.][a-z0-9:._/-]{0,511}$/i;
-const READ_ONLY_BOUNDARY = /\b(?:read-only|no edits?|do not edit(?: files?| source| project| repo)?|do not change (?:files?|source|project|repo)|do not mutate (?:files?|source|project|repo|workspace)|khong sua(?: file| source| project)?|khong edit(?: file| source| project)?|khong doi(?: file| source| project)?)\b/;
-
-function sha256(value) {
-  return crypto.createHash("sha256").update(String(value ?? "")).digest("hex");
-}
-
+const READ_ONLY_BOUNDARY = /\b(?:read-only|no\s+(?:code|source|project|file|workspace|repo(?:sitory)?)?\s*(?:edits?|changes?|mutations?)|do not\s+(?:edit|change|modify|mutate|touch)(?: files?| source| project| repo| workspace)?|leave\s+(?:the\s+)?(?:source|project|repo|workspace)\s+(?:unchanged|unmodified)|khong\s+(?:sua|edit|thay\s+doi)(?: file| source| project)?)\b/;
 function compactId(value, fallback = "criterion") {
   return String(value ?? fallback)
     .trim()
@@ -80,11 +85,6 @@ function normalizedText(value) {
     .replace(/[\u0300-\u036f]/g, "")
     .toLowerCase();
 }
-
-function includesAny(text, patterns) {
-  return patterns.some((pattern) => pattern.test(text));
-}
-
 function pathBoundaryMentioned(text, patterns) {
   const value = normalizedText(text);
   return uniqueStrings(patterns).some((pattern) => {
@@ -95,73 +95,26 @@ function pathBoundaryMentioned(text, patterns) {
     return value.includes(lower) || (Boolean(basename) && value.includes(basename));
   });
 }
-
+function readOnlyBoundaryTiedToPattern(text, patterns) {
+  return normalizedText(text)
+    .split(/(?:\r?\n+|[.!?;]+|\s+[—–]\s+)/)
+    .some((clause) => READ_ONLY_BOUNDARY.test(clause) && pathBoundaryMentioned(clause, patterns));
+}
 function changedFilesRespectBoundaries(changedFiles, boundaryPatterns) {
   const patterns = uniqueStrings(boundaryPatterns);
   if (patterns.length === 0) return true;
   return uniqueStrings(changedFiles).every((file) => !matchesAnyPath(file, patterns));
 }
-
-export function inferAcceptanceObligations(text, changeMode = "source-change") {
-  const value = normalizedText(text);
-  const accessControlText = value
-    .replace(/`[^`\n]*`/g, " ")
-    .replace(/\b(?:[a-z0-9_.@-]+\/)+[a-z0-9_.@/-]+\b/g, " ");
-  const obligations = [];
-  if (changeMode === "read-only" || READ_ONLY_BOUNDARY.test(value)) {
-    obligations.push("read-only-evidence");
-  }
-  const actorAccessControl = includesAny(accessControlText, [
-    /\b(?:admins?|roles?|owners?|users?|callers?|resources?)\b[\s\S]{0,80}\b(?:access|allow(?:ed)?|deny|denied|block(?:ed)?|forbid(?:den)?|manag(?:e|es|ed|ing))\b/,
-    /\b(?:access|allow(?:ed)?|deny|denied|block(?:ed)?|forbid(?:den)?|manag(?:e|es|ed|ing))\b[\s\S]{0,80}\b(?:admins?|roles?|owners?|users?|callers?|resources?)\b/
-  ]);
-  const explicitAuthorization = includesAny(accessControlText, [
-    /\bauth(?:orization)?\b/, /\bunauthoriz(?:ed|ation)\b/, /\bpermission\b/
-  ]) || actorAccessControl;
-  const ownerAccessControl = /\bowner\b/.test(accessControlText) && includesAny(accessControlText, [
-    /\busers?\b/, /\bresources?\b/, /\baccess\b/, /\bmanag(?:e|es|ed|ing)\b/, /\bauth(?:orization)?\b/, /\bpermission\b/, /\broles?\b/
+function acceptanceReadOnlyInferenceOptions(input, text) {
+  const boundaryPatterns = uniqueStrings([
+    ...(Array.isArray(input?.outOfScope) ? input.outOfScope : []),
+    ...(Array.isArray(input?.protectedPaths) ? input.protectedPaths : [])
   ]);
-  if (explicitAuthorization || ownerAccessControl) {
-    obligations.push("authorization-deny-case");
-  }
-  const tenantMentioned = includesAny(value, [/\btenants?\b/, /\bcross[- ]tenant\b/, /\bsame[- ]tenant\b/, /\btenantid\b/]);
-  const tenantStorage = tenantMentioned && includesAny(value, [
-    /\bcache\b/, /\bcache[- ]?key\b/, /\bstorage\b/, /\bcollision\b/, /\bentity\b/, /\bsame tuple\b/
-  ]);
-  const strongAuthorization = includesAny(accessControlText, [
-    /\bauth(?:orization)?\b/, /\bunauthoriz(?:ed|ation)\b/, /\bpermission\b/
-  ]);
-  const tenantActorAccess = tenantMentioned && actorAccessControl;
-  const explicitTenantAccessBoundary = includesAny(value, [
-    /\bcross[- ]tenant\b/, /\bsame[- ]tenant\b/, /\btenant boundary\b/,
-    /\btenantid\b[\s\S]{0,100}\b(?:equal|match|same non-empty|access|allow|deny|block|forbid)/,
-    /\b(?:access|allow|deny|block|forbid)[\s\S]{0,100}\btenantid\b/
-  ]) && includesAny(value, [
-    /\baccess\b/, /\ballow(?:ed)?\b/, /\b(?:deny|denied)\b/, /\bblock(?:ed)?\b/, /\bforbid(?:den)?\b/,
-    /\bequal\b/, /\bmatch(?:es|ed|ing)?\b/, /\bsame non-empty\b/
-  ]);
-  if (tenantMentioned) {
-    if (tenantStorage) {
-      obligations.push("tenant-storage-isolation");
-    } else if (strongAuthorization || ownerAccessControl || tenantActorAccess || explicitTenantAccessBoundary) {
-      obligations.push("tenant-boundary");
-    }
-  }
-  const explicitInvalidInput = includesAny(value, [/\binvalid\b/, /\btypeerror\b/, /\bthrow\b/, /\bnon-negative\b/, /\bpositive integer\b/, /\binteger\b/]);
-  const rejectInvalidInput = /\breject(?:s|ed|ion)?\b/.test(value)
-    && !/\breject(?:s|ed|ion)?\s+(?:no\s+)?valid\b/.test(value)
-    && includesAny(value, [/\binvalid\b/, /\bbad\b/, /\bmalformed\b/, /\bnegative\b/, /\bnull\b/, /\bundefined\b/, /\bnon[- ]?(?:number|numeric)\b/, /\bout[- ]?of[- ]?range\b/]);
-  if (explicitInvalidInput || rejectInvalidInput) {
-    obligations.push("invalid-input-rejection");
-  }
-  if (includesAny(value, [/\bboundary\b/, /\bceil(?:ing)?\b/, /\bclamp\b/, /\bmin(?:imum)?\b/, /\bmax(?:imum)?\b/, /\binclusive\b/, /\bzero\b/, /\b0\b/, /\bexpiry\b/, /\bround(?:ing)?\b/, /\bedge\b/, /\bfalsey\b/, /\bfalsy\b/, /\bnullish\b/, /\bdefault(?:s)?\b/, /\bpreserv(?:e|ed|es|ing)\b/])) {
-    obligations.push("boundary-case");
-  }
-  if (includesAny(value, [/\bmutation\b/, /\bunchanged\b/, /\bwithout changing\b/, /\bbackward\b/, /\bapi\b/, /\bexported api\b/, /\bfocused\b/])) {
-    obligations.push("backward-compatibility");
-  }
-  if (changeMode === "source-change") obligations.push("verification-evidence");
-  return [...new Set(obligations)];
+  return {
+    mutationPolicy: input?.mutationPolicy,
+    readOnlyBoundary: boundaryPatterns.length > 0
+      && readOnlyBoundaryTiedToPattern(text, boundaryPatterns)
+  };
 }
 
 function generatedCriterionForObligation(obligation) {
@@ -191,7 +144,6 @@ const GENERATED_ACCEPTANCE_TEXTS = new Set([
   "authorization-deny-case", "tenant-boundary", "tenant-storage-isolation", "invalid-input-rejection", "boundary-case",
   "backward-compatibility", "read-only-evidence", "verification-evidence"
 ].map((obligation) => generatedCriterionForObligation(obligation)));
-
 function acceptanceTaskText(task) {
   return [
     task?.summary,
@@ -209,7 +161,7 @@ function acceptanceCriterionText(task, criterion) {
     ? matched
     : acceptanceTaskText(task);
 }
-
+function invalidInputCriterionText(task, criterion) { const selected = acceptanceCriterionText(task, criterion), identifierContext = malformedIdentifierCriterionText(selected, task, GENERATED_ACCEPTANCE_TEXTS); return contextualTemporalCriterion(identifierContext, selected, task, GENERATED_ACCEPTANCE_TEXTS); }
 /**
  * Produce bounded, task-derived proof guidance without a second model call.
  * These hints remain generic: they describe semantic partitions from the
@@ -227,8 +179,9 @@ function semanticConflictReasons(obligation, task, corpus, criterion) {
 
 /**
  * Surface a concrete existing return contract before implementation starts.
- * This is intentionally source-derived and bounded to exact in-scope files;
- * it does not guess from benchmark scenario names or hidden expectations.
+ * This is intentionally source-derived and bounded to exact known files; it
+ * does not turn the task's initial focus into write authority or guess from
+ * benchmark scenario names and hidden expectations.
  */
 export function acceptanceBaselineGuidance(task, options = {}) {
   if (!options.cwd) return [];
@@ -237,7 +190,7 @@ export function acceptanceBaselineGuidance(task, options = {}) {
     ...(Array.isArray(task?.changedFiles) ? task.changedFiles : []),
     ...(Array.isArray(task?.observedChangedFiles) ? task.observedChangedFiles : [])
   ]).filter((file) => !/[?*\[\]{}]/.test(file) && !isAcceptanceTestPath(file));
-  return returnRepresentationGuidance(acceptanceTaskText(task), options.cwd, files);
+  return uniqueStrings([...returnRepresentationGuidance(acceptanceTaskText(task), options.cwd, files), ...acceptancePrecedenceContractGuidance({ taskText: acceptanceTaskText(task), sourceEntries: changedFileAcceptanceCorpus(options.cwd, files).sourceEntries })]);
 }
 
 export function acceptanceSemanticConflicts(task, options = {}) {
@@ -247,7 +200,11 @@ export function acceptanceSemanticConflicts(task, options = {}) {
     : { ...emptyAcceptanceCorpus(changedFiles.length > 0 ? changedFiles : ["inline.js"]), sourceText: normalizedText(options.sourceText), allText: normalizedText(options.sourceText) };
   if (!corpus.adapter.proofCapable) return [];
   const obligations = task?.acceptanceReceipt?.criteria?.map((criterion) => criterion.obligation)
-    ?? inferAcceptanceObligations(acceptanceTaskText(task), task?.changeMode);
+    ?? inferAcceptanceObligations(
+      acceptanceTaskText(task),
+      task?.changeMode,
+      acceptanceReadOnlyInferenceOptions(task, acceptanceTaskText(task))
+    );
   return uniqueStrings([
     ...obligations.flatMap((obligation) => semanticConflictReasons(obligation, task, corpus)),
     ...(options.cwd ? baselineReturnRepresentationConflicts(acceptanceTaskText(task), options.cwd, corpus.sourceFiles) : [])
@@ -258,7 +215,6 @@ function criterionId(text, obligation, index) {
   const prefix = compactId(obligation ?? "criterion").slice(0, 24);
   return `ac-${String(index + 1).padStart(2, "0")}-${prefix}-${sha256(text).slice(0, 8)}`.slice(0, 80);
 }
-
 export function buildAcceptanceReceipt(input = {}) {
   const changeMode = input.changeMode === "read-only" ? "read-only" : "source-change";
   const baseText = [
@@ -266,12 +222,26 @@ export function buildAcceptanceReceipt(input = {}) {
     input.expectedOutput,
     ...(Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : [])
   ].filter(Boolean).join("\n");
-  const obligations = inferAcceptanceObligations(baseText, changeMode);
+  const obligations = inferAcceptanceObligations(
+    baseText,
+    changeMode,
+    acceptanceReadOnlyInferenceOptions(input, baseText)
+  );
+  // Generated lifecycle metadata may suggest advisory checks, but cannot
+  // create a mandatory product requirement absent from operator intent.
+  // Keep the full receipt hash and useful existing follow-up diagnostics.
+  const operatorText = [input.summary, ...(Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : [])].filter(Boolean).join("\n");
+  const operatorObligations = new Set(inferAcceptanceObligations(operatorText, changeMode,
+    acceptanceReadOnlyInferenceOptions(input, operatorText)));
   const texts = uniqueStrings(Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : []);
   const generatedObligations = new Map();
   for (const obligation of obligations) {
     const generated = generatedCriterionForObligation(obligation);
-    if (!texts.some((text) => inferAcceptanceObligations(text, changeMode).includes(obligation))) {
+    if (!texts.some((text) => inferAcceptanceObligations(
+      text,
+      changeMode,
+      acceptanceReadOnlyInferenceOptions(input, text)
+    ).includes(obligation))) {
       texts.push(generated);
       generatedObligations.set(generated, obligation);
     }
@@ -282,17 +252,25 @@ export function buildAcceptanceReceipt(input = {}) {
       : generatedCriterionForObligation("verification-evidence"));
   }
   const acceptanceCriteria = texts.slice(0, MAX_CRITERIA);
+  const durableBehaviorProof = durableBehaviorProofRequired(input.source === "runtime" ? operatorText : baseText, changeMode);
   const criteria = acceptanceCriteria.map((text, index) => {
-    const inferred = inferAcceptanceObligations(text, changeMode);
+    const inferred = inferAcceptanceObligations(
+      text,
+      changeMode,
+      acceptanceReadOnlyInferenceOptions(input, text)
+    );
     const obligation = generatedObligations.get(text)
       ?? inferred.find((item) => item !== "verification-evidence" && item !== "backward-compatibility")
-      ?? inferred[0]
+      ?? (isVerificationOnlyCriterion(text) ? "verification-evidence" : undefined)
+      ?? (inferred.includes("backward-compatibility") ? "backward-compatibility" : undefined)
       ?? "requested-behavior";
     return {
       id: criterionId(text, obligation, index),
       hash: sha256(text),
       obligation,
-      priority: CRITICAL_OBLIGATIONS.has(obligation) ? "critical" : "normal",
+      priority: input.source === "runtime" && generatedObligations.has(text) && !operatorObligations.has(obligation)
+        ? "normal"
+        : compoundAcceptanceCriterion(text) || CRITICAL_OBLIGATIONS.has(obligation) || (durableBehaviorProof && obligation !== "verification-evidence") ? "critical" : "normal",
       status: "pending",
       evidence: []
     };
@@ -351,20 +329,30 @@ export function normalizeAcceptanceReceipt(value) {
 
 function normalizeHelperUsage(value) {
   if (!isRecord(value) || !["off", "recommend", "on"].includes(value.mode)) return undefined;
-  const helpers = Array.isArray(value.helpers) ? value.helpers.slice(0, 3).filter(isRecord).map((item) => ({
+  const rawHelpers = Array.isArray(value.helpers) ? value.helpers.slice(0, 3).filter(isRecord) : [];
+  const helpers = rawHelpers.map((item) => ({
     role: HELPER_ROLES.has(item.role) ? item.role : "scout",
     disposition: compactId(item.disposition ?? "unknown"),
     requestRef: HASH.test(String(item.requestRef)) ? item.requestRef : sha256(item.requestRef),
     outputDigest: item.outputDigest === null || HASH.test(String(item.outputDigest)) ? item.outputDigest : null,
     calls: Number.isInteger(item.calls) ? Math.max(0, Math.min(100, item.calls)) : 0,
     tokens: Number.isInteger(item.tokens) ? Math.max(0, Math.min(100_000_000, item.tokens)) : 0
-  })) : [];
-  return { mode: value.mode, used: helpers.some((item) => !["solo", "recommend", "unavailable", "blocked"].includes(item.disposition)), reasonCodes: uniqueStrings(value.reasonCodes).map(compactId).slice(0, 16), helpers, recordedAt: validTimestamp(value.recordedAt) ? value.recordedAt : new Date().toISOString() };
+  }));
+  const used = helpers.some((item) => !["solo", "recommend", "unavailable", "blocked"].includes(item.disposition));
+  const helperDecision = rawHelpers.find((item) => ["dispatch", "skip"].includes(item.decision))?.decision;
+  const decision = ["dispatch", "skip"].includes(value.decision) ? value.decision : helperDecision ?? (used ? "dispatch" : "skip");
+  const rawProjectedSavings = typeof value.projectedSavingsRatio === "number"
+    ? value.projectedSavingsRatio
+    : rawHelpers.find((item) => typeof item.projectedSavingsRatio === "number")?.projectedSavingsRatio;
+  const projectedSavingsRatio = typeof rawProjectedSavings === "number" && Number.isFinite(rawProjectedSavings)
+    ? Math.max(-10, Math.min(1, rawProjectedSavings))
+    : null;
+  return { mode: value.mode, used, decision, projectedSavingsRatio, reasonCodes: uniqueStrings(value.reasonCodes).map(compactId).slice(0, 16), helpers, recordedAt: validTimestamp(value.recordedAt) ? value.recordedAt : new Date().toISOString() };
 }
 
 export function applyAcceptanceHelperUsage(task, input = {}) {
   const receipt = normalizeAcceptanceReceipt(task?.acceptanceReceipt); if (!receipt) return task;
-  const helperUsage = normalizeHelperUsage({ mode: input.mode ?? "off", reasonCodes: input.reasonCodes ?? [], helpers: input.helpers ?? [], recordedAt: input.recordedAt ?? new Date().toISOString() });
+  const helperUsage = normalizeHelperUsage({ mode: input.mode ?? "off", decision: input.decision, projectedSavingsRatio: input.projectedSavingsRatio, reasonCodes: input.reasonCodes ?? [], helpers: input.helpers ?? [], recordedAt: input.recordedAt ?? new Date().toISOString() });
   return { ...task, acceptanceReceipt: { ...receipt, criteria: structuredClone(task.acceptanceReceipt.criteria), helperUsage } };
 }
 
@@ -525,17 +513,6 @@ function normalizeAcceptanceEvidence(value) {
   };
 }
 
-function evidenceKey(evidence) {
-  return JSON.stringify({
-    kind: evidence.kind,
-    summary: evidence.summary,
-    paths: evidence.paths ?? [],
-    command: evidence.command,
-    exitCode: evidence.exitCode,
-    workingTreeDigest: evidence.workingTreeDigest
-  });
-}
-
 function addEvidence(criterion, evidence, recordedAt) {
   const normalized = normalizeAcceptanceEvidence({ ...evidence, recordedAt });
   if (!normalized) return false;
@@ -562,10 +539,10 @@ function declaredCallableNames(sourceText) {
   return names;
 }
 
-function contractCallableTargets(task, criterion, sourceText = "") {
+function contractCallableTargets(task, criterion, sourceText = "", criterionText) {
   const ignored = new Set(["api", "boolean", "date", "error", "false", "null", "string", "true", "typeerror", "undefined"]);
   const explicit = [];
-  const text = acceptanceCriterionText(task, criterion);
+  const text = criterionText ?? acceptanceCriterionText(task, criterion);
   let previousEnd = 0;
   let roleGroup = false;
   for (const match of text.matchAll(/`([A-Za-z_$][A-Za-z0-9_$]*)\s*\([^`]*\)`/g)) {
@@ -587,12 +564,12 @@ function contractCallableTargets(task, criterion, sourceText = "") {
   return uniqueStrings([primary.name, ...productEntrypoints.map(({ name }) => name)]).slice(0, 8);
 }
 
-function namedCodeTargets(task, criterion, sourceText = "") {
-  const text = acceptanceCriterionText(task, criterion);
+function namedCodeTargets(task, criterion, sourceText = "", criterionText) {
+  const text = criterionText ?? acceptanceCriterionText(task, criterion);
   const ignored = new Set([
     "api", "boolean", "date", "error", "false", "null", "string", "true", "typeerror", "undefined"
   ]);
-  const targets = contractCallableTargets(task, criterion, sourceText);
+  const targets = contractCallableTargets(task, criterion, sourceText, text);
   const callables = declaredCallableNames(sourceText);
   for (const sentence of text.split(/(?<=[.!?])\s+/)) {
     if (!/\b(?:validat(?:e|es|ed|ion)|invalid|reject(?:s|ed|ion)?|throw(?:s|ing)?|malformed)\b/i.test(sentence)) continue;
@@ -602,10 +579,7 @@ function namedCodeTargets(task, criterion, sourceText = "") {
   }
   return uniqueStrings(targets).slice(0, 8);
 }
-
-function explicitlyCallableTargets(task, criterion, sourceText = "") {
-  return contractCallableTargets(task, criterion, sourceText);
-}
+function explicitlyCallableTargets(task, criterion, sourceText = "", criterionText) { return contractCallableTargets(task, criterion, sourceText, criterionText); }
 
 function booleanAssertionSignals(testText) {
   const text = String(testText ?? "");
@@ -633,8 +607,8 @@ function hasStructuredCompositeIdentity(sourceText) {
   return jsonTuple || nestedLookup || hasLengthPrefixedIdentityKey(text);
 }
 
-function focusedContractEvidence(obligation, task, corpus, verifierEvidence, criterion) {
-  if (!verifierEvidence || corpus.sourceFiles.length === 0 || corpus.testFiles.length === 0) return undefined;
+function focusedContractEvidence(obligation, task, corpus, verifierEvidence, criterion, cwd) {
+  if (!verifierEvidence || corpus.sourceFiles.length === 0 || !verifierCommandsCoverTests(task, corpus.testFiles, cwd)) return undefined;
   const targets = namedCodeTargets(task, criterion, corpus.sourceText);
   const targetCoverage = targets.length === 0 || targets.every((target) => (
     new RegExp(`\\b${escapeRegex(target.toLowerCase())}\\b`).test(corpus.testText)
@@ -670,23 +644,12 @@ function focusedContractEvidence(obligation, task, corpus, verifierEvidence, cri
   };
 }
 
-function hasCurrentPassingVerifier(task, currentWorkingTreeDigest) {
-  if (task?.workingTreeDigestAlgorithm !== WORKING_TREE_DIGEST_ALGORITHM
-    || !isCurrentWorkingTreeDigest(currentWorkingTreeDigest)) return false;
-  const planned = meaningfulVerificationCommands(task?.verifyCommands ?? []);
-  const latest = latestObservedVerificationEvidence(task?.verifyEvidence);
-  return planned.length > 0 && planned.every((command) => {
-    const evidence = latest.get(command.trim());
-    return verificationEvidenceProvesStableTree(evidence, currentWorkingTreeDigest);
-  });
-}
-
-function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDigest, criterion) {
-  const passingVerifier = hasCurrentPassingVerifier(task, currentWorkingTreeDigest);
+function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDigest, criterion, cwd, workspaceRevisionDigest, sourceProofRequiredIds, apiBaselineEvidence, strictClauseProof = false) {
+  const passingVerifier = hasCurrentPassingVerifier(task, currentWorkingTreeDigest, workspaceRevisionDigest);
   const latestVerifyEvidence = latestObservedVerificationEvidence(task?.verifyEvidence);
   const verifyEvidence = meaningfulVerificationCommands(task?.verifyCommands ?? [])
     .map((command) => latestVerifyEvidence.get(command.trim()))
-    .filter((evidence) => verificationEvidenceProvesStableTree(evidence, currentWorkingTreeDigest));
+    .filter((evidence) => verificationEvidenceProvesStableTree(evidence, currentWorkingTreeDigest, workspaceRevisionDigest));
   const verifier = verifyEvidence[0];
   const verifierEvidence = verifier ? {
     kind: "verify-command",
@@ -696,10 +659,22 @@ function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDiges
     workingTreeDigest: currentWorkingTreeDigest
   } : undefined;
   if (semanticConflictReasons(obligation, task, corpus, criterion).length > 0) return undefined;
+  // An exact API-preservation clause cannot borrow weaker evidence from an inferred category.
+  const api = apiBaselineCriterionEvidence({ task, criterion, cwd, corpus, currentWorkingTreeDigest, workspaceRevisionDigest, apiBaselineEvidence });
+  if (api.handled) return api.evidence;
+  const document = documentContentCriterionEvidence({ task, criterion, corpus, cwd, passingVerifier, verifierEvidence, currentWorkingTreeDigest, workspaceRevisionDigest });
+  if (document.handled) return document.evidence;
+  // Group children require a checker covering the complete clause. Legacy
+  // lexical/category matches may cover only one phrase in a longer sentence.
+  if (strictClauseProof) {
+    const text = acceptanceCriterionText(task, criterion);
+    return /^(?:Run the configured verification[.]?|The configured verification command passes after the final mutation[.]?)$/.test(text)
+      && passingVerifier ? verifierEvidence : undefined;
+  }
 
   if (obligation === "read-only-evidence") {
     const readOnlyEvidence = durableContextEvidenceEntries(task);
-    const readOnlyOk = task.changeMode === "read-only"
+    const readOnlyOk = (task.changeMode === "read-only" || task.mutationPolicy === "forbidden")
       && corpus.files.length === 0
       && hasDurableContextEvidence(task);
     if (readOnlyOk) return {
@@ -716,9 +691,9 @@ function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDiges
       ].filter(Boolean).join("\n");
       const combinedText = `${taskText}\n${corpus.allText}`;
       const sourceChangeReadOnlyOk = corpus.files.length > 0
-        && READ_ONLY_BOUNDARY.test(normalizedText(combinedText))
+        && boundaryPatterns.length > 0
+        && readOnlyBoundaryTiedToPattern(combinedText, boundaryPatterns)
         && changedFilesRespectBoundaries(corpus.files, boundaryPatterns)
-        && (boundaryPatterns.length === 0 || pathBoundaryMentioned(combinedText, boundaryPatterns))
         && hasDurableContextEvidence(task);
       if (sourceChangeReadOnlyOk) {
         return {
@@ -732,54 +707,56 @@ function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDiges
     return undefined;
   }
 
-  if (obligation === "verification-evidence" || obligation === "requested-behavior" || obligation === "backward-compatibility") {
-    if (!passingVerifier) return undefined;
-    return verifierEvidence;
+  const precedence = acceptancePrecedenceReceiptEvidence({ obligation, taskText: acceptanceCriterionText(task, criterion), sourceEntries: corpus.sourceEntries, testEntries: corpus.testEntries, namedTargets: namedCodeTargets(task, criterion, corpus.sourceText), passingVerifier, verifierEvidence, sourceFiles: corpus.sourceFiles, testFiles: corpus.testFiles, verifierCoversTests: verifierCommandsCoverTests(task, corpus.testFiles, cwd) }); if (precedence.handled) return precedence.evidence;
+
+  const generic = genericCriterionEvidence({ obligation, task, criterion, taskText: acceptanceTaskText(task), corpus, verifierEvidence, passingVerifier, cwd });
+  if (generic.handled) {
+    // A neutral artifact (for example a runbook) has no executable source
+    // linkage. Passing project smoke cannot establish its required content;
+    // use the existing finite missing-proof handoff without granting authority.
+    if (!generic.evidence && passingVerifier && criterion.priority === "critical"
+      && obligation === "requested-behavior" && corpus.adapter.status === "neutral"
+      && corpus.files.length > 0) sourceProofRequiredIds?.add(criterion.id);
+    return generic.evidence;
   }
 
   if (!corpus.adapter.proofCapable) return undefined;
 
   if (obligation === "tenant-boundary") {
-    return focusedContractEvidence(obligation, task, corpus, verifierEvidence, criterion);
+    return focusedContractEvidence(obligation, task, corpus, verifierEvidence, criterion, cwd);
   }
 
   if (obligation === "tenant-storage-isolation") {
-    return focusedContractEvidence(obligation, task, corpus, verifierEvidence, criterion);
+    return focusedContractEvidence(obligation, task, corpus, verifierEvidence, criterion, cwd);
   }
 
   if (obligation === "authorization-deny-case") {
-    return focusedContractEvidence(obligation, task, corpus, verifierEvidence, criterion);
+    return focusedContractEvidence(obligation, task, corpus, verifierEvidence, criterion, cwd);
   }
 
   if (obligation === "invalid-input-rejection") {
-    const { sourceOk, testOk } = acceptanceInvalidInputEvidence({
-      taskText: acceptanceCriterionText(task, criterion),
-      sourceText: corpus.sourceText,
-      testText: corpus.testText,
-      sourceEntries: corpus.sourceEntries,
-      testEntries: corpus.testEntries,
-      namedTargets: namedCodeTargets(task, criterion, corpus.sourceText),
-      provenanceTargets: explicitlyCallableTargets(task, criterion, corpus.sourceText)
+    const criterionText = invalidInputCriterionText(task, criterion);
+    const result = invalidInputReceiptProof({
+      proofInput: { taskText: criterionText, contextText: acceptanceTaskText(task), sourceText: corpus.sourceText, testText: corpus.testText,
+        sourceEntries: corpus.sourceEntries, testEntries: corpus.testEntries,
+        namedTargets: namedCodeTargets(task, criterion, corpus.sourceText, criterionText),
+        provenanceTargets: explicitlyCallableTargets(task, criterion, corpus.sourceText, criterionText) },
+      passingVerifier, verifierEvidence, sourceFiles: corpus.sourceFiles, testFiles: corpus.testFiles,
+      verifierCoversTests: verifierCommandsCoverTests(task, corpus.testFiles, cwd)
     });
-    if (passingVerifier && corpus.sourceFiles.length > 0 && corpus.testFiles.length > 0 && sourceOk && testOk) {
-      return {
-        ...verifierEvidence,
-        kind: "verifier-backed-focused-test",
-        summary: "Configured verifier passed with focused invalid-input tests for named entrypoints.",
-        paths: [...new Set([...corpus.sourceFiles, ...corpus.testFiles])]
-      };
-    }
-    return undefined;
+    if (result.sourceProofRequired) sourceProofRequiredIds?.add(criterion.id);
+    return result.evidence;
   }
 
   if (obligation === "boundary-case") {
+    if (!boundaryTargetHasLiveSuccess({ task, criterion, corpus })) return undefined;
     const expirySourceOk = /\b(?:expiresat|expiry|expires|expired|timestamp|now)\b/.test(corpus.sourceText)
       && /(?:===|!==|>=|<=|>|<)/.test(corpus.sourceText);
     const testOk = /boundary|edge|zero|ceil|clamp|min|max|inclusive|exact|equal|equality|expired|expiry|past|future|partial|round|falsey|falsy|nullish|default|retrylimit|label|\bfalse\b|\b0\b/.test(corpus.testText);
     const sourceOk = /math\.ceil|ceil|clamp|min|max|round|zero|return\s+0|\?\?|nullish|falsey|falsy|default|retrylimit|enabled|label/.test(corpus.sourceText)
       || expirySourceOk
       || (passingVerifier && corpus.sourceFiles.length > 0 && testOk);
-    if (passingVerifier && corpus.sourceFiles.length > 0 && corpus.testFiles.length > 0 && sourceOk && testOk) {
+    if (passingVerifier && corpus.sourceFiles.length > 0 && verifierCommandsCoverTests(task, corpus.testFiles, cwd) && sourceOk && testOk) {
       return {
         ...verifierEvidence,
         kind: "verifier-backed-focused-test",
@@ -790,19 +767,56 @@ function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDiges
     return undefined;
   }
 
-  return passingVerifier ? verifierEvidence : undefined;
+  return genericFallbackEvidence({ behavioral: generic.behavioral, corpus, verifierEvidence, passingVerifier });
 }
 
 export function refreshAcceptanceReceipt(task, options = {}) {
   const receipt = normalizeAcceptanceReceipt(task?.acceptanceReceipt);
-  if (!receipt) return { task, missing: [], criticalMissing: [], changed: false };
+  if (!receipt) return { task, missing: [], criticalMissing: [], adapterAbstained: [], independentRequired: [], sourceProofRequired: [], changed: false };
   const cwd = options.cwd;
   const changedFiles = uniqueStrings(options.changedFiles ?? task.changedFiles ?? task.observedChangedFiles ?? []);
   const currentWorkingTreeDigest = options.currentWorkingTreeDigest;
+  const workspaceRevisionDigest = verificationProjectionWorkspaceRevision(task, options);
   const recordedAt = options.recordedAt ?? new Date().toISOString();
   const corpus = cwd ? changedFileAcceptanceCorpus(cwd, changedFiles) : emptyAcceptanceCorpus(changedFiles);
+  const independent = independentAcceptanceState(cwd, task, currentWorkingTreeDigest).assessments;
+  const sourceProofRequiredIds = new Set();
   let changed = false;
-  for (const criterion of receipt.criteria) {
+  for (const [index, criterion] of receipt.criteria.entries()) {
+    if (!acceptanceCriterionBindingValid(task, receipt, criterion, index)) {
+      changed = resetUnprovenCriterion(criterion) || changed;
+      continue;
+    }
+    const compound = compoundAcceptanceCriterion(task.acceptanceCriteria[index]);
+    const runtimeArtifactContent = receipt.source === "runtime" && task.changeMode === "source-change"
+      && criterion.obligation === "requested-behavior" && corpus.adapter.status === "neutral"
+      && corpus.files.length > 0;
+    if ((compound || runtimeArtifactContent) && criterion.priority !== "critical") { criterion.priority = "critical"; changed = true; }
+    if (independent.has(criterion.id)) { changed = applyIndependentCriterionAssessment(criterion, independent.get(criterion.id), currentWorkingTreeDigest, recordedAt) || changed; continue; }
+    if (compound) {
+      const group = boundAcceptanceClauseGroup(task, receipt, criterion, index);
+      const childEvidence = group && task.changeMode === "source-change" && cwd
+        && task.workingTreeDigestAlgorithm === WORKING_TREE_DIGEST_ALGORITHM && isCurrentWorkingTreeDigest(currentWorkingTreeDigest)
+        ? group.children.map(child => {
+          const inferred = inferAcceptanceObligations(child.text, task.changeMode);
+          const obligation = inferred.find(item => item !== "verification-evidence" && item !== "backward-compatibility")
+            ?? (isVerificationOnlyCriterion(child.text) ? "verification-evidence" : undefined)
+            ?? (inferred.includes("backward-compatibility") ? "backward-compatibility" : "requested-behavior");
+          const derived = { id: child.id, hash: child.hash, obligation, priority: "critical", status: "pending", evidence: [] };
+          const projected = { ...task, expectedOutput: [task.expectedOutput, group.context].filter(Boolean).join("\n"),
+            acceptanceCriteria: task.acceptanceCriteria.map((text, position) => position === index ? child.text : text),
+            acceptanceReceipt: { ...receipt, criteria: receipt.criteria.map((item, position) => position === index ? derived : item) } };
+          const evidence = evidenceForObligation(obligation, projected, corpus, currentWorkingTreeDigest, derived, cwd,
+            workspaceRevisionDigest, undefined, options.apiBaselineEvidence, true);
+          return { id: child.id, hash: child.hash, evidence };
+        }) : [];
+      const evidence = allClauseEvidence(group, childEvidence, currentWorkingTreeDigest);
+      const previous = JSON.stringify(criterion);
+      resetUnprovenCriterion(criterion);
+      if (evidence) addEvidence(criterion, evidence, recordedAt);
+      changed = JSON.stringify(criterion) !== previous || changed;
+      continue;
+    }
     if (task?.changeMode === "source-change" && cwd) {
       const previousStatus = criterion.status;
       const previousEvidence = (criterion.evidence ?? []).map(evidenceKey);
@@ -810,7 +824,7 @@ export function refreshAcceptanceReceipt(task, options = {}) {
       criterion.evidence = [];
       const evidence = task?.workingTreeDigestAlgorithm === WORKING_TREE_DIGEST_ALGORITHM
         && isCurrentWorkingTreeDigest(currentWorkingTreeDigest)
-        ? evidenceForObligation(criterion.obligation, task, corpus, currentWorkingTreeDigest, criterion)
+        ? evidenceForObligation(criterion.obligation, task, corpus, currentWorkingTreeDigest, criterion, cwd, workspaceRevisionDigest, sourceProofRequiredIds, options.apiBaselineEvidence)
         : undefined;
       if (evidence) addEvidence(criterion, evidence, recordedAt);
       const nextEvidence = (criterion.evidence ?? []).map(evidenceKey);
@@ -818,17 +832,15 @@ export function refreshAcceptanceReceipt(task, options = {}) {
       continue;
     }
     if (criterion.status === "satisfied") continue;
-    const evidence = evidenceForObligation(criterion.obligation, task, corpus, currentWorkingTreeDigest, criterion);
+    const evidence = evidenceForObligation(criterion.obligation, task, corpus, currentWorkingTreeDigest, criterion, cwd, workspaceRevisionDigest, undefined, options.apiBaselineEvidence);
     if (evidence) changed = addEvidence(criterion, evidence, recordedAt) || changed;
   }
-  const missing = receipt.criteria.filter((criterion) => criterion.status !== "satisfied");
-  const criticalMissing = missing.filter((criterion) => criterion.priority === "critical");
+  const { missing, criticalMissing, adapterAbstained, independentRequired, sourceProofRequired } = missingAcceptanceProofCapabilities(task, receipt, {
+    corpus, passingVerifier: hasCurrentPassingVerifier(task, currentWorkingTreeDigest, workspaceRevisionDigest),
+    taskText: acceptanceTaskText(task), independentAssessments: independent, sourceProofRequiredIds
+  });
   return {
-    task: { ...task, acceptanceReceipt: receipt },
-    receipt,
-    missing,
-    criticalMissing,
-    changed
+    task: { ...task, acceptanceReceipt: receipt }, receipt, missing, criticalMissing, adapterAbstained, independentRequired, sourceProofRequired, changed
   };
 }
 
@@ -847,31 +859,47 @@ export function acceptanceCriticalRecoveryProjection(task, options = {}) {
   const corpus = changedFileAcceptanceCorpus(cwd, changedFiles);
   if (!corpus.adapter.proofCapable) return [];
   if (corpus.sourceEntries.length === 0 && corpus.testEntries.length === 0) return [];
-  const verifierCurrent = hasCurrentPassingVerifier(task, currentWorkingTreeDigest);
+  const workspaceRevisionDigest = verificationProjectionWorkspaceRevision(task, options);
+  const verifierCurrent = hasCurrentPassingVerifier(task, currentWorkingTreeDigest, workspaceRevisionDigest);
+  const independent = independentAcceptanceState(cwd, task, currentWorkingTreeDigest).assessments;
   const projections = [];
   for (const criterion of receipt.criteria.filter((item) => item.priority === "critical")) {
+    // Advisory recovery must honor the same live authority as receipt refresh.
+    // A copied status or stale/failed assessment cannot suppress missing proof.
+    const assessment = independent.get(criterion.id);
+    if (assessment?.verdict === "pass" && assessment.completionAllowed === true) continue;
+    const disposition = criterionBehaviorProofDisposition({ obligation: criterion.obligation, task, criterion, taskText: acceptanceTaskText(task), corpus, passingVerifier: verifierCurrent });
     const criterionText = (Array.isArray(task?.acceptanceCriteria) ? task.acceptanceCriteria : [])
       .find((text) => typeof text === "string" && sha256(text) === criterion.hash && !GENERATED_ACCEPTANCE_TEXTS.has(text));
-    if (!criterionText || evidenceForObligation(criterion.obligation, task, corpus, currentWorkingTreeDigest, criterion)) continue;
-    const targets = namedCodeTargets(task, criterion, corpus.sourceText);
-    const missingDimensions = [];
+    if (!criterionText) continue;
+    const api = apiBaselineRecoveryProjection({ task, criterion, criterionText, cwd, corpus, currentWorkingTreeDigest, workspaceRevisionDigest, apiBaselineEvidence: options.apiBaselineEvidence }); if (api.handled) { if (api.projection) projections.push(api.projection); continue; }
+    if (compoundAcceptanceCriterion(criterionText)) {
+      projections.push({ criterionId: criterion.id, criterionHash: criterion.hash, criterionText, targets: [], missingDimensions: ["independent-compound-proof"], proofHints: ["Use an approved independent assessment covering every clause of this exact criterion. A partial verifier or source heuristic cannot prove the group; do not edit source solely to satisfy that heuristic."] });
+      continue;
+    }
+    if (disposition === "unknown") { projections.push({ criterionId: criterion.id, criterionHash: criterion.hash, criterionText: criterionText.slice(0, 700), targets: [], missingDimensions: ["adapter-linkage"], proofHints: ["Add a focused executable test with a direct relative import to the changed source, or configure a deterministic language adapter that resolves this helper/barrel path; then rerun the exact verifier."] }); continue; }
+    if (evidenceForObligation(criterion.obligation, task, corpus, currentWorkingTreeDigest, criterion, cwd, workspaceRevisionDigest, undefined, options.apiBaselineEvidence)) continue;
+    const evidenceCriterionText = criterion.obligation === "invalid-input-rejection" ? invalidInputCriterionText(task, criterion) : criterionText;
+    const targets = namedCodeTargets(task, criterion, corpus.sourceText, evidenceCriterionText);
+    const missingDimensions = [], sourceProofReasons = [];
     if (!verifierCurrent) missingDimensions.push("current-verifier");
     if (criterion.obligation === "invalid-input-rejection") {
       if (corpus.sourceFiles.length === 0 || corpus.testFiles.length === 0) continue;
       const proof = acceptanceInvalidInputEvidence({
-        taskText: criterionText, sourceText: corpus.sourceText, testText: corpus.testText,
+        taskText: evidenceCriterionText, contextText: acceptanceTaskText(task), sourceText: corpus.sourceText, testText: corpus.testText,
         sourceEntries: corpus.sourceEntries, testEntries: corpus.testEntries,
-        namedTargets: targets, provenanceTargets: explicitlyCallableTargets(task, criterion, corpus.sourceText)
+        namedTargets: targets, provenanceTargets: explicitlyCallableTargets(task, criterion, corpus.sourceText, evidenceCriterionText), includeDiagnostics: true
       });
-      if (!proof.sourceOk) missingDimensions.push("source-rejection");
+      if (!proof.sourceOk) { missingDimensions.push("source-proof-unknown"); sourceProofReasons.push(...(proof.sourceReasons ?? [])); }
       if (!proof.testOk) missingDimensions.push("executable-focused-test");
     }
     if (missingDimensions.length === 0) missingDimensions.push("focused-evidence");
-    const proofHints = acceptanceContractProofGuidance(criterionText);
-    if (missingDimensions.includes("source-rejection")) proofHints.push("Add a reachable entrypoint-bound rejection guard for every explicitly invalid partition and requested error class.");
+    const diagnosticHints = sourceProofReasons.length > 0 ? [`Source proof abstained: ${sourceProofReasons.join(", ")}. This is missing verification evidence, not an observed implementation defect.`, ...temporalProofReasonGuidance(sourceProofReasons)] : [];
+    const proofHints = [...diagnosticHints, ...acceptanceContractProofGuidance(evidenceCriterionText)];
+    if (missingDimensions.includes("source-proof-unknown")) proofHints.push("Use an approved independent validator for the declared invalid partitions and error classes. Do not rewrite source solely to satisfy the analyzer; source repair needs a concrete observed counterexample.");
     if (missingDimensions.includes("executable-focused-test")) proofHints.push("Add live entrypoint-bound rejection assertions; dynamic, skipped, dead, mutable, or unresolved proof remains pending.");
     if (missingDimensions.includes("current-verifier")) proofHints.push("Run the exact configured verifier against one unchanged current working-tree snapshot.");
-    projections.push({ criterionId: criterion.id, criterionHash: criterion.hash, criterionText: criterionText.slice(0, 700), targets: uniqueStrings(targets).slice(0, 8), missingDimensions: uniqueStrings(missingDimensions), proofHints: uniqueStrings(proofHints).slice(0, 6).map((hint) => hint.slice(0, 300)) });
+    projections.push({ criterionId: criterion.id, criterionHash: criterion.hash, criterionText: criterionText.slice(0, 700), targets: uniqueStrings(targets).slice(0, 8), missingDimensions: uniqueStrings(missingDimensions), proofHints: uniqueStrings(proofHints).slice(0, 6).map((hint) => hint.slice(0, 300)), diagnosticHints: uniqueStrings(diagnosticHints).slice(0, 2).map((hint) => hint.slice(0, 300)) });
   }
   return projections.slice(0, MAX_CRITERIA);
 }
@@ -902,7 +930,7 @@ export function acceptanceReceiptValidationErrors(value) {
   }
   if (value.helperUsage !== undefined) {
     const usage = value.helperUsage;
-    if (!isRecord(usage) || hasUnsupportedField(usage, HELPER_USAGE_FIELDS) || !["off", "recommend", "on"].includes(usage.mode) || typeof usage.used !== "boolean" || !Array.isArray(usage.reasonCodes) || usage.reasonCodes.length > 16 || usage.reasonCodes.some((item) => typeof item !== "string" || compactId(item) !== item) || !Array.isArray(usage.helpers) || usage.helpers.length > 3 || !validTimestamp(usage.recordedAt)) errors.push("acceptanceReceipt helperUsage is invalid");
+    if (!isRecord(usage) || hasUnsupportedField(usage, HELPER_USAGE_FIELDS) || !["off", "recommend", "on"].includes(usage.mode) || typeof usage.used !== "boolean" || (usage.decision !== undefined && !["dispatch", "skip"].includes(usage.decision)) || (usage.projectedSavingsRatio !== undefined && usage.projectedSavingsRatio !== null && (typeof usage.projectedSavingsRatio !== "number" || !Number.isFinite(usage.projectedSavingsRatio) || usage.projectedSavingsRatio < -10 || usage.projectedSavingsRatio > 1)) || !Array.isArray(usage.reasonCodes) || usage.reasonCodes.length > 16 || usage.reasonCodes.some((item) => typeof item !== "string" || compactId(item) !== item) || !Array.isArray(usage.helpers) || usage.helpers.length > 3 || !validTimestamp(usage.recordedAt)) errors.push("acceptanceReceipt helperUsage is invalid");
     else for (const helper of usage.helpers) if (!isRecord(helper) || hasUnsupportedField(helper, HELPER_ENTRY_FIELDS) || !HELPER_ROLES.has(helper.role) || typeof helper.disposition !== "string" || compactId(helper.disposition) !== helper.disposition || !HASH.test(String(helper.requestRef)) || (helper.outputDigest !== null && !HASH.test(String(helper.outputDigest))) || !Number.isInteger(helper.calls) || helper.calls < 0 || helper.calls > 100 || !Number.isInteger(helper.tokens) || helper.tokens < 0 || helper.tokens > 100_000_000) errors.push("acceptanceReceipt helper entry is invalid");
   }
   if (!Array.isArray(value.criteria) || value.criteria.length === 0 || value.criteria.length > MAX_CRITERIA) {