@piagent/platform 1.6.1 → 1.8.0

package/packages/piagent-core/extensions/acceptance-behavior-proof.js

@@ -1,7 +1,11 @@
+import { dependencyGraphNonMutationEvidence } from "./acceptance-parameter-contract.js"; import { finiteIntervalNonMutationEvidence } from "./acceptance-temporal-contract.js";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 
+import { acceptanceContractConjuncts } from "./acceptance-contract-conjunction.js";
+import { pureRecordNonMutationEvidence, byteArrayNonMutationEvidence, braceScope, sameScope, unconditionalEvidenceScope, constantDeclarations, literalBinding, splitTopLevel, flatObjectSnapshot, stableDeepSnapshot, boundStringValue, exactBoundValue, callArgumentNames } from "./acceptance-literal-dataflow.js";
+import { acceptanceResultContractEvidence } from "./acceptance-result-contract-evidence.js";
 import { criterionGraphValidationErrors } from "./criterion-graph.js";
 import { regexCanStartAfterLexicalChunks } from "./javascript-regex-evidence.js";
 import { normalizePathCandidate } from "./policy-core.js";
@@ -16,6 +20,40 @@ function sha256(value) {
   return crypto.createHash("sha256").update(String(value ?? "")).digest("hex");
 }
 
+export { sha256 as acceptanceTextHash };
+
+// A multiline criterion preserves distinct intake clauses. No legacy matcher
+// proves their conjunction; an independent assessment must cover the full hash.
+export function compoundAcceptanceCriterion(text) {
+  return /[\r\n]/.test(String(text ?? "").trim());
+}
+
+export function acceptanceCriterionBindingValid(task, receipt, criterion, index) {
+  const texts = task?.acceptanceCriteria;
+  return Array.isArray(texts) && texts.length === receipt.criteria.length
+    && typeof texts[index] === "string" && sha256(texts[index]) === criterion.hash
+    && receipt.criteria.filter((item) => item.id === criterion.id).length === 1;
+}
+
+export function resetUnprovenCriterion(criterion) {
+  const changed = criterion.status !== "pending" || criterion.evidence.length > 0 || criterion.priority !== "critical";
+  criterion.status = "pending";
+  criterion.evidence = [];
+  criterion.priority = "critical";
+  return changed;
+}
+
+export function acceptanceEvidenceKey(evidence) {
+  return JSON.stringify({
+    kind: evidence.kind,
+    summary: evidence.summary,
+    paths: evidence.paths ?? [],
+    command: evidence.command,
+    exitCode: evidence.exitCode,
+    workingTreeDigest: evidence.workingTreeDigest
+  });
+}
+
 function escapeRegex(value) {
   return String(value ?? "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -27,7 +65,7 @@ function normalizedText(value) {
 export function durableBehaviorProofRequired(text, changeMode = "source-change") {
   const value = String(text ?? "");
   if (changeMode === "read-only") return false;
-  return /\b(?:concurren|do not mutate|must not mutate|without mutating|return shape|returned? (?:element|object|value|representation)|preserve (?:the )?(?:api|input|output|return)|public api|exact error|typeerror|syntaxerror|rangeerror)\b/i.test(value);
+  return /\b(?:concurren|do not mutate|must not mutate|without mutating|inputs? must remain unchanged|return shape|returned? (?:element|object|value|representation)|preserve (?:the )?(?:api|input|output|return)|public api|exact error|typeerror|syntaxerror|rangeerror)\b/i.test(value);
 }
 
 function boundCriterionGraphNode(task, criterion) {
@@ -134,10 +172,6 @@ function bindJavaScriptStrings(value) {
   return { code: output.join(""), strings };
 }
 
-function boundStringValue(token, strings) {
-  const index = Number(String(token ?? "").match(/^__pi_bound_string_(\d+)__$/)?.[1]);
-  return Number.isInteger(index) ? strings[index] : undefined;
-}
 
 function moduleRecords(entry) {
   const evidence = String(entry.evidenceText ?? "");
@@ -195,39 +229,55 @@ function exportedNames(sourceEntries) {
   return names;
 }
 
-function resolvedSpecifierMatchesSource(testPath, specifier, sourceFiles) {
-  if (!specifier.startsWith(".")) return false;
+function resolvedSpecifierSources(testPath, specifier, sourceFiles) {
+  if (!specifier.startsWith(".")) return [];
   const resolved = normalizePathCandidate(path.posix.normalize(path.posix.join(path.posix.dirname(testPath), specifier)));
   const candidates = new Set([resolved, resolved.replace(/\.[a-z0-9]+$/i, "")]);
-  for (const source of sourceFiles.map((file) => normalizePathCandidate(file))) {
+  return sourceFiles.map((file) => normalizePathCandidate(file)).filter((source) => {
     const stem = source.replace(/\.[a-z0-9]+$/i, "");
-    if (candidates.has(source) || candidates.has(stem) || stem === `${resolved.replace(/\/$/, "")}/index`) return true;
-  }
-  return false;
+    return candidates.has(source) || candidates.has(stem) || stem === `${resolved.replace(/\/$/, "")}/index`;
+  });
 }
 
 /* linked = proven; unknown = alias/barrel/indirect may be valid; unlinked = only unrelated imports. */
 function testSourceLinkage(corpus) {
-  const sourceExports = exportedNames(corpus.sourceEntries);
+  const sourceExports = new Map(corpus.sourceEntries.map((entry) => [
+    normalizePathCandidate(entry.path), exportedNames([entry])
+  ]));
   const linkedEntries = [];
   let unresolvedProjectImport = false;
   for (const entry of corpus.testEntries) {
     const records = moduleRecords(entry);
     const callables = new Set();
+    const callableBindings = [];
     let linked = false;
     for (const record of records) {
-      const bindings = importedBindings(record);
-      if (resolvedSpecifierMatchesSource(entry.path, record.specifier, corpus.sourceFiles)) {
+      const importBindings = importedBindings(record);
+      const sourcePaths = resolvedSpecifierSources(entry.path, record.specifier, corpus.sourceFiles);
+      if (sourcePaths.length > 0) {
         linked = true;
-        for (const binding of bindings) {
-          if (binding.exported === "*") sourceExports.forEach((name) => callables.add(`${binding.local}.${name}`));
-          else callables.add(binding.local);
+        for (const binding of importBindings) {
+          if (binding.exported === "*") sourcePaths.forEach((sourcePath) => {
+            for (const name of sourceExports.get(sourcePath) ?? []) {
+              const testName = `${binding.local}.${name}`;
+              callables.add(testName);
+              callableBindings.push({ sourceName: name, sourcePath, testName });
+            }
+          });
+          else {
+            callables.add(binding.local);
+            for (const sourcePath of sourcePaths) {
+              if (sourceExports.get(sourcePath)?.has(binding.exported)) {
+                callableBindings.push({ sourceName: binding.exported, sourcePath, testName: binding.local });
+              }
+            }
+          }
         }
         continue;
       }
       if (record.specifier.startsWith(".") || /^[#@~]/.test(record.specifier)) unresolvedProjectImport = true;
     }
-    if (linked) linkedEntries.push({ entry, callables: [...callables] });
+    if (linked) linkedEntries.push({ entry, callables: [...callables], bindings: callableBindings });
   }
   if (linkedEntries.length > 0) return { status: "linked", entries: linkedEntries };
   return { status: unresolvedProjectImport ? "unknown" : "unlinked", entries: [] };
@@ -242,6 +292,21 @@ function balancedCallEnd(code, openIndex) {
   return -1;
 }
 
+function enclosingTestDescriptions(code, strings, callStart) {
+  const descriptions = [];
+  const pattern = new RegExp(`\\b(?:it|test)\\s*\\(\\s*(${BOUND_STRING}[0-9]+__)\\s*,`, "g");
+  for (const match of code.matchAll(pattern)) {
+    if (match.index >= callStart) break;
+    const open = code.indexOf("(", match.index);
+    const end = balancedCallEnd(code, open);
+    const description = boundStringValue(match[1], strings);
+    if (end > callStart && typeof description === "string" && description.trim()) {
+      descriptions.push({ start: match.index, description });
+    }
+  }
+  return descriptions.sort((left, right) => right.start - left.start).map((item) => item.description);
+}
+
 function assertionSlices(code) {
   const assertions = [];
   const pattern = /\b(?:assert(?:\.[a-z][a-z0-9_]*)?|expect)\s*\(/gi;
@@ -268,19 +333,17 @@ function assignedCallNames(code, callStart) {
 
 function nextBindingWrite(code, name, after) {
   const escaped = escapeRegex(name);
-  const pattern = new RegExp(`\\b(?:const|let|var)\\s+${escaped}\\s*=|\\b${escaped}\\s*=(?!=|>)`, "g");
+  const pattern = new RegExp(`\\b(?:const|let|var)\\s+${escaped}\\s*=|\\b${escaped}\\s*(?:=(?!=|>)|(?:\\|\\||&&|\\?\\?|\\*\\*|<<|>>>?|[+*/%&|^\\-])=|\\+\\+|--)|(?:\\+\\+|--)\\s*\\b${escaped}\\b|[\\[{][^;\\n]*\\b${escaped}\\b[^;\\n]*[\\]}]\\s*=(?!=|>)`, "g");
   pattern.lastIndex = after;
   return pattern.exec(code)?.index ?? Number.POSITIVE_INFINITY;
 }
 
-function callArgumentNames(slice) {
-  const body = slice.slice(slice.indexOf("(") + 1, -1);
-  return [...body.matchAll(/(?:^|,)\s*([a-z_$][a-z0-9_$]*)\s*(?=,|$)/gi)].map((match) => match[1]);
-}
+
 
 function callableSlices(code, strings, callables) {
   const calls = [];
   const assertions = assertionSlices(code);
+  const declarations = constantDeclarations(code);
   for (const callable of callables) {
     const pattern = new RegExp(`\\b${escapeRegex(callable)}\\s*\\(`, "g");
     for (const match of code.matchAll(pattern)) {
@@ -288,7 +351,7 @@ function callableSlices(code, strings, callables) {
       const end = balancedCallEnd(code, open);
       if (end < 0) continue;
       const slice = code.slice(match.index, end);
-      const values = [...slice.matchAll(/__pi_bound_string_[0-9]+__/g)]
+      let values = [...slice.matchAll(/__pi_bound_string_[0-9]+__/g)]
         .map((item) => boundStringValue(item[0], strings)).filter((item) => typeof item === "string");
       const argumentNames = callArgumentNames(slice);
       const resultNames = [...new Set(assignedCallNames(code, match.index))];
@@ -305,33 +368,37 @@ function callableSlices(code, strings, callables) {
         [...assertion.code.matchAll(/__pi_bound_string_[0-9]+__/g)]
           .map((item) => boundStringValue(item[0], strings)).filter((item) => typeof item === "string")
       ));
-      if (boundAssertions.length > 0) calls.push({
+      const call = {
+        callable,
         slice, values, strings, resultNames, argumentNames, assertionValues, prelude: code.slice(0, match.index),
-        assertions: boundAssertions.map((item) => item.code)
-      });
+        assertions: boundAssertions.map((item) => item.code),
+        descriptions: enclosingTestDescriptions(code, strings, match.index),
+        code, declarations, start: match.index, end,
+        safeScope: unconditionalEvidenceScope(code, match.index),
+        scopedAssertions: boundAssertions.filter((assertion) => unconditionalEvidenceScope(code, assertion.start)
+          && sameScope(braceScope(code, assertion.start), braceScope(code, match.index)))
+      };
+      const callableRoot = callable.split(".")[0];
+      const callScope = braceScope(code, match.index);
+      if (declarations.some((entry) => entry.name === callableRoot && entry.start < match.index
+        && entry.scope.every((open, index) => callScope[index] === open))) call.safeScope = false;
+      for (const shadow of code.matchAll(new RegExp(`\\b(?:function|class)\\s+${escapeRegex(callableRoot)}\\b`, "g"))) {
+        if (braceScope(code, shadow.index).every((open, index) => callScope[index] === open)) call.safeScope = false;
+      }
+      const argumentsList = splitTopLevel(slice.slice(slice.indexOf("(") + 1, -1));
+      if (call.safeScope && argumentsList.length === 1 && /^[a-z_$][a-z0-9_$]*$/i.test(argumentsList[0])) {
+        const literal = literalBinding(call, argumentsList[0], match.index);
+        if (literal?.kind === "array" && literal.elements.every((item) => typeof item.value === "string")) {
+          call.values = literal.elements.map((item) => item.value);
+          call.assertions = call.scopedAssertions.map((assertion) => assertion.code);
+        }
+      }
+      if (boundAssertions.length > 0) calls.push(call);
     }
   }
   return calls;
 }
 
-function splitTopLevel(value) {
-  const parts = [];
-  let start = 0, round = 0, square = 0, curly = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    const token = value[index];
-    if (token === "(") round += 1;
-    else if (token === ")") round -= 1;
-    else if (token === "[") square += 1;
-    else if (token === "]") square -= 1;
-    else if (token === "{") curly += 1;
-    else if (token === "}") curly -= 1;
-    else if (token === "," && round === 0 && square === 0 && curly === 0) {
-      parts.push(value.slice(start, index).trim()); start = index + 1;
-    }
-  }
-  parts.push(value.slice(start).trim());
-  return parts;
-}
 
 function assertionComparisons(call) {
   return call.assertions.flatMap((assertion) => {
@@ -354,23 +421,24 @@ function assertionComparisons(call) {
   });
 }
 
-function exactBoundValue(expression, strings) {
-  const value = String(expression ?? "").trim();
-  if (value === "true") return true;
-  if (value === "false") return false;
-  return boundStringValue(value, strings);
-}
 
 function propertyExpression(objectExpression, property, strings) {
   const value = String(objectExpression ?? "").trim();
   if (!(value.startsWith("{") && value.endsWith("}"))) return undefined;
-  for (const member of splitTopLevel(value.slice(1, -1))) {
+  const members = splitTopLevel(value.slice(1, -1));
+  if (members.at(-1) === "") members.pop();
+  const fields = new Map();
+  for (const member of members) {
     const colon = member.indexOf(":");
-    if (colon < 0) continue;
-    const key = member.slice(0, colon).trim();
-    if (key === property || boundStringValue(key, strings) === property) return member.slice(colon + 1).trim();
+    if (colon < 0) return undefined;
+    const rawKey = member.slice(0, colon).trim();
+    const key = boundStringValue(rawKey, strings) ?? (/^[a-z_$][a-z0-9_$]*$/i.test(rawKey) ? rawKey : undefined);
+    // Bound strings retain escape spelling; do not mistake escaped aliases
+    // for distinct runtime property names without a verified decoder.
+    if (key === undefined || key.includes("\\") || key === "__proto__" || fields.has(key)) return undefined;
+    fields.set(key, member.slice(colon + 1).trim());
   }
-  return undefined;
+  return fields.get(property);
 }
 
 function callResultExpression(call, expression) {
@@ -446,12 +514,14 @@ function repeatedFlagExpectedValue(values) {
 
 function preCallSnapshotName(call, argument) {
   const escaped = escapeRegex(argument);
+  const objectSnapshot = flatObjectSnapshot(call, argument, assertionComparisons);
+  if (objectSnapshot) return objectSnapshot.name;
   const deepPatterns = [
     new RegExp(`\\b(?:const|let)\\s+([a-z_$][a-z0-9_$]*)\\s*=\\s*structuredClone\\s*\\(\\s*${escaped}\\s*\\)`, "gi"),
     new RegExp(`\\b(?:const|let)\\s+([a-z_$][a-z0-9_$]*)\\s*=\\s*JSON\\.parse\\s*\\(\\s*JSON\\.stringify\\s*\\(\\s*${escaped}\\s*\\)\\s*\\)`, "gi")
   ];
   const deep = deepPatterns.flatMap((pattern) => [...call.prelude.matchAll(pattern)].map((match) => match[1])).at(-1);
-  if (deep) return deep;
+  if (deep) return stableDeepSnapshot(call, argument, deep, assertionComparisons) ? deep : undefined;
   const declaration = [...call.prelude.matchAll(new RegExp(`\\b(?:const|let)\\s+${escaped}\\s*=\\s*\\[([^\\]]*)\\]`, "gi"))].at(-1);
   const primitiveIndexFactory = new RegExp("\\b(?:const|let)\\s+" + escaped + "\\s*=\\s*Array\\.from\\s*\\(\\s*\\{\\s*length\\s*:\\s*\\d+\\s*\\}\\s*,\\s*\\(\\s*[a-z_$][a-z0-9_$]*\\s*,\\s*([a-z_$][a-z0-9_$]*)\\s*\\)\\s*=>\\s*\\1\\s*\\)", "i").test(call.prelude);
   const primitiveElements = primitiveIndexFactory || declaration && splitTopLevel(declaration[1]).every((item) => {
@@ -468,17 +538,125 @@ function preCallSnapshotName(call, argument) {
   return shallowPatterns.flatMap((pattern) => [...call.prelude.matchAll(pattern)].map((match) => match[1])).at(-1);
 }
 
-function nonMutationAssertion(call) {
-  return call.argumentNames.some((argument) => {
+function nonMutationAssertion(call, requireAll = false) {
+  const argumentsList = splitTopLevel(call.slice.slice(call.slice.indexOf("(") + 1, -1));
+  if (requireAll && (call.argumentNames.length !== argumentsList.length || !call.safeScope)) return false;
+  const provesArgument = (argument) => {
+    if (requireAll && literalBinding(call, argument, call.start)?.kind === "primitive") return true;
     const snapshot = preCallSnapshotName(call, argument);
     if (!snapshot) return false;
-    return call.assertions.some((assertion) => (
+    const assertions = requireAll ? call.scopedAssertions.map((entry) => entry.code) : call.assertions;
+    return assertions.some((assertion) => (
       new RegExp(`\\bassert\\.(?:deepEqual|deepStrictEqual|strictEqual)\\s*\\(\\s*${escapeRegex(argument)}\\s*,\\s*${escapeRegex(snapshot)}\\b`, "i").test(assertion)
       || new RegExp(`\\bexpect\\s*\\(\\s*${escapeRegex(argument)}\\s*\\)\\s*\\.to(?:Strict)?Equal\\s*\\(\\s*${escapeRegex(snapshot)}\\b`, "i").test(assertion)
     ));
+  };
+  return call.argumentNames.length > 0 && (requireAll ? call.argumentNames.every(provesArgument) : call.argumentNames.some(provesArgument));
+}
+
+
+function primitiveContractParameters(task) {
+  const contracts = new Map();
+  const text = [task?.summary, ...(Array.isArray(task?.acceptanceCriteria) ? task.acceptanceCriteria : [])]
+    .filter(Boolean).join("\n");
+  const pattern = /`([a-z_$][a-z0-9_$]*)`\s+(?:must|should|has\s+to)\s+be\s+(?:an?\s+)?(?:non[- ]empty\s+)?(string|integer|number|boolean|bigint|symbol)\b/gi;
+  for (const match of text.matchAll(pattern)) contracts.set(match[1], match[2].toLowerCase());
+  return contracts;
+}
+
+function balancedBlockEnd(code, openIndex) {
+  let depth = 0;
+  for (let index = openIndex; index < code.length; index += 1) {
+    if (code[index] === "{") depth += 1;
+    else if (code[index] === "}" && --depth === 0) return index + 1;
+  }
+  return -1;
+}
+
+function declaredFunctionBody(sourceEntries, callable) {
+  const local = callable.split(".").at(-1);
+  if (!/^[a-z_$][a-z0-9_$]*$/i.test(local ?? "")) return undefined;
+  const pattern = new RegExp(`\\bfunction\\s+${escapeRegex(local)}\\s*\\(([^)]*)\\)\\s*\\{`, "i");
+  for (const entry of sourceEntries) {
+    const match = pattern.exec(entry.text);
+    if (!match) continue;
+    const open = entry.text.indexOf("{", match.index + match[0].length - 1);
+    const end = balancedBlockEnd(entry.text, open);
+    const parameters = match[1].split(",").map((item) => item.trim());
+    if (end > open && parameters.every((item) => /^[a-z_$][a-z0-9_$]*$/i.test(item))) {
+      return { body: entry.text.slice(open + 1, end - 1), parameters };
+    }
+  }
+  return undefined;
+}
+
+function primitiveGuardIndex(body, parameter, type) {
+  const escaped = escapeRegex(parameter);
+  const pattern = type === "integer"
+    ? new RegExp(`!\\s*Number\\.is(?:Safe)?Integer\\s*\\(\\s*${escaped}\\s*\\)`, "i")
+    : new RegExp(`typeof\\s+${escaped}\\s*!==?\\s*["']${escapeRegex(type)}["']`, "i");
+  const match = pattern.exec(body);
+  if (!match) return -1;
+  const ifStart = body.lastIndexOf("if", match.index);
+  const open = ifStart >= 0 ? body.indexOf("(", ifStart + 2) : -1;
+  const close = open >= 0 ? balancedCallEnd(body, open) : -1;
+  if (ifStart < 0 || open < 0 || match.index < open || match.index >= close) return -1;
+  const consequent = body.slice(close, close + 320);
+  return /^\s*(?:throw\b|\{[\s\S]{0,260}\bthrow\b)/.test(consequent) ? match.index : -1;
+}
+
+function parameterMutationObserved(body, parameter) {
+  const escaped = escapeRegex(parameter);
+  return [
+    new RegExp(`\\b${escaped}\\s*(?:\\[[^\\]]+\\]|\\.[a-z_$][a-z0-9_$]*)?\\s*(?:=(?!=|>)|\\+=|-=|\\*=|\/=|%=|\\+\\+|--)`, "i"),
+    new RegExp(`(?:\\+\\+|--)\\s*${escaped}\\b|\\bdelete\\s+${escaped}\\b`, "i"),
+    new RegExp(`\\b(?:Object\\.(?:assign|definePropert(?:y|ies))|Reflect\\.(?:deleteProperty|set))\\s*\\(\\s*${escaped}\\b`, "i"),
+    new RegExp(`\\b${escaped}\\.(?:copyWithin|fill|pop|push|reverse|shift|sort|splice|unshift)\\s*\\(`, "i")
+  ].some((pattern) => pattern.test(body));
+}
+
+function primitiveNonMutationEvidence(task, profiles, sourceEntries) {
+  const contracts = primitiveContractParameters(task);
+  if (contracts.size === 0) return false;
+  const callables = [...new Set(profiles.flatMap((profile) => profile.callables))];
+  return callables.length > 0 && callables.every((callable) => {
+    const declared = declaredFunctionBody(sourceEntries, callable);
+    if (!declared || declared.parameters.length === 0) return false;
+    return declared.parameters.every((parameter) => {
+      const type = contracts.get(parameter);
+      if (!type || parameterMutationObserved(declared.body, parameter)) return false;
+      const guard = primitiveGuardIndex(declared.body, parameter, type);
+      if (guard < 0) return false;
+      const prefix = declared.body.slice(0, guard);
+      return !new RegExp(`\\b[a-z_$][a-z0-9_$.]*\\s*\\([^)]*\\b${escapeRegex(parameter)}\\b`, "i").test(prefix);
+    });
   });
 }
 
+function dependencyNeutralEvidence(corpus) {
+  const manifest = /(?:^|\/)(?:package(?:-lock)?\.json|npm-shrinkwrap\.json|pnpm-lock\.yaml|yarn\.lock|deno\.jsonc?|bun\.lockb?|requirements[^/]*\.txt|pyproject\.toml|poetry\.lock|cargo\.toml|cargo\.lock|go\.mod|go\.sum)$/i;
+  if (corpus.files.some((file) => manifest.test(file))) return false;
+  return corpus.sourceEntries.length > 0 && corpus.sourceEntries.every((entry) => (
+    moduleRecords(entry).every((record) => record.specifier.startsWith(".") || record.specifier.startsWith("node:"))
+  ));
+}
+
+function semanticTerm(value) {
+  if (/^(?:[a-z]+s|[a-z]+es)$/i.test(value) && !/(?:ss|us)$/i.test(value)) {
+    if (/(?:ches|shes|ses|xes|zes)$/i.test(value)) return value.slice(0, -2);
+    return value.slice(0, -1);
+  }
+  return value;
+}
+
+function semanticTerms(value) {
+  const separated = String(value ?? "").replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+  return new Set((normalizedText(separated).match(/[a-z][a-z0-9_$]{1,}/g) ?? [])
+    .map(semanticTerm)
+    .filter((word) => !BEHAVIOR_STOPWORDS.has(word)
+      && !new Set(["and", "the", "with", "from", "into", "this", "that", "for", "are", "was", "were", "has", "have", "then"]).has(word)));
+}
+
 function definedExpectedExpression(expression, strings, prelude = "") {
   const value = String(expression ?? "").trim();
   if (!value || /^(?:undefined|null|void\b)/i.test(value)) return false;
@@ -526,11 +704,11 @@ function assertionProvesDefinedField(call, field) {
 
 function linkedTestEvidence(linkage) {
   const profiles = [];
-  for (const { entry, callables } of linkage.entries) {
+  for (const { entry, callables, bindings } of linkage.entries) {
     if (!/\b(?:assert(?:\.[a-z][a-z0-9_]*)?\s*\(|expect\s*\()/i.test(entry.evidenceText)) continue;
     const bound = bindJavaScriptStrings(entry.text);
     const calls = callableSlices(bound.code, bound.strings, callables);
-    if (calls.length > 0) profiles.push({ path: entry.path, code: bound.code, calls, callables });
+    if (calls.length > 0) profiles.push({ path: entry.path, raw: entry.text, evidenceCode: normalizedText(entry.evidenceText), code: bound.code, calls, callables, bindings });
   }
   return profiles;
 }
@@ -688,14 +866,14 @@ export function verifierCommandsCoverTests(task, testPaths, cwd) {
   }));
 }
 
-function criterionBehaviorMatches(task, criterion, profiles, sourceFiles) {
-  const rawCriterion = boundCriterionText(task, criterion);
+function criterionConjunctMatches(task, rawCriterion, profiles, corpus) {
   if (!rawCriterion || profiles.length === 0) return false;
   const text = normalizedText(rawCriterion);
   const calls = profiles.flatMap((profile) => profile.calls);
   const code = calls.flatMap((call) => call.assertions).join("\n");
   const requirements = [];
-  if (rawCriterion.split(";").filter((clause) => clause.trim()).length > 1) return false;
+  const resultEvidence = acceptanceResultContractEvidence(rawCriterion, profiles, corpus.sourceEntries, [task?.summary, task?.expectedOutput, ...(task?.acceptanceCriteria ?? [])].filter(Boolean).join("\n"));
+  if (resultEvidence !== undefined) requirements.push(resultEvidence);
   if (/\bfocused\s+tests?\b/.test(text)) requirements.push(calls.length > 0);
   if (/--[a-z0-9_-]+=[a-z0-9_<[{]/i.test(text) || /\bname\s*=\s*value\b/.test(text)) {
     requirements.push(calls.some((call) => call.values.some((value) => {
@@ -734,8 +912,13 @@ function criterionBehaviorMatches(task, criterion, profiles, sourceFiles) {
       return expected !== undefined && assertedFlagValue(call, expected.name.slice(2), expected.value);
     }));
   }
-  if (/\b(?:do not|must not|without)\s+mutat|\bpreserve\s+(?:the\s+)?input/.test(text)) {
-    requirements.push(calls.some(nonMutationAssertion));
+  if (/\b(?:do not|must not|without)\s+mutat|\b(?:do not|must not)\s+[^.;]{0,100}\bor\s+mutat|\bpreserve\s+(?:the\s+)?input|\binputs? must remain unchanged\b/.test(text)) {
+    const requireAll = /\binputs\b|\b(?:both|either|all|any)\s+(?:of\s+)?(?:the\s+)?(?:arguments?|inputs?)\b/.test(text);
+    requirements.push(dependencyGraphNonMutationEvidence({rawCriterion,profiles,sourceEntries:corpus.sourceEntries}) || pureRecordNonMutationEvidence({rawCriterion,profiles,sourceEntries:corpus.sourceEntries}) || byteArrayNonMutationEvidence({rawCriterion,profiles,sourceEntries:corpus.sourceEntries}) || finiteIntervalNonMutationEvidence({ rawCriterion, profiles, sourceEntries: corpus.sourceEntries, contextText: [task?.summary, task?.expectedOutput, ...(task?.acceptanceCriteria ?? [])].filter(Boolean).join("\n") }) || calls.some((call) => nonMutationAssertion({ ...call, sourceEntries: corpus.sourceEntries }, requireAll))
+      || primitiveNonMutationEvidence(task, profiles, corpus.sourceEntries));
+  }
+  if (/\b(?:do not|must not|without)\s+add(?:ing)?\s+(?:new\s+)?dependenc/.test(text)) {
+    requirements.push(dependencyNeutralEvidence(corpus));
   }
   if (/\breturn shape\b|\breturned? (?:object|representation)\b/.test(text)) {
     requirements.push(calls.some((call) => assertionProvesDefinedField(call, "flags")
@@ -746,12 +929,23 @@ function criterionBehaviorMatches(task, criterion, profiles, sourceFiles) {
   if (errorClass) requirements.push(new RegExp(`\\b(?:assert\\.throws|rejects|tothrow)\\b[\\s\\S]{0,240}\\b${errorClass}\\b`, "i").test(code));
   if (requirements.length > 0) return requirements.every(Boolean);
   const names = new Set(profiles.flatMap((profile) => profile.callables).flatMap((name) => name.split(".")));
-  const paths = [...sourceFiles, ...profiles.map((profile) => profile.path)].join("\n");
+  const paths = [...corpus.sourceFiles, ...profiles.map((profile) => profile.path)].join("\n");
   const anchors = [...rawCriterion.matchAll(/\b[a-z_$][a-z0-9_$]{3,}\b/gi)]
     .map((match) => match[0]).filter((word) => !BEHAVIOR_STOPWORDS.has(word.toLowerCase()));
-  return anchors.some((anchor) => names.has(anchor)
+  const direct = anchors.some((anchor) => names.has(anchor)
     || new RegExp(`\\b${escapeRegex(anchor)}\\b`, "i").test(code)
     || new RegExp(`(?:^|[/_.-])${escapeRegex(anchor)}(?:[/_.-]|$)`, "i").test(paths));
+  const criterionTerms = semanticTerms(rawCriterion);
+  const descriptionTerms = semanticTerms(calls.flatMap((call) => call.descriptions ?? []).join("\n"));
+  const descriptionOverlap = [...criterionTerms].filter((term) => descriptionTerms.has(term));
+  return direct || descriptionOverlap.length >= 2;
+}
+
+function criterionBehaviorMatches(task, criterion, profiles, corpus) {
+  const rawCriterion = boundCriterionText(task, criterion);
+  const conjuncts = acceptanceContractConjuncts(rawCriterion);
+  return conjuncts.length > 0
+    && conjuncts.every((conjunct) => criterionConjunctMatches(task, conjunct, profiles, corpus));
 }
 
 function behavioralFocusRequired(input) {
@@ -777,7 +971,7 @@ function focusedBehaviorEvidence(input) {
   if (criterionBehaviorProofDisposition(input) !== "linked") return undefined;
   const linkage = testSourceLinkage(input.corpus);
   const profiles = linkedTestEvidence(linkage).filter((profile) => verifierCommandsCoverTests(input.task, [profile.path], input.cwd));
-  if (!criterionBehaviorMatches(input.task, input.criterion, profiles, input.corpus.sourceFiles)) return undefined;
+  if (!criterionBehaviorMatches(input.task, input.criterion, profiles, input.corpus)) return undefined;
   return {
     ...input.verifierEvidence,
     kind: "verifier-backed-focused-test",

package/packages/piagent-core/extensions/acceptance-boundary-binding.js

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+import { namedTargetBindings, sanitizeJavaScriptEvidence, sourceExports } from "./acceptance-contract-semantics.js";
+import { executableRejectionAssertions } from "./acceptance-executable-evidence.js";
+import { routeNamedSourceTargets } from "./acceptance-source-origin.js";
+
+// This is an additional provenance gate, not a numeric semantics prover. A
+// positive operation cannot borrow a rejection assertion or another function's
+// boundary tests. Keep the exact criterion hash and immediate subject context;
+// unresolved pronouns/ownership stay unproven instead of guessing by test names.
+export function boundaryTargetHasLiveSuccess({ task, criterion, corpus }) {
+  const criteria = task.acceptanceCriteria ?? [];
+  const index = criteria.findIndex(text => typeof text === "string"
+    && createHash("sha256").update(text).digest("hex") === criterion.hash);
+  const text = index >= 0 ? criteria[index] : "";
+  if (!/\bclamps?\b/i.test(text)) return true;
+  if (!/^otherwise\s+it\b|^`[A-Za-z_$][\w$]*`\s+clamps?\b/i.test(text.trim())) return true;
+  const subjectText = /^otherwise\s+it\b/i.test(text.trim()) ? criteria[index - 1] : text;
+  const target = String(subjectText ?? "").trim().match(/^`([A-Za-z_$][\w$]*)`\s+(?:returns?|clamps?)\b/i)?.[1]?.toLowerCase();
+  if (!target) return false;
+  const { strictTargets, unresolvedTargets } = routeNamedSourceTargets({ namedTargets: [target], provenanceTargets: new Set(),
+    sourceEntries: corpus.sourceEntries, exports: corpus.sourceEntries.flatMap(sourceExports), taskText: subjectText });
+  if (strictTargets.length !== 1 || unresolvedTargets.length > 0) return false;
+  const binding = namedTargetBindings(corpus.sourceEntries, corpus.testEntries, [target])[0];
+  return Boolean(binding?.sourceName && binding.testBindings.some(testBinding => {
+    const entry = corpus.testEntries.find(item => item.path === testBinding.testPath);
+    if (!entry) return false;
+    const code = sanitizeJavaScriptEvidence(entry.text).toLowerCase();
+    return executableRejectionAssertions(code, new Set([testBinding.testName]), false, true)
+      .some(assertion => assertion.mode === "does-not-throw" && assertion.targets.includes(testBinding.testName));
+  }));
+}