@piagent/platform 1.5.5 → 1.6.1

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

@@ -1,9 +1,11 @@
 import crypto from "node:crypto";
 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 { criterionBehaviorProofDisposition, criterionRequiresBehavioralProof, durableBehaviorProofRequired, genericCriterionEvidence, genericFallbackEvidence, isVerificationOnlyCriterion, verifierCommandsCoverTests } from "./acceptance-behavior-proof.js";
 import { latestObservedVerificationEvidence, meaningfulVerificationCommands, verificationEvidenceProvesStableTree } from "./verification-intelligence.js";
 import {
   acceptanceContractProofGuidance,
@@ -33,7 +35,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"]);
@@ -42,7 +44,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/;
+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 sha256(value) {
   return crypto.createHash("sha256").update(String(value ?? "")).digest("hex");
@@ -79,11 +81,9 @@ 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) => {
@@ -94,32 +94,70 @@ 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));
 }
+function acceptanceReadOnlyInferenceOptions(input, text) {
+  const boundaryPatterns = uniqueStrings([
+    ...(Array.isArray(input?.outOfScope) ? input.outOfScope : []),
+    ...(Array.isArray(input?.protectedPaths) ? input.protectedPaths : [])
+  ]);
+  return {
+    mutationPolicy: input?.mutationPolicy,
+    readOnlyBoundary: boundaryPatterns.length > 0
+      && readOnlyBoundaryTiedToPattern(text, boundaryPatterns)
+  };
+}
 
-export function inferAcceptanceObligations(text, changeMode = "source-change") {
+export function inferAcceptanceObligations(text, changeMode = "source-change", options = {}) {
   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)) {
+  if (changeMode === "read-only" || options.mutationPolicy === "forbidden" || options.readOnlyBoundary === true) {
     obligations.push("read-only-evidence");
   }
-  const explicitAuthorization = includesAny(value, [
-    /\bauth(?:orization)?\b/, /\bunauthoriz(?:ed|ation)\b/, /\bpermission\b/, /\brole\b/, /\badmin\b/, /\bdeny\b/, /\bdenied\b/
+  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 ownerAccessControl = /\bowner\b/.test(value) && includesAny(value, [
+  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/
   ]);
   if (explicitAuthorization || ownerAccessControl) {
     obligations.push("authorization-deny-case");
   }
-  if (includesAny(value, [/\btenant\b/, /\bcross-tenant\b/, /\bsame tenant\b/, /\btenantid\b/])) {
-    if (includesAny(value, [/\bcache\b/, /\bcache[- ]?key\b/, /\bstorage\b/, /\bcollision\b/, /\bentity\b/, /\bsame tuple\b/])) {
+  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 {
+    } else if (strongAuthorization || ownerAccessControl || tenantActorAccess || explicitTenantAccessBoundary) {
       obligations.push("tenant-boundary");
     }
   }
@@ -167,7 +205,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,
@@ -203,8 +240,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 [];
@@ -223,7 +261,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) : [])
@@ -234,7 +276,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 = [
@@ -242,12 +283,20 @@ 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)
+  );
   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);
     }
@@ -258,17 +307,23 @@ export function buildAcceptanceReceipt(input = {}) {
       : generatedCriterionForObligation("verification-evidence"));
   }
   const acceptanceCriteria = texts.slice(0, MAX_CRITERIA);
+  const durableBehaviorProof = durableBehaviorProofRequired(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: CRITICAL_OBLIGATIONS.has(obligation) || (durableBehaviorProof && obligation !== "verification-evidence") ? "critical" : "normal",
       status: "pending",
       evidence: []
     };
@@ -327,20 +382,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 } };
 }
 
@@ -609,8 +674,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)
@@ -657,7 +722,7 @@ function hasCurrentPassingVerifier(task, currentWorkingTreeDigest) {
   });
 }
 
