@piagent/platform 1.6.0 → 1.7.1

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

@@ -0,0 +1,1000 @@
+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";
+
+const BOUND_STRING = "__pi_bound_string_";
+const BEHAVIOR_STOPWORDS = new Set([
+  "after", "also", "before", "behavior", "change", "configured", "every", "first", "remain", "requested",
+  "return", "shape", "standalone", "support", "value", "verification", "without"
+]);
+
+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, "\\$&");
+}
+
+function normalizedText(value) {
+  return String(value ?? "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+}
+
+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|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) {
+  if (!task?.criterionGraph || criterionGraphValidationErrors(task.criterionGraph, task).length > 0) return undefined;
+  const criterionIndex = (Array.isArray(task.acceptanceCriteria) ? task.acceptanceCriteria : [])
+    .findIndex((text) => typeof text === "string" && sha256(text) === criterion?.hash);
+  return criterionIndex < 0 ? undefined : task.criterionGraph.nodes.find((node) => node.criterionIndex === criterionIndex);
+}
+
+function boundCriterionText(task, criterion) {
+  return (Array.isArray(task?.acceptanceCriteria) ? task.acceptanceCriteria : [])
+    .find((text) => typeof text === "string" && sha256(text) === criterion?.hash);
+}
+
+export function criterionRequiresBehavioralProof(task, criterion, taskText) {
+  return durableBehaviorProofRequired(taskText, task?.changeMode)
+    && boundCriterionGraphNode(task, criterion)?.proofKinds?.includes("behavioral-check") === true;
+}
+
+export function isVerificationOnlyCriterion(text) {
+  const value = normalizedText(text).replace(/^\s*\[[^\]]+\]\s*/, "").trim();
+  return /^(?:verify(?: the)? project|(?:run|execute|rerun|re-run)\s+(?:the\s+)?(?:(?:configured|exact|project|workspace|focused)\s+)?(?:verification(?: commands?)?|verifiers?|tests?|typecheck|lint|build)\b[\s\S]*|(?:the\s+)?(?:(?:configured|exact|project|workspace)\s+)?(?:verification(?: command)?|verifier|tests?|typecheck|lint|build)\b[\s\S]*\b(?:pass(?:es)?|run|succeed(?:s)?|verify)\b[\s\S]*)[.!?]*$/.test(value);
+}
+
+/* A small lexer used only to bind executable module strings and call inputs. */
+function bindJavaScriptStrings(value) {
+  const source = String(value ?? "");
+  const output = [];
+  const strings = [];
+  let index = 0;
+  while (index < source.length) {
+    const current = source[index];
+    const next = source[index + 1];
+    if (current === "/" && next === "/") {
+      while (index < source.length && !/[\r\n]/.test(source[index])) { output.push(" "); index += 1; }
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      const end = source.indexOf("*/", index + 2);
+      const limit = end < 0 ? source.length : end + 2;
+      while (index < limit) { output.push(/[\r\n]/.test(source[index]) ? source[index] : " "); index += 1; }
+      continue;
+    }
+    if (current === "'" || current === '"') {
+      const quote = current;
+      let cursor = index + 1;
+      let payload = "";
+      let closed = false;
+      while (cursor < source.length) {
+        if (source[cursor] === "\\") { payload += source.slice(cursor, cursor + 2); cursor += 2; continue; }
+        if (source[cursor] === quote) { cursor += 1; closed = true; break; }
+        payload += source[cursor]; cursor += 1;
+      }
+      if (closed) {
+        output.push(`${BOUND_STRING}${strings.length}__`);
+        strings.push(payload);
+      } else {
+        output.push(" ".repeat(Math.max(1, cursor - index)));
+      }
+      index = cursor;
+      continue;
+    }
+    if (current === "`") {
+      let cursor = index + 1;
+      let payload = "";
+      let closed = false;
+      let interpolated = false;
+      while (cursor < source.length) {
+        if (source[cursor] === "\\") { payload += source.slice(cursor, cursor + 2); cursor += 2; continue; }
+        if (source[cursor] === "$" && source[cursor + 1] === "{") interpolated = true;
+        if (source[cursor] === "`") { cursor += 1; closed = true; break; }
+        payload += source[cursor]; cursor += 1;
+      }
+      if (closed && !interpolated) {
+        output.push(`${BOUND_STRING}${strings.length}__`);
+        strings.push(payload);
+      } else {
+        output.push(" ".repeat(Math.max(1, cursor - index)));
+      }
+      index = cursor;
+      continue;
+    }
+    if (current === "/" && next !== "=" && regexCanStartAfterLexicalChunks(output)) {
+      let cursor = index + 1;
+      let inClass = false;
+      let closed = false;
+      while (cursor < source.length) {
+        if (source[cursor] === "\\") { cursor += 2; continue; }
+        if (source[cursor] === "[") inClass = true;
+        else if (source[cursor] === "]") inClass = false;
+        else if (source[cursor] === "/" && !inClass) { cursor += 1; while (/[a-z]/i.test(source[cursor] ?? "")) cursor += 1; closed = true; break; }
+        else if (/[\r\n]/.test(source[cursor])) break;
+        cursor += 1;
+      }
+      if (closed) {
+        output.push(" ".repeat(Math.max(1, cursor - index)));
+        index = cursor;
+        continue;
+      }
+    }
+    output.push(current);
+    index += 1;
+  }
+  return { code: output.join(""), strings };
+}
+
+
+function moduleRecords(entry) {
+  const evidence = String(entry.evidenceText ?? "");
+  if (!/\b(?:import|export|require)\b[\s\S]{0,260}\b__pi_[a-z0-9_]+__/i.test(evidence)) return [];
+  const { code, strings } = bindJavaScriptStrings(entry.text);
+  const records = [];
+  const token = "(__pi_bound_string_[0-9]+__)";
+  const patterns = [
+    { kind: "module", pattern: new RegExp(`\\b(?:import|export)\\s+([\\s\\S]{0,220}?)\\s+from\\s+${token}`, "g") },
+    { kind: "side-effect", pattern: new RegExp(`\\bimport\\s*(?:\\(\\s*)?${token}`, "g") },
+    { kind: "require", pattern: new RegExp(`\\b(?:const|let|var)\\s+([^=;\\n]{1,160})=\\s*require\\s*\\(\\s*${token}`, "g") }
+  ];
+  for (const { kind, pattern } of patterns) {
+    for (const match of code.matchAll(pattern)) {
+      const specifier = boundStringValue(match.at(-1), strings);
+      if (typeof specifier === "string") records.push({ kind, clause: match[1] ?? "", specifier });
+    }
+  }
+  return records;
+}
+
+function importedBindings(record) {
+  const bindings = [];
+  const clause = record.clause.trim();
+  for (const match of clause.matchAll(/(?:^|[{,])\s*([a-z_$][a-z0-9_$]*)\s*(?:as\s+([a-z_$][a-z0-9_$]*))?/gi)) {
+    bindings.push({ exported: match[1], local: match[2] ?? match[1] });
+  }
+  const namespace = clause.match(/\*\s+as\s+([a-z_$][a-z0-9_$]*)/i)?.[1];
+  if (namespace) bindings.push({ exported: "*", local: namespace });
+  const defaultBinding = clause.match(/^([a-z_$][a-z0-9_$]*)\s*(?:,|$)/i)?.[1];
+  if (defaultBinding && !bindings.some((item) => item.local === defaultBinding)) {
+    bindings.push({ exported: "default", local: defaultBinding });
+  }
+  if (record.kind === "require") {
+    for (const match of clause.matchAll(/(?:^|[{,])\s*([a-z_$][a-z0-9_$]*)\s*(?::\s*([a-z_$][a-z0-9_$]*))?/gi)) {
+      bindings.push({ exported: match[1], local: match[2] ?? match[1] });
+    }
+  }
+  return bindings;
+}
+
+function exportedNames(sourceEntries) {
+  const names = new Set();
+  for (const entry of sourceEntries) {
+    const text = String(entry.evidenceText ?? "");
+    for (const match of text.matchAll(/\bexport\s+(?:async\s+)?(?:function|class|const|let|var)\s+([a-z_$][a-z0-9_$]*)/gi)) names.add(match[1]);
+    for (const match of text.matchAll(/\bexport\s*\{([^}]+)\}/gi)) {
+      for (const item of match[1].split(",")) {
+        const name = item.trim().match(/(?:^|\s+as\s+)([a-z_$][a-z0-9_$]*)$/i)?.[1];
+        if (name) names.add(name);
+      }
+    }
+    for (const match of text.matchAll(/\b(?:module\.exports|exports)\.([a-z_$][a-z0-9_$]*)\s*=/gi)) names.add(match[1]);
+  }
+  return names;
+}
+
+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, "")]);
+  return sourceFiles.map((file) => normalizePathCandidate(file)).filter((source) => {
+    const stem = source.replace(/\.[a-z0-9]+$/i, "");
+    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 = 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 importBindings = importedBindings(record);
+      const sourcePaths = resolvedSpecifierSources(entry.path, record.specifier, corpus.sourceFiles);
+      if (sourcePaths.length > 0) {
+        linked = true;
+        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], bindings: callableBindings });
+  }
+  if (linkedEntries.length > 0) return { status: "linked", entries: linkedEntries };
+  return { status: unresolvedProjectImport ? "unknown" : "unlinked", entries: [] };
+}
+
+function balancedCallEnd(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 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;
+  for (const match of code.matchAll(pattern)) {
+    const open = code.indexOf("(", match.index);
+    let end = balancedCallEnd(code, open);
+    if (end < 0) continue;
+    if (/\bexpect\s*\(/i.test(match[0])) {
+      const statementEnd = code.slice(end).search(/[;\r\n]/);
+      if (statementEnd >= 0) end += statementEnd;
+    }
+    assertions.push({ start: match.index, end, code: code.slice(match.index, end) });
+  }
+  return assertions;
+}
+
+function assignedCallNames(code, callStart) {
+  const prefix = code.slice(Math.max(0, callStart - 160), callStart);
+  return [
+    prefix.match(/\b(?:const|let|var)\s+([a-z_$][a-z0-9_$]*)\s*=\s*(?:await\s*)?$/i)?.[1],
+    prefix.match(/\b([a-z_$][a-z0-9_$]*)\s*=\s*(?:await\s*)?$/i)?.[1]
+  ].filter(Boolean);
+}
+
+function nextBindingWrite(code, name, after) {
+  const escaped = escapeRegex(name);
+  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 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)) {
+      const open = code.indexOf("(", match.index);
+      const end = balancedCallEnd(code, open);
+      if (end < 0) continue;
+      const slice = code.slice(match.index, end);
+      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))];
+      const bindingNames = [...resultNames, ...argumentNames];
+      const resultWriteLimits = new Map(resultNames.map((name) => [name, nextBindingWrite(code, name, end)]));
+      const boundAssertions = assertions.filter((assertion) => (
+        (assertion.start <= match.index && assertion.end >= end)
+        || assertion.start >= end && bindingNames.some((name) => (
+          new RegExp(`\\b${escapeRegex(name)}\\b`).test(assertion.code)
+          && (!resultWriteLimits.has(name) || assertion.start < resultWriteLimits.get(name))
+        ))
+      ));
+      const assertionValues = boundAssertions.flatMap((assertion) => (
+        [...assertion.code.matchAll(/__pi_bound_string_[0-9]+__/g)]
+          .map((item) => boundStringValue(item[0], strings)).filter((item) => typeof item === "string")
+      ));
+      const call = {
+        callable,
+        slice, values, strings, resultNames, argumentNames, assertionValues, prelude: code.slice(0, match.index),
+        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 assertionComparisons(call) {
+  return call.assertions.flatMap((assertion) => {
+    const assertCall = assertion.match(/^\s*assert\.(?:equal|strictEqual|deepEqual|deepStrictEqual)\s*\(/i);
+    if (assertCall) {
+      const open = assertion.indexOf("(", assertCall.index);
+      const end = balancedCallEnd(assertion, open);
+      const [actual, expected] = end > open ? splitTopLevel(assertion.slice(open + 1, end - 1)) : [];
+      return actual && expected ? [{ actual, expected }] : [];
+    }
+    const expectCall = assertion.match(/^\s*expect\s*\(/i);
+    if (!expectCall) return [];
+    const open = assertion.indexOf("(", expectCall.index);
+    const end = balancedCallEnd(assertion, open);
+    const matcher = end > open ? assertion.slice(end).match(/^\s*\.to(?:Be|Equal|StrictEqual)\s*\(/i) : undefined;
+    if (!matcher) return [];
+    const expectedOpen = assertion.indexOf("(", end + matcher.index);
+    const expectedEnd = balancedCallEnd(assertion, expectedOpen);
+    return expectedEnd > expectedOpen ? [{ actual: assertion.slice(open + 1, end - 1).trim(), expected: assertion.slice(expectedOpen + 1, expectedEnd - 1).trim() }] : [];
+  });
+}
+
+
+function propertyExpression(objectExpression, property, strings) {
+  const value = String(objectExpression ?? "").trim();
+  if (!(value.startsWith("{") && value.endsWith("}"))) return undefined;
+  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) 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 fields.get(property);
+}
+
+function callResultExpression(call, expression) {
+  const value = String(expression ?? "");
+  return call.resultNames.some((name) => new RegExp(`^\\s*${escapeRegex(name)}\\b`).test(value)) || value.includes(call.slice);
+}
+
+function actualField(call, actual, container, field) {
+  if (!callResultExpression(call, actual)) return false;
+  const dot = new RegExp(`\\.${escapeRegex(container)}\\s*\\.\\s*${escapeRegex(field)}\\b`);
+  if (dot.test(actual)) return true;
+  const bracket = new RegExp(`\\.${escapeRegex(container)}\\s*\\[\\s*(__pi_bound_string_[0-9]+__)\\s*\\]`).exec(actual);
+  return bracket ? boundStringValue(bracket[1], call.strings) === field : false;
+}
+
+function actualContainer(call, actual, container) {
+  return callResultExpression(call, actual) && new RegExp(`\\.${escapeRegex(container)}\\s*$`).test(actual);
+}
+
+function actualWholeResult(call, actual) {
+  const value = String(actual ?? "").trim();
+  return call.resultNames.includes(value) || value === call.slice;
+}
+
+function expectedValueMatches(expression, expected, strings) {
+  return exactBoundValue(expression, strings) === expected;
+}
+
+function assertedFlagValue(call, flag, expected) {
+  return assertionComparisons(call).some(({ actual, expected: asserted }) => {
+    if (actualField(call, actual, "flags", flag)) return expectedValueMatches(asserted, expected, call.strings);
+    const flags = actualContainer(call, actual, "flags") ? asserted
+      : actualWholeResult(call, actual) ? propertyExpression(asserted, "flags", call.strings) : undefined;
+    const field = propertyExpression(flags, flag, call.strings);
+    return field !== undefined && expectedValueMatches(field, expected, call.strings);
+  });
+}
+
+function exactStringArray(expression, strings) {
+  const value = String(expression ?? "").trim();
+  if (!(value.startsWith("[") && value.endsWith("]"))) return undefined;
+  const items = splitTopLevel(value.slice(1, -1));
+  if (items.length === 1 && items[0] === "") return [];
+  const resolved = items.map((item) => boundStringValue(item, strings));
+  return resolved.every((item) => typeof item === "string") ? resolved : undefined;
+}
+
+function assertedPositionalSuffix(call, suffix) {
+  return assertionComparisons(call).some(({ actual, expected }) => {
+    const positional = actualContainer(call, actual, "positional") ? expected
+      : actualWholeResult(call, actual) ? propertyExpression(expected, "positional", call.strings) : undefined;
+    const observed = exactStringArray(positional, call.strings);
+    return observed !== undefined && JSON.stringify(observed) === JSON.stringify(suffix);
+  });
+}
+
+function repeatedFlagExpectedValue(values) {
+  const flags = [];
+  for (let index = 0; index < values.length; index += 1) {
+    const token = values[index];
+    if (token === "--") break;
+    if (!/^--[^=\s]+/.test(token)) continue;
+    const equals = token.indexOf("=");
+    if (equals >= 0) flags.push({ name: token.slice(0, equals), value: token.slice(equals + 1) });
+    else if (values[index + 1] !== undefined && !/^--/.test(values[index + 1])) {
+      flags.push({ name: token, value: values[index + 1] });
+      index += 1;
+    } else flags.push({ name: token, value: true });
+  }
+  const repeated = flags.filter((flag, index) => flags.some((other, otherIndex) => otherIndex < index && other.name === flag.name));
+  return repeated.at(-1);
+}
+
+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 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) => {
+    const value = item.trim();
+    return value === "" || exactBoundValue(value, call.strings) !== undefined
+      || /^(?:true|false|null|undefined|[-+]?\\d+(?:\\.\\d+)?n?)$/.test(value);
+  });
+  if (!primitiveElements) return undefined;
+  const shallowPatterns = [
+    new RegExp(`\\b(?:const|let)\\s+([a-z_$][a-z0-9_$]*)\\s*=\\s*\\[\\s*\\.\\.\\.\\s*${escaped}\\s*\\]`, "gi"),
+    new RegExp(`\\b(?:const|let)\\s+([a-z_$][a-z0-9_$]*)\\s*=\\s*${escaped}\\.(?:slice|concat)\\s*\\(\\s*\\)`, "gi"),
+    new RegExp(`\\b(?:const|let)\\s+([a-z_$][a-z0-9_$]*)\\s*=\\s*Array\\.from\\s*\\(\\s*${escaped}\\s*\\)`, "gi")
+  ];
+  return shallowPatterns.flatMap((pattern) => [...call.prelude.matchAll(pattern)].map((match) => match[1])).at(-1);
+}
+
+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;
+    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;
+  const identifier = value.match(/^[a-z_$][a-z0-9_$]*$/i)?.[0];
+  if (identifier && new RegExp(`\\b(?:const|let)\\s+${escapeRegex(identifier)}\\s*=\\s*(?:\\{|\\[|true\\b|false\\b|[-+]?\\d|${BOUND_STRING})`, "i").test(prelude)) return true;
+  return exactBoundValue(value, strings) !== undefined
+    || /^(?:true|false|[-+]?\d+(?:\.\d+)?n?|\{|\[)/.test(value);
+}
+
+function positiveDefinedPredicate(call, expression, field) {
+  const value = String(expression ?? "").trim();
+  if (actualContainer(call, value, field)) return true;
+  const arrayCheck = value.match(/^Array\.isArray\s*\(([\s\S]+)\)$/i);
+  if (arrayCheck && actualContainer(call, arrayCheck[1], field)) return true;
+  const comparison = value.match(/^([\s\S]+?)\s*(===|==|!==|!=)\s*([\s\S]+)$/);
+  if (!comparison || !actualContainer(call, comparison[1], field)) return false;
+  const expected = comparison[3].trim();
+  if (comparison[2] === "!==" && expected === "undefined") return true;
+  if (comparison[2] === "!=" && /^(?:undefined|null)$/.test(expected)) return true;
+  return ["===", "=="].includes(comparison[2]) && definedExpectedExpression(expected, call.strings, call.prelude);
+}
+
+function assertionProvesDefinedField(call, field) {
+  if (assertionComparisons(call).some(({ actual, expected }) => {
+    if (actualContainer(call, actual, field)) return definedExpectedExpression(expected, call.strings, call.prelude);
+    if (!actualWholeResult(call, actual)) return false;
+    const fieldValue = propertyExpression(expected, field, call.strings);
+    return fieldValue !== undefined && definedExpectedExpression(fieldValue, call.strings, call.prelude);
+  })) return true;
+  return call.assertions.some((assertion) => {
+    const ok = assertion.match(/^\s*assert\.ok\s*\(/i);
+    if (ok) {
+      const open = assertion.indexOf("(", ok.index);
+      const end = balancedCallEnd(assertion, open);
+      return end > open && positiveDefinedPredicate(call, assertion.slice(open + 1, end - 1), field);
+    }
+    const expected = assertion.match(/^\s*expect\s*\(/i);
+    if (!expected) return false;
+    const open = assertion.indexOf("(", expected.index);
+    const end = balancedCallEnd(assertion, open);
+    return end > open && actualContainer(call, assertion.slice(open + 1, end - 1), field)
+      && /^\s*\.toBeDefined\s*\(/i.test(assertion.slice(end));
+  });
+}
+
+function linkedTestEvidence(linkage) {
+  const profiles = [];
+  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, raw: entry.text, evidenceCode: normalizedText(entry.evidenceText), code: bound.code, calls, callables, bindings });
+  }
+  return profiles;
+}
+
+function shellTokens(command) {
+  return (String(command ?? "").match(/"[^"]*"|'[^']*'|[^\s]+/g) ?? [])
+    .map((token) => token.replace(/^(['"])([\s\S]*)\1$/, "$2"));
+}
+
+function shellStructure(command) {
+  const value = String(command ?? ""), segments = [], operators = [];
+  let quote = "", escaped = false, start = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const token = value[index];
+    if (escaped) { escaped = false; continue; }
+    if (token === "\\") { escaped = true; continue; }
+    if (quote) { if (token === quote) quote = ""; continue; }
+    if (token === "'" || token === '"') { quote = token; continue; }
+    const pair = value.slice(index, index + 2);
+    const width = ["&&", "||", "|&"].includes(pair) ? 2
+      : token === ";" || token === "\n" || token === "|" || (token === "&" && !/[<>]/.test(value[index - 1] ?? "")) ? 1 : 0;
+    if (!width) continue;
+    if (value.slice(start, index).trim()) segments.push(value.slice(start, index).trim());
+    operators.push(value.slice(index, index + width));
+    start = index + width; index += width - 1;
+  }
+  if (value.slice(start).trim()) segments.push(value.slice(start).trim());
+  return { segments, operators };
+}
+
+function shellSegments(command) { return shellStructure(command).segments; }
+
+function workspacePredicatePath(cwd, candidate, executable) {
+  if (typeof cwd !== "string" || !cwd) return false;
+  const relative = normalizePathCandidate(String(candidate ?? "").replace(/^\.\//, ""));
+  if (!relative || path.isAbsolute(relative) || relative.split("/").includes("..")) return false;
+  try {
+    const target = path.join(cwd, relative);
+    if (executable) { fs.accessSync(target, fs.constants.X_OK); return fs.statSync(target).isFile(); }
+    return fs.statSync(target).isFile();
+  } catch { return false; }
+}
+
+function commandAvailable(command) {
+  const name = String(command ?? "");
+  return /^[a-z0-9_.-]+$/i.test(name) && String(process.env.PATH ?? "").split(path.delimiter).some((directory) => {
+    try { fs.accessSync(path.join(directory, name), fs.constants.X_OK); return true; } catch { return false; }
+  });
+}
+
+function safeConditionPart(part, cwd) {
+  const value = String(part ?? "").trim();
+  const file = value.match(/^test\s+-(f|x)\s+([^\s]+)$/i);
+  if (file) return workspacePredicatePath(cwd, file[2], file[1].toLowerCase() === "x");
+  const available = value.match(/^command\s+-v\s+([a-z0-9_.-]+)(?:\s+>\/dev\/null\s+2>&1)?$/i);
+  if (available) return commandAvailable(available[1]);
+  if (/^node\s+-e\b/.test(value) && /scripts?\|\|\{\}/.test(value) && /s\.test\?0:1/.test(value)) {
+    try { return typeof JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"))?.scripts?.test === "string"; } catch { return false; }
+  }
+  return value === "true";
+}
+
+function verifierWorkingDirectory(cwd, body) {
+  const target = body.map((segment) => segment.match(/^cd\s+([^\s]+)$/)?.[1]).find(Boolean);
+  if (!target) return cwd;
+  const relative = normalizePathCandidate(String(target).replace(/^\.\//, ""));
+  const resolved = relative && cwd ? path.resolve(cwd, relative) : "";
+  try {
+    return resolved && !path.relative(cwd, resolved).split(path.sep).includes("..") && fs.statSync(resolved).isDirectory() ? resolved : undefined;
+  } catch { return undefined; }
+}
+
+function executableVerifierPlan(command, cwd) {
+  const { segments, operators } = shellStructure(command);
+  if (operators.some((operator) => ["||", "|", "|&", "&"].includes(operator))) return { segments: [], cwd };
+  let cursor = segments.findIndex((segment) => /^if\b/.test(segment));
+  if (cursor < 0) return { segments: operators.some((operator) => operator === ";" || operator === "\n") ? [] : segments, cwd };
+  let selected;
+  while (cursor >= 0 && cursor < segments.length) {
+    const marker = segments[cursor].match(/^(?:if|elif)\s+([\s\S]+)$/);
+    if (!marker) return { segments: [], cwd };
+    const condition = [marker[1]];
+    cursor += 1;
+    while (cursor < segments.length && !/^then\b/.test(segments[cursor])) condition.push(segments[cursor++]);
+    if (cursor >= segments.length) return { segments: [], cwd };
+    const body = [segments[cursor].replace(/^then\s*/, "")].filter(Boolean);
+    cursor += 1;
+    while (cursor < segments.length && !/^(?:elif|else|fi)\b/.test(segments[cursor])) body.push(segments[cursor++]);
+    if (condition.every((part) => safeConditionPart(part, cwd))) { selected = body; break; }
+    if (!/^elif\b/.test(segments[cursor] ?? "")) return { segments: [], cwd };
+  }
+  const end = segments.findIndex((segment, index) => index >= cursor && /^fi\b/.test(segment));
+  const selectedCwd = selected && verifierWorkingDirectory(cwd, selected);
+  return !selected || end < 0 || !selectedCwd ? { segments: [], cwd }
+    : { segments: [...selected, ...segments.slice(end + 1)], cwd: selectedCwd };
+}
+
+function testPathMatchesToken(testPath, token) {
+  const candidate = normalizePathCandidate(String(token ?? "").replace(/^\.\//, ""));
+  const target = normalizePathCandidate(testPath);
+  if (!/[?*]/.test(candidate)) return candidate === target;
+  const pattern = escapeRegex(candidate).replace(/\\\*\\\*\//g, "(?:.*/)?").replace(/\\\*\\\*/g, ".*").replace(/\\\*/g, "[^/]*").replace(/\\\?/g, "[^/]");
+  return new RegExp(`^${pattern}$`).test(target);
+}
+
+function testRunnerArguments(segment) {
+  const tokens = shellTokens(segment).filter((token) => !["then", "do"].includes(token));
+  while (/^[a-z_][a-z0-9_]*=/i.test(tokens[0] ?? "")) tokens.shift();
+  if (/^(?:npm|pnpm|yarn|bun)$/.test(tokens[0] ?? "")) {
+    const scriptIndex = tokens[1] === "run" ? 2 : 1, script = tokens[scriptIndex];
+    if (script === "test") return { args: tokens.slice(scriptIndex + 1).filter((token) => token !== "--" && token !== "--if-present") };
+    if (/^test:[a-z0-9_.-]+$/i.test(script ?? "")) return { args: [], packageScript: script };
+    return undefined;
+  }
+  const joined = tokens.join(" ");
+  const runners = [
+    /^node --test\b/, /^(?:uv run |python -m )?pytest\b/,
+    /^(?:npx )?(?:vitest(?: run)?|jest|playwright test|cypress run)\b/
+  ];
+  for (const runner of runners) {
+    const match = joined.match(runner);
+    if (match) return { args: shellTokens(joined.slice(match[0].length)).filter((token) => token !== "--") };
+  }
+  if (/^(?:flutter test|\.\/(?:mvnw|gradlew) test)$/.test(joined)) return { args: [] };
+  return undefined;
+}
+
+function packageTestScriptCovers(cwd, scriptName, testPath) {
+  if (typeof cwd !== "string" || !cwd) return false;
+  try {
+    const script = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"))?.scripts?.[scriptName];
+    const structure = shellStructure(script);
+    return typeof script === "string" && structure.segments.length === 1 && structure.operators.length === 0
+      && verifierSegmentCoversTest(structure.segments[0], testPath, cwd, false);
+  } catch { return false; }
+}
+
+function verifierSegmentCoversTest(segment, testPath, cwd, allowPackageScript = true) {
+  const runner = testRunnerArguments(segment);
+  if (!runner || runner.packageScript && !allowPackageScript) return false;
+  if (runner.packageScript) return packageTestScriptCovers(cwd, runner.packageScript, testPath);
+  if (/(?:^|\s)--if-present(?:\s|$)/.test(segment) && !packageTestScriptCovers(cwd, "test", testPath)) return false;
+  const pathArguments = runner.args.filter((token) => !token.startsWith("-"));
+  return pathArguments.length === 0 || pathArguments.some((token) => testPathMatchesToken(testPath, token));
+}
+
+export function verifierCommandsCoverTests(task, testPaths, cwd) {
+  const commands = (Array.isArray(task?.verifyCommands) ? task.verifyCommands : []).filter((command) => typeof command === "string");
+  return testPaths.length > 0 && testPaths.every((testPath) => commands.some((command) => {
+    const plan = executableVerifierPlan(command, cwd);
+    const prefix = normalizePathCandidate(cwd && plan.cwd ? path.relative(cwd, plan.cwd).replaceAll("\\", "/") : "");
+    const normalizedTest = normalizePathCandidate(testPath);
+    const relativeTest = prefix ? normalizedTest.startsWith(prefix + "/") ? normalizedTest.slice(prefix.length + 1) : "" : normalizedTest;
+    return Boolean(relativeTest) && plan.segments.some((segment) => verifierSegmentCoversTest(segment, relativeTest, plan.cwd));
+  }));
+}
+
+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 = [];
+  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) => {
+      const match = value.match(/^--([^=\s]+)=(.+)$/);
+      return match ? assertedFlagValue(call, match[1], match[2]) : false;
+    })));
+  }
+  if (/--[a-z0-9_-]+\s+(?:value|<[^>]+>)/i.test(text)) {
+    requirements.push(calls.some((call) => call.values.some((value, index) => {
+      const name = value.match(/^--([^=\s]+)$/)?.[1], expected = call.values[index + 1];
+      return name && expected !== undefined && !/^--/.test(expected) && assertedFlagValue(call, name, expected);
+    })));
+  }
+  if (/\bboolean\b[\s\S]{0,30}--[a-z0-9_-]+/i.test(text)) {
+    requirements.push(calls.some((call) => call.values.some((value, index) => {
+      const name = value.match(/^--([^=\s]+)$/)?.[1];
+      return name && (call.values[index + 1] === undefined || /^--/.test(call.values[index + 1]))
+        && assertedFlagValue(call, name, true);
+    })));
+  }
+  if (/\bstandalone\s+`?--`?(?=\s|$)|`?--`?\s+(?:ends?|stops?)\s+flag/i.test(text)) {
+    requirements.push(calls.some((call) => {
+      const delimiter = call.values.indexOf("--"), suffix = call.values.slice(delimiter + 1);
+      return delimiter >= 0 && suffix.length > 0 && assertedPositionalSuffix(call, suffix);
+    }));
+  }
+  if (/\bflag\s+followed\s+by\s+another\s+flag\b/.test(text)) {
+    requirements.push(calls.some((call) => call.values.some((value, index) => {
+      const name = value.match(/^--([^=\s]+)$/)?.[1];
+      return name && /^--[^=\s]+$/.test(call.values[index + 1] ?? "") && assertedFlagValue(call, name, true);
+    })));
+  }
+  if (/\brepeated?\s+flags?\b|\blast\s+value\b/.test(text)) {
+    requirements.push(calls.some((call) => {
+      const expected = repeatedFlagExpectedValue(call.values);
+      return expected !== undefined && assertedFlagValue(call, expected.name.slice(2), expected.value);
+    }));
+  }
+  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")
+      && assertionProvesDefinedField(call, "positional")));
+  }
+  if (/\bconcurren|\bparallel\b/.test(text)) requirements.push(/\bpromise\.all\s*\(|\ballsettled\s*\(/i.test(code));
+  const errorClass = text.match(/\b(typeerror|syntaxerror|rangeerror)\b/)?.[1];
+  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 = [...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()));
+  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) {
+  if (input.obligation === "requested-behavior") {
+    return criterionRequiresBehavioralProof(input.task, input.criterion, input.taskText)
+      || input.criterion.priority === "critical";
+  }
+  return input.obligation === "backward-compatibility"
+    && (criterionRequiresBehavioralProof(input.task, input.criterion, input.taskText) || input.criterion.priority === "critical");
+}
+
+export function criterionBehaviorProofDisposition(input) {
+  if (!behavioralFocusRequired(input)) return "not-applicable";
+  if (!input.passingVerifier) return "unlinked";
+  if (!input.corpus.adapter.proofCapable) {
+    return ["unsupported", "unresolved"].includes(input.corpus.adapter.status) ? "unknown" : "unlinked";
+  }
+  if (input.corpus.sourceFiles.length === 0 || input.corpus.testFiles.length === 0) return "unlinked";
+  return testSourceLinkage(input.corpus).status;
+}
+
+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)) return undefined;
+  return {
+    ...input.verifierEvidence,
+    kind: "verifier-backed-focused-test",
+    summary: "Configured verifier passed with changed executable assertions tied to this criterion and changed source.",
+    paths: [...new Set([...input.corpus.sourceFiles, ...profiles.map((profile) => profile.path)])]
+  };
+}
+
+export function genericCriterionEvidence(input) {
+  const behavioral = criterionRequiresBehavioralProof(input.task, input.criterion, input.taskText);
+  if (input.obligation === "requested-behavior") {
+    return { handled: true, evidence: behavioralFocusRequired(input)
+      ? focusedBehaviorEvidence(input)
+      : input.passingVerifier ? input.verifierEvidence : undefined };
+  }
+  if (input.obligation === "verification-evidence" || input.obligation === "backward-compatibility") {
+    return { handled: true, evidence: behavioralFocusRequired(input) ? focusedBehaviorEvidence(input)
+      : input.passingVerifier ? input.verifierEvidence : undefined };
+  }
+  return { handled: false, behavioral };
+}
+
+export function genericFallbackEvidence(input) {
+  /* No criterion is available at this legacy fallback boundary: abstain for behavioral proof. */
+  return input.behavioral ? undefined : input.passingVerifier ? input.verifierEvidence : undefined;
+}