-function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDigest, criterion) {
+function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDigest, criterion, cwd) {
   const passingVerifier = hasCurrentPassingVerifier(task, currentWorkingTreeDigest);
   const latestVerifyEvidence = latestObservedVerificationEvidence(task?.verifyEvidence);
   const verifyEvidence = meaningfulVerificationCommands(task?.verifyCommands ?? [])
@@ -674,14 +739,14 @@ function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDiges
   if (semanticConflictReasons(obligation, task, corpus, criterion).length > 0) return undefined;
 
   if (obligation === "read-only-evidence") {
-    const readOnlyOk = task.changeMode === "read-only"
+    const readOnlyEvidence = durableContextEvidenceEntries(task);
+    const readOnlyOk = (task.changeMode === "read-only" || task.mutationPolicy === "forbidden")
       && corpus.files.length === 0
-      && Array.isArray(task.contextManifest)
-      && task.contextManifest.length > 0;
+      && hasDurableContextEvidence(task);
     if (readOnlyOk) return {
       kind: "read-only-context",
       summary: "Read-only context was observed and no project files changed.",
-      paths: task.contextManifest.map((item) => item.path).slice(0, 8)
+      paths: readOnlyEvidence.map((item) => item.path).slice(0, 8)
     };
     if (task.changeMode === "source-change") {
       const boundaryPatterns = uniqueStrings([...(task.outOfScope ?? []), ...(task.protectedPaths ?? [])]);
@@ -692,11 +757,10 @@ 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))
-        && Array.isArray(task.contextManifest)
-        && task.contextManifest.length > 0;
+        && hasDurableContextEvidence(task);
       if (sourceChangeReadOnlyOk) {
         return {
           kind: "source-change-read-only-boundary",
@@ -709,23 +773,21 @@ 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 generic = genericCriterionEvidence({ obligation, task, criterion, taskText: acceptanceTaskText(task), corpus, verifierEvidence, passingVerifier, cwd });
+  if (generic.handled) 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") {
@@ -738,7 +800,7 @@ function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDiges
       namedTargets: namedCodeTargets(task, criterion, corpus.sourceText),
       provenanceTargets: explicitlyCallableTargets(task, criterion, corpus.sourceText)
     });
-    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",
@@ -756,7 +818,7 @@ function evidenceForObligation(obligation, task, corpus, currentWorkingTreeDiges
     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",
@@ -767,12 +829,12 @@ 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: [], changed: false };
   const cwd = options.cwd;
   const changedFiles = uniqueStrings(options.changedFiles ?? task.changedFiles ?? task.observedChangedFiles ?? []);
   const currentWorkingTreeDigest = options.currentWorkingTreeDigest;
@@ -787,7 +849,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)
         : undefined;
       if (evidence) addEvidence(criterion, evidence, recordedAt);
       const nextEvidence = (criterion.evidence ?? []).map(evidenceKey);
@@ -795,17 +857,16 @@ 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);
     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 passingVerifier = hasCurrentPassingVerifier(task, currentWorkingTreeDigest);
+  const adapterAbstained = missing.filter((criterion) => criterionBehaviorProofDisposition({ obligation: criterion.obligation, task, criterion, taskText: acceptanceTaskText(task), corpus, passingVerifier }) === "unknown");
+  const criticalMissing = missing.filter((criterion) => (criterion.priority === "critical" || criterionRequiresBehavioralProof(task, criterion, acceptanceTaskText(task))
+  ));
   return {
-    task: { ...task, acceptanceReceipt: receipt },
-    receipt,
-    missing,
-    criticalMissing,
-    changed
+    task: { ...task, acceptanceReceipt: receipt }, receipt, missing, criticalMissing, adapterAbstained, changed
   };
 }
 
@@ -827,9 +888,12 @@ export function acceptanceCriticalRecoveryProjection(task, options = {}) {
   const verifierCurrent = hasCurrentPassingVerifier(task, currentWorkingTreeDigest);
   const projections = [];
   for (const criterion of receipt.criteria.filter((item) => item.priority === "critical")) {
+    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;
+    if (!criterionText) 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)) continue;
     const targets = namedCodeTargets(task, criterion, corpus.sourceText);
     const missingDimensions = [];
     if (!verifierCurrent) missingDimensions.push("current-verifier");
@@ -879,7 +943,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) {