@piagent/platform 1.6.0 → 1.7.1

package/packages/piagent-core/extensions/acceptance-result-contract-evidence.js

@@ -0,0 +1,159 @@
+import { finiteIntervalFallbackEvidence } from "./acceptance-temporal-contract.js";
+import { normalizePathCandidate } from "./policy-core.js";
+
+function escapeRegex(value) {
+  return String(value ?? "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function balancedEnd(code, openIndex, opening = "(", closing = ")") {
+  let depth = 0;
+  for (let index = openIndex; index < code.length; index += 1) {
+    if (code[index] === opening) depth += 1;
+    else if (code[index] === closing && --depth === 0) return index + 1;
+  }
+  return -1;
+}
+
+function splitTopLevel(value) {
+  const parts = [];
+  let start = 0;
+  let round = 0;
+  let square = 0;
+  let 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 boundStringValue(token, strings) {
+  const index = Number(String(token ?? "").match(/^__pi_bound_string_(\d+)__$/)?.[1]);
+  return Number.isInteger(index) ? strings[index] : undefined;
+}
+
+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 assertionComparisons(call) {
+  return call.assertions.flatMap((assertion) => {
+    const match = assertion.match(/^\s*assert\.(?:equal|strictEqual|deepEqual|deepStrictEqual)\s*\(/i);
+    if (!match) return [];
+    const open = assertion.indexOf("(", match.index);
+    const end = balancedEnd(assertion, open);
+    const [actual, expected] = end > open ? splitTopLevel(assertion.slice(open + 1, end - 1)) : [];
+    return actual && expected ? [{ actual, expected }] : [];
+  });
+}
+
+function actualWholeResult(call, actual) {
+  const value = String(actual ?? "").trim();
+  return call.resultNames.includes(value) || value === call.slice;
+}
+
+function wholeResultStringArrays(call) {
+  return assertionComparisons(call).flatMap(({ actual, expected }) => {
+    if (!actualWholeResult(call, actual)) return [];
+    const strings = exactStringArray(expected, call.strings);
+    return strings === undefined ? [] : [strings];
+  });
+}
+
+function callArgumentExpressions(call) {
+  const open = call.slice.indexOf("(");
+  const end = open >= 0 ? balancedEnd(call.slice, open) : -1;
+  return end > open ? splitTopLevel(call.slice.slice(open + 1, end - 1)) : [];
+}
+
+function exactPositiveInteger(expression) {
+  const value = String(expression ?? "").trim().replaceAll("_", "");
+  if (!/^[+]?[0-9]+$/.test(value)) return undefined;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function arrayExpressionLength(call, expression) {
+  const value = String(expression ?? "").trim();
+  let array = value;
+  if (/^[a-z_$][a-z0-9_$]*$/i.test(value)) {
+    const pattern = new RegExp(`\\b(?:const|let|var)\\s+${escapeRegex(value)}\\s*=\\s*\\[`, "gi");
+    const declaration = [...call.prelude.matchAll(pattern)].at(-1);
+    if (!declaration) return undefined;
+    const open = call.prelude.indexOf("[", declaration.index + declaration[0].length - 1);
+    const end = balancedEnd(call.prelude, open, "[", "]");
+    if (end < 0) return undefined;
+    array = call.prelude.slice(open, end);
+  }
+  if (!(array.startsWith("[") && array.endsWith("]"))) return undefined;
+  const items = splitTopLevel(array.slice(1, -1));
+  return items.length === 1 && items[0] === "" ? 0 : items.length;
+}
+
+function declaredFunction(sourceEntries, profile, call) {
+  const binding = profile.bindings?.find((item) => item.testName === call.callable);
+  const name = binding?.sourceName ?? call.callable.split(".").at(-1);
+  const entries = binding
+    ? sourceEntries.filter((entry) => normalizePathCandidate(entry.path) === binding.sourcePath)
+    : sourceEntries;
+  const pattern = new RegExp(`\\bfunction\\s+${escapeRegex(name)}\\s*\\(([^)]*)\\)\\s*\\{`, "i");
+  for (const entry of entries) {
+    const match = pattern.exec(entry.text);
+    if (!match) continue;
+    const open = entry.text.indexOf("{", match.index + match[0].length - 1);
+    const end = balancedEnd(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 returnExpressions(body) {
+  return [...String(body ?? "").matchAll(/\breturn\s+([\s\S]{1,1200}?);/gi)].map((match) => match[1]);
+}
+
+function sourceResultContract(body, idsRequired, capParameter) {
+  const idMap = /\.map\s*\(\s*(?:\(\s*)?([a-z_$][a-z0-9_$]*)\s*(?:\)\s*)?=>\s*(?:\{\s*return\s+)?\1\s*\.\s*id\b/i;
+  const cap = capParameter
+    ? new RegExp(`\\.slice\\s*\\(\\s*0\\s*,\\s*${escapeRegex(capParameter)}\\s*\\)`, "i")
+    : undefined;
+  return returnExpressions(body).some((expression) => (!idsRequired || idMap.test(expression)) && (!cap || cap.test(expression)));
+}
+
+export function acceptanceResultContractEvidence(rawCriterion, profiles, sourceEntries, contextText) {
+  if (/^otherwise\s+return\b/i.test(String(rawCriterion).trim())) return finiteIntervalFallbackEvidence({ rawCriterion, profiles, sourceEntries, contextText });
+  const text = String(rawCriterion ?? "").toLowerCase();
+  const idsRequired = /\breturn(?:s|ed)?\s+only\b[^.;]{0,80}\bids?\b/.test(text);
+  const capParameter = String(rawCriterion ?? "").match(/\bcapped\s+at\s+`?([a-z_$][a-z0-9_$]*)`?/i)?.[1];
+  if (!idsRequired && !capParameter) return undefined;
+  return profiles.some((profile) => profile.calls.some((call) => {
+    const callable = declaredFunction(sourceEntries, profile, call);
+    if (!callable) return false;
+    const expectedArrays = wholeResultStringArrays(call);
+    if (!sourceResultContract(callable.body, idsRequired, capParameter) || (idsRequired && expectedArrays.length === 0)) return false;
+    if (!capParameter) return true;
+    const parameterIndex = callable.parameters.indexOf(capParameter);
+    const args = callArgumentExpressions(call);
+    const cap = parameterIndex >= 0 ? exactPositiveInteger(args[parameterIndex]) : undefined;
+    const inputLength = arrayExpressionLength(call, args[0]);
+    return cap !== undefined && inputLength !== undefined && inputLength > cap
+      && expectedArrays.some((expected) => expected.length === cap);
+  }));
+}

package/packages/piagent-core/extensions/acceptance-source-origin.js

@@ -0,0 +1,214 @@
+import path from "node:path";
+import { parse } from "@babel/parser";
+
+const cache = new Map();
+const MAX_SOURCE_LENGTH = 64_000, MAX_NODES = 12_000, MAX_CACHE_ENTRIES = 32;
+const modulePath = value => path.posix.normalize(String(value).replace(/\\/g, "/"));
+const callable = node => ["FunctionExpression", "ArrowFunctionExpression"].includes(node?.type);
+const nameOf = node => node?.type === "Identifier" ? node.name
+  : node?.type === "PrivateName" ? node.id.name
+    : ["StringLiteral", "NumericLiteral"].includes(node?.type) ? String(node.value) : null;
+const bindingNames = node => node?.type === "Identifier" ? [node.name]
+  : node?.type === "ObjectPattern" ? node.properties.flatMap(item => bindingNames(item.type === "RestElement" ? item.argument : item.value))
+    : node?.type === "ArrayPattern" ? node.elements.flatMap(bindingNames)
+      : node?.type === "AssignmentPattern" ? bindingNames(node.left)
+        : node?.type === "RestElement" ? bindingNames(node.argument) : [];
+
+
+// A computed store of a plain record into a function-local fresh copy does
+// not introduce a callable origin under that dynamic key. Its child members
+// are still inventoried normally. This classifies origin only, not behavior.
+function localRecordStore(node, enclosing, ast) {
+  if (node.operator !== "=" || !node.left.computed || node.right.type !== "ObjectExpression"
+    || node.right.properties.some(item => item.type !== "ObjectProperty" || item.computed || item.method)) return false;
+  let receiver = node.left.object;
+  while (receiver?.type === "MemberExpression" && !receiver.computed) {
+    if (["constructor", "prototype", "__proto__"].includes(receiver.property.name)) return false;
+    receiver = receiver.object;
+  }
+  if (receiver?.type !== "Identifier" || ["module", "exports", "global", "globalThis", "Object", "Function"].includes(receiver.name)) return false;
+  const fn = [...enclosing].reverse().find(item => ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression", "ObjectMethod", "ClassMethod"].includes(item.type));
+  if (!fn || fn.async || fn.generator || fn.body.type !== "BlockStatement" || fn.params.some(item => bindingNames(item).includes(receiver.name))) return false;
+  const declarations = fn.body.body.filter(item => item.type === "VariableDeclaration" && item.kind === "const")
+    .flatMap(item => item.declarations).filter(item => item.id.type === "Identifier" && item.id.name === receiver.name && item.end < node.start);
+  if (declarations.length !== 1) return false;
+  const declaration = declarations[0], value = declaration.init;
+  const cloned = value?.type === "CallExpression" && value.callee.type === "Identifier" && value.callee.name === "structuredClone"
+    && value.arguments.length === 1 && value.arguments[0].type === "Identifier" && fn.params.some(item => item.type === "Identifier" && item.name === value.arguments[0].name);
+  if (!cloned && !(value?.type === "ObjectExpression" && value.properties.length === 0)) return false;
+  let count = 0, valid = true;
+  const inspect = (item, parent, local, depth = 0) => {
+    if (!item || typeof item.type !== "string") return;
+    if (++count > MAX_NODES || depth > 128) throw new Error("source-origin-local-store-budget");
+    const inside = local || item === fn;
+    if (inside && item.type === "VariableDeclarator" && item !== declaration && bindingNames(item.id).includes(receiver.name)) valid = false;
+    if (inside && item !== fn && /Function|Method|Class/.test(item.type) && (item.id?.name === receiver.name || item.params?.some(param => bindingNames(param).includes(receiver.name)))) valid = false;
+    if (inside && item.type === "CatchClause" && bindingNames(item.param).includes(receiver.name)) valid = false;
+    if (inside && ["AssignmentExpression", "UpdateExpression"].includes(item.type) && bindingNames(item.left ?? item.argument).includes(receiver.name)) valid = false;
+    if (cloned && item.type === "Identifier" && item.name === "structuredClone"
+      && !(parent?.type === "CallExpression" && parent.callee === item && parent.arguments.length === 1)) valid = false;
+    for (const [key, child] of Object.entries(item)) {
+      if (["loc", "start", "end", "extra", "comments", "tokens", "errors"].includes(key)) continue;
+      if (Array.isArray(child)) child.forEach(part => inspect(part, item, inside, depth + 1));
+      else if (child && typeof child === "object") inspect(child, item, inside, depth + 1);
+    }
+  };
+  inspect(ast, null, false);
+  return valid;
+}
+
+// Parse syntax only: never load project modules, run configuration, or evaluate
+// initializers. Cache compact origin records, not ASTs or acceptance results.
+function sourceOrigins(entry) {
+  if (typeof entry.text !== "string" || entry.text.length > MAX_SOURCE_LENGTH) return null;
+  const extension = path.posix.extname(entry.path).toLowerCase();
+  const key = `${extension}\0${entry.text}`;
+  if (cache.has(key)) return cache.get(key);
+  let result = null;
+  try {
+    const plugins = /\.[cm]?tsx?$/.test(extension) ? ["typescript"] : [];
+    if (!/\.[cm]?ts$/.test(extension)) plugins.push("jsx");
+    const ast = parse(entry.text, { sourceType: "unambiguous", plugins,
+      errorRecovery: false, attachComment: false, allowReturnOutsideFunction: false });
+    const origins = [], exportEdges = [], exportObjects = new Set(), seen = new Set();
+    let count = 0, localStoreChecks = 0, unresolvedComputedMember = false, commonJsSeen = false, commonJsRebound = false;
+    const add = (name, kind, node, topLevel = false, referenceName = null) => {
+      if (typeof name !== "string") { unresolvedComputedMember = true; return; }
+      const identity = `${name}\0${node.start}\0${node.end}`;
+      if (seen.has(identity)) return;
+      seen.add(identity);
+      origins.push(Object.freeze({ name, kind, start: node.start, end: node.end, topLevel, referenceName }));
+    };
+    const memberPath = node => node?.type === "Identifier" ? [node.name]
+      : node?.type === "MemberExpression" && (!node.computed || node.property.type === "StringLiteral")
+        ? [...(memberPath(node.object) ?? []), nameOf(node.property)] : null;
+    const commonJsExport = node => {
+      const names = memberPath(node);
+      if (names?.[0] === "exports" && names.length === 2) return names[1];
+      if (names?.[0] === "module" && names[1] === "exports" && names.length <= 3) return names[2] ?? "default";
+      return null;
+    };
+    for (const statement of ast.program.body) {
+      if (statement.type === "ExportNamedDeclaration") {
+        if (statement.source) unresolvedComputedMember = true;
+        else if (statement.declaration?.id) exportEdges.push({ exportName: statement.declaration.id.name, localName: statement.declaration.id.name });
+        else if (statement.declaration?.type === "VariableDeclaration") {
+          for (const declaration of statement.declaration.declarations) {
+            if (declaration.id.type === "Identifier") exportEdges.push({ exportName: declaration.id.name, localName: declaration.id.name });
+          }
+        } else for (const specifier of statement.specifiers) {
+          if (specifier.type === "ExportSpecifier") exportEdges.push({ exportName: nameOf(specifier.exported), localName: specifier.local.name });
+        }
+      }
+      if (statement.type === "ExportDefaultDeclaration") {
+        const localName = statement.declaration.id?.name ?? (statement.declaration.type === "Identifier" ? statement.declaration.name : null);
+        if (localName) exportEdges.push({ exportName: "default", localName });
+      }
+      const assignment = statement.type === "ExpressionStatement" ? statement.expression : null;
+      const exportedName = assignment?.type === "AssignmentExpression" ? commonJsExport(assignment.left) : null;
+      if (exportedName !== null) {
+        commonJsSeen = true;
+        if (assignment.operator !== "=") unresolvedComputedMember = true;
+        else if (assignment.right.type === "Identifier") exportEdges.push({ exportName: exportedName, localName: assignment.right.name });
+        else if (exportedName === "default" && assignment.right.type === "ObjectExpression") {
+          exportObjects.add(assignment.right);
+          for (const property of assignment.right.properties) {
+            const exportName = property.computed && property.key?.type !== "StringLiteral" ? null : nameOf(property.key);
+            if (property.type !== "ObjectProperty" || !exportName || property.value.type !== "Identifier") unresolvedComputedMember = true;
+            else exportEdges.push({ exportName, localName: property.value.name });
+          }
+        } else unresolvedComputedMember = true;
+      }
+    }
+    const visit = (node, parent, ancestors, depth = 0) => {
+      if (!node || typeof node.type !== "string") return;
+      if (++count > MAX_NODES || depth > 128) throw new Error("source-origin-budget");
+      const enclosing = [...ancestors, parent].filter(Boolean);
+      const topLevel = enclosing.every(item => ["File", "Program", "ExportNamedDeclaration",
+        "ExportDefaultDeclaration", "VariableDeclaration"].includes(item.type));
+      if (node.type === "FunctionDeclaration" && node.id) add(node.id.name, "function", node, topLevel);
+      if (node.type === "TSDeclareFunction" && node.id) add(node.id.name, "declaration-only", node, topLevel);
+      if (node.type === "ClassDeclaration" && node.id) add(node.id.name, "class", node, topLevel);
+      if (node.type === "VariableDeclarator") {
+        for (const name of bindingNames(node.id)) {
+          add(name, node.id.type === "Identifier" && callable(node.init) ? "function" : "binding", node.init ?? node, topLevel);
+        }
+      }
+      if (node.type === "FunctionExpression" && node.id
+        && !(parent?.type === "VariableDeclarator" && parent.id.name === node.id.name)) add(node.id.name, "nested-function", node);
+      if (["ObjectMethod", "ClassMethod", "ClassPrivateMethod", "ObjectProperty", "ClassProperty", "ClassPrivateProperty"].includes(node.type)) {
+        const name = node.computed && node.key.type !== "StringLiteral" && node.key.type !== "NumericLiteral" ? null : nameOf(node.key);
+        if (!exportObjects.has(parent)) {
+          const reference = node.value?.type === "Identifier" ? node.value.name : null;
+          const rootObject = enclosing.every(item => ["File", "Program", "ExportNamedDeclaration", "VariableDeclaration", "VariableDeclarator", "ObjectExpression"].includes(item.type));
+          add(name, reference ? "member-reference" : node.type.endsWith("Method") || callable(node.value) ? "method" : "property", node, rootObject, reference);
+        }
+      }
+      if (node.type === "AssignmentExpression") {
+        if (bindingNames(node.left).some(name => ["module", "exports"].includes(name))) commonJsRebound = true;
+        const cjs = commonJsExport(node.left);
+        const rootAssignment = enclosing.every(item => ["File", "Program", "ExpressionStatement"].includes(item.type));
+        if (cjs !== null && !rootAssignment) unresolvedComputedMember = true;
+        if (cjs === null && node.left.type === "MemberExpression") {
+          const name = node.left.computed && node.left.property.type !== "StringLiteral" ? null : nameOf(node.left.property);
+          if (name !== null || localStoreChecks++ >= 32 || !localRecordStore(node, enclosing, ast)) add(name, "member-assignment", node);
+        }
+      }
+      if (node.type === "ExportAllDeclaration") unresolvedComputedMember = true;
+      for (const [key, value] of Object.entries(node)) {
+        if (["loc", "start", "end", "extra", "comments", "tokens", "errors"].includes(key)) continue;
+        if (Array.isArray(value)) for (const item of value) visit(item, node, enclosing, depth + 1);
+        else if (value && typeof value === "object") visit(value, node, enclosing, depth + 1);
+      }
+    };
+    visit(ast, null, []);
+    if (commonJsSeen && (commonJsRebound || origins.some(origin => origin.topLevel && ["module", "exports"].includes(origin.name)))) unresolvedComputedMember = true;
+    result = Object.freeze({ origins: Object.freeze(origins), exportEdges: Object.freeze(exportEdges.map(Object.freeze)), unresolvedComputedMember });
+  } catch { /* Unsupported or malformed syntax has no source-origin authority. */ }
+  if (cache.size >= MAX_CACHE_ENTRIES) cache.delete(cache.keys().next().value);
+  cache.set(key, result);
+  return result;
+}
+
+/** Route names to existing proof engines by unique source origin, never by a
+ * corpus-wide export-name match alone. This does not prove runtime behavior. */
+export function routeNamedSourceTargets({ namedTargets, provenanceTargets, sourceEntries, exports, taskText = "" }) {
+  if (namedTargets.length === 0 || sourceEntries.length === 0) return {
+    strictTargets: namedTargets.filter(name => provenanceTargets.has(name)),
+    structuralTargets: namedTargets.filter(name => !provenanceTargets.has(name)), unresolvedTargets: [], routes: []
+  };
+  const entries = sourceEntries.map(entry => ({ path: modulePath(entry.path), inventory: sourceOrigins(entry) }));
+  const incomplete = entries.some(entry => !entry.inventory || entry.inventory.unresolvedComputedMember);
+  const origins = entries.flatMap(entry => (entry.inventory?.origins ?? []).map(origin => ({ ...origin, path: entry.path })));
+  const explicitPaths = [...new Set((String(taskText).match(/[^\s`"'<>()[\]{}:,;!?=]+\.[cm]?[jt]sx?\b/g) ?? []).map(modulePath))];
+  const routes = namedTargets.map(target => {
+    const exported = exports.filter(item => item.contractName === target);
+    const candidates = origins.filter(origin => origin.name.toLowerCase() === target || exported.some(binding =>
+      modulePath(binding.sourcePath) === origin.path && binding.sourceName === origin.name.toLowerCase()));
+    const distinct = candidates.filter(origin => origin.kind !== "member-reference" || !origin.topLevel
+      || !candidates.some(other => other.kind === "function" && other.topLevel && other.path === origin.path
+        && other.name === origin.referenceName && origin.name === other.name));
+    const unresolved = reason => ({ target, kind: "unresolved", reason });
+    if (incomplete) return unresolved("source-origin-inventory-incomplete");
+    if (distinct.length !== 1 || exported.length > 1) return unresolved("source-origin-ambiguous-or-missing");
+    const origin = distinct[0];
+    if (explicitPaths.length > 1) return unresolved("criterion-module-ambiguous");
+    if (explicitPaths.length === 1 && explicitPaths[0] !== origin.path) return unresolved("criterion-module-mismatch");
+    if (exported.length === 1) {
+      const binding = exported[0];
+      if (origin.kind !== "function" || !origin.topLevel || modulePath(binding.sourcePath) !== origin.path
+        || binding.sourceName !== origin.name.toLowerCase()) return unresolved("export-does-not-own-source-origin");
+      const owned = entries.find(entry => entry.path === origin.path).inventory.exportEdges.some(edge =>
+        edge.localName === origin.name && edge.exportName?.toLowerCase() === binding.exportName);
+      if (!owned) return unresolved("export-does-not-own-source-origin");
+      return { target, kind: "export", origin };
+    }
+    if (origin.kind === "method" && !provenanceTargets.has(target)) return { target, kind: "structural", origin };
+    return unresolved("source-origin-not-an-exported-callable");
+  });
+  return {
+    strictTargets: routes.filter(route => route.kind === "export").map(route => route.target),
+    structuralTargets: routes.filter(route => route.kind === "structural").map(route => route.target),
+    unresolvedTargets: routes.filter(route => route.kind === "unresolved").map(route => route.target), routes
+  };
+}

package/packages/piagent-core/extensions/acceptance-state-machine-evidence.js

@@ -1,3 +1,4 @@
+import { boundedTopLevelStatements } from "./acceptance-callable-scanner.js";
 import { rejectionStatementErrorClass } from "./acceptance-error-classes.js";
 
 function escapeRegex(value) {
@@ -163,6 +164,7 @@ function preLoopStatementsProven(text, offset, carrier) {
   let prefix = text.slice(0, offset), escaped = escapeRegex(carrier);
   prefix = prefix.replace(new RegExp(`\\bconst\\s+${escaped}\\s*=\\s*string\\s*\\(\\s*[a-z_$][a-z0-9_$]*\\s*\\)\\s*(?:;|(?=\\r?\\n))`, "gi"), " ");
   prefix = prefix.replace(/\b(?:let|var)\s+[a-z_$][a-z0-9_$]*(?:\s*:\s*(?:boolean|string))?\s*=\s*(?:false|__pi_empty_string_literal__)\s*(?:;|(?=\r?\n))/gi, " ");
+  prefix = prefix.replace(/\b(?:const|let)\s+[a-z_$][a-z0-9_$]*\s*=\s*\[\s*\]\s*(?:;|(?=\r?\n))/gi, " ");
   return /^[\s;]*$/.test(prefix);
 }
 
@@ -326,11 +328,12 @@ function counterFlowProven(text, loop, ranges, state, truthyOffset) {
   for (const relativeOffset of directBindingMutations(bodyText, loop.counter)) {
     const offset = loop.start + relativeOffset;
     if (!new RegExp(`^${escapeRegex(loop.counter)}\\s*(?:\\+\\+|\\+=\\s*1)\\s*(?:;|(?=\\r?\\n|}))`, "i").test(text.slice(offset))) return false;
-    if (offset >= truthyOffset) continue;
+
     const ancestors = ranges.filter((range) => offset >= range.start && offset < range.end);
     const stateGuard = ancestors.some((range) => new RegExp(`^${escapeRegex(state)}(?:\\s*={2,3}\\s*true)?$`, "i").test(stripOuterParentheses(range.condition)));
     const nextQuote = ancestors.some((range) => new RegExp(`\\b${escapeRegex(loop.carrier)}\\b\\s*\\[\\s*${escapeRegex(loop.counter)}\\s*\\+\\s*1\\s*\\]\\s*={3}\\s*__pi_double_quote_string_literal__`, "i").test(range.condition));
-    if ((!stateGuard || !nextQuote) && !initiallyFalseAuxiliaryGuard(text, loop, ranges, ancestors, state)) return false;
+    const nonQuoteSkip = ancestors.some(range => nonQuoteInputCondition(range.condition, loop, true));
+    if ((!stateGuard || !nextQuote) && !nonQuoteSkip && !initiallyFalseAuxiliaryGuard(text, loop, ranges, ancestors, state)) return false;
   }
   return true;
 }
@@ -341,7 +344,9 @@ function priorSiblingControlProven(text, loop, ranges, state, truthyOffset) {
     && braceDepthAt(loopText, item.conditionStart - loop.start) === 0)) {
     if (truthyOffset >= range.start && truthyOffset < range.end) continue;
     if (text[range.start] === "{" && statePattern.test(stripOuterParentheses(range.condition))
-      && !/^\s*else\b/i.test(text.slice(range.end))) continue;
+      && (!/^\s*else\b/i.test(text.slice(range.end))
+        || ranges.some(next => next.conditionStart > range.end && truthyOffset >= next.start && truthyOffset < next.end
+          && /^\s*else\s*$/i.test(text.slice(range.end, next.conditionStart)) && quoteInputGuard(next.condition, loop)))) continue;
     return false;
   }
   return true;
@@ -362,12 +367,33 @@ function statementFragmentProven(raw, loop) {
   if (loop.counter && new RegExp(`^(?:${escapeRegex(loop.counter)}\\s*(?:\\+\\+|\\+=\\s*1)|\\+\\+\\s*${escapeRegex(loop.counter)})$`, "i").test(value)) return true;
   if (loop.booleanBindings.some((name) => new RegExp(`^${escapeRegex(name)}\\s*=\\s*(?:true|false)$`, "i").test(value))) return true;
   if (inputs && loop.emptyAccumulators.some((name) => new RegExp(`^${escapeRegex(name)}\\s*\\+=\\s*(?:${inputs})$`, "i").test(value))) return true;
+  if (loop.emptyAccumulators.some(name => new RegExp(`^${escapeRegex(name)}\\s*=\\s*__pi_empty_string_literal__$`, "i").test(value)
+    || new RegExp(`^${escapeRegex(name)}\\s*\\+=\\s*__pi_double_quote_string_literal__$`, "i").test(value))) return true;
+  if (loop.resettableArrays.some(name => new RegExp(`^${escapeRegex(name)}\\s*=\\s*\\[\\s*\\]$`, "i").test(value))) return true;
+  if (ownedArrayPushPattern(loop, true).test(value)) return true;
   return Boolean(loop.counter && loop.items.some((name) => new RegExp(`^const\\s+${escapeRegex(name)}\\s*=\\s*${carrierItem}$`, "i").test(value)));
 }
 
+function ownedArrayPushPattern(loop, anchored = false) {
+  const arrays = loop.arrayBindings.map(escapeRegex).join("|");
+  const values = [...loop.arrayBindings, ...loop.emptyAccumulators].map(escapeRegex).join("|");
+  return arrays && values ? new RegExp(`${anchored ? "^" : "\\b"}(?:${arrays})\\.push\\s*\\(\\s*(?:${values})\\s*\\)${anchored ? "$" : ""}`, "gi") : /(?!) /;
+}
+
+function nonQuoteInputCondition(raw, loop, requireLookahead = false) {
+  const value = stripOuterParentheses(raw), parts = value.split(requireLookahead ? /\s*&&\s*/ : /\s*(?:&&|\|\|)\s*/);
+  const current = [...loop.items.map(escapeRegex), ...(loop.counter ? [`${escapeRegex(loop.carrier)}\\s*\\[\\s*${escapeRegex(loop.counter)}\\s*\\]`] : [])].join("|");
+  const next = loop.counter ? `${escapeRegex(loop.carrier)}\\s*\\[\\s*${escapeRegex(loop.counter)}\\s*\\+\\s*1\\s*\\]` : "(?!)";
+  const literal = "__pi_(?:(?:whitespace|empty)_)?string_literal__";
+  const isCurrent = part => new RegExp(`^(?:${current})\\s*===\\s*${literal}$`, "i").test(stripOuterParentheses(part));
+  const isNext = part => new RegExp(`^${next}\\s*===\\s*${literal}$`, "i").test(stripOuterParentheses(part));
+  return parts.length > 0 && parts.length <= 4 && parts.every(part => isCurrent(part) || isNext(part))
+    && parts.some(isCurrent) && (!requireLookahead || parts.length === 2 && parts.some(isNext));
+}
+
 function loopStatementsProven(loopBody, loop) {
   if (/\b(?:break|delete|new|return|throw|typeof|void)\b/i.test(loopBody)) return false;
-  if (/\b(?!if\b)[a-z_$][a-z0-9_$]*\s*(?:\?\.\s*)?\(|\b[a-z_$][a-z0-9_$]*\s*__pi_template_literal__|[\])]\s*(?:\?\.\s*)?\(/i.test(loopBody)) return false;
+  if (/\b(?!if\b)[a-z_$][a-z0-9_$]*\s*(?:\?\.\s*)?\(|\b[a-z_$][a-z0-9_$]*\s*__pi_template_literal__|[\])]\s*(?:\?\.\s*)?\(/i.test(loopBody.replace(ownedArrayPushPattern(loop), ""))) return false;
   for (const match of loopBody.matchAll(/;/g)) {
     const start = Math.max(loopBody.lastIndexOf(";", match.index - 1), loopBody.lastIndexOf("{", match.index - 1), loopBody.lastIndexOf("}", match.index - 1)) + 1;
     if (!statementFragmentProven(loopBody.slice(start, match.index), loop)) return false;
@@ -395,12 +421,34 @@ function loopConditionsProven(ranges, loop, state) {
   return ranges.every((range) => {
     const condition = stripOuterParentheses(range.condition);
     if (!sideEffectFreeCondition(condition)) return false;
-    if (statePattern.test(condition) || quoteInputGuard(condition, loop)) return true;
+    if (statePattern.test(condition) || quoteInputGuard(condition, loop) || nonQuoteInputCondition(condition, loop)) return true;
+    const quoteParts = topLevelParts(condition.replaceAll("&&", "\u0000"), "\u0000");
+    if (quoteParts.length === 2 && quoteInputGuard(quoteParts[0], loop) && next
+      && new RegExp(`^${next}\\s*===\\s*${quote}$`, "i").test(stripOuterParentheses(quoteParts[1]))) return true;
     if (next && new RegExp(`^(?:${next}\\s*={3}\\s*${quote}|${quote}\\s*={3}\\s*${next})$`, "i").test(condition)) return true;
     return loop.booleanBindings.some((name) => name !== state && new RegExp(`^(?:!\\s*${escapeRegex(name)}|${escapeRegex(name)}(?:\\s*={2,3}\\s*(?:true|false))?)$`, "i").test(condition));
   });
 }
 
+function escapedQuoteBranchProven(text, loop, ranges, state, transitions) {
+  const truthy = transitions.find(item => item?.write.value === "true"), falsy = transitions.find(item => item?.write.value === "false");
+  if (!truthy || !falsy) return false;
+  const next = loop.counter && new RegExp(`\\b${escapeRegex(loop.carrier)}\\s*\\[\\s*${escapeRegex(loop.counter)}\\s*\\+\\s*1\\s*\\]\\s*===\\s*__pi_double_quote_string_literal__`, "i");
+  const escapeRanges = next ? ranges.filter(range => next.test(range.condition)) : [];
+  const fieldOpening = loop.emptyAccumulators.some(name => new RegExp(`\\b${escapeRegex(name)}\\b`, "i").test(truthy.immediate.condition));
+  if (!escapeRanges.length) return !fieldOpening;
+  if (escapeRanges.length !== 1) return false;
+  const escape = escapeRanges[0], ancestors = ranges.filter(range => escape.conditionStart >= range.start && escape.end <= range.end);
+  if (!ancestors.some(range => new RegExp(`^${escapeRegex(state)}(?:\\s*={2,3}\\s*true)?$`, "i").test(stripOuterParentheses(range.condition)))
+    || ![...ancestors, escape].some(range => quoteInputGuard(range.condition.split("&&")[0], loop))) return false;
+  const raw = text.slice(escape.start, escape.end).trim().replace(/^\{\s*|\s*\}$/g, "");
+  const fields = loop.emptyAccumulators.map(escapeRegex).join("|");
+  const append = fields ? `(?:(?:${fields})\\s*\\+=\\s*__pi_double_quote_string_literal__\\s*;\\s*)?` : "";
+  if (!new RegExp(`^${append}${escapeRegex(loop.counter)}\\s*(?:\\+\\+|\\+=\\s*1)\\s*;?\\s*$`, "i").test(raw)) return false;
+  return /^\s*else\s*$/i.test(text.slice(escape.end, falsy.immediate.conditionStart))
+    || /^\s*else\s*(?:\{\s*)?$/i.test(text.slice(escape.end, falsy.offset));
+}
+
 function transitionShapeProven(text, transitions) {
   const truthy = transitions.find((item) => item.write.value === "true");
   const falsy = transitions.find((item) => item.write.value === "false");
@@ -442,8 +490,9 @@ function truthyTransitionTailProven(text, loop, transition) {
 // Prove only one narrow terminal state-machine rejection shape. Callers must
 // still establish stable exports/imports, live assertions, error constructors,
 // the exact current verifier, and a current-tree changed source/test corpus.
-export function statefulTerminalRejectionEvidence(body, parameters, requestedErrors, contractText, targetName, sourceCode) {
-  if (!affirmativeQuotedTerminalContract(contractText, targetName)) return false;
+export function statefulTerminalRejectionEvidence(body, parameters, requestedErrors, contractText, targetName, sourceCode, uniqueExportBinding = false) {
+  const implicitContract = uniqueExportBinding && /^\s*(?:(?:must|shall|should)\s+)?(?:throw|raise)\s+`?SyntaxError`?\s+for\s+(?:an?\s+)?unterminated\s+quoted?\s+field[.!]?\s*$/i.test(String(contractText ?? ""));
+  if (!implicitContract && !affirmativeQuotedTerminalContract(contractText, targetName)) return false;
   const loops = [];
   for (const match of body.matchAll(/\bfor\s*\(/gi)) {
     if (braceDepthAt(body, match.index) !== 0 || priorUnconditionalExit(body, match.index) || topLevelControlBefore(body, match.index)) continue;
@@ -471,7 +520,13 @@ export function statefulTerminalRejectionEvidence(body, parameters, requestedErr
       .filter((item) => braceDepthAt(body, item.index) === 0).map((item) => item[1].toLowerCase());
     const booleanBindings = [...body.slice(0, match.index).matchAll(/\b(?:let|var)\s+([a-z_$][a-z0-9_$]*)(?:\s*:\s*boolean)?\s*=\s*false\s*(?:;|(?=\r?\n))/gi)]
       .filter((item) => braceDepthAt(body, item.index) === 0).map((item) => item[1].toLowerCase());
-    const loop = { ...evidence, start: bodyStart + 1, end: bodyEnd - 1, items: [...new Set(items)], inputNames: [...new Set(inputNames)], emptyAccumulators, booleanBindings };
+    const arrayBindings = [...body.slice(0, match.index).matchAll(/\b(?:const|let)\s+([a-z_$][a-z0-9_$]*)\s*=\s*\[\s*\]\s*(?:;|(?=\r?\n))/gi)]
+      .filter(item => braceDepthAt(body, item.index) === 0).map(item => item[1].toLowerCase());
+    // Local array calls rely on ordinary inherited methods; abstain on module initialization effects.
+    const module = arrayBindings.length > 0 ? boundedTopLevelStatements(sourceCode) : null;
+    if (module && (!module.complete || module.statements.some(item => item.kind !== "function-declaration"))) continue;
+    const resettableArrays = arrayBindings.filter(name => new RegExp(`\\blet\\s+${escapeRegex(name)}\\s*=`, "i").test(body.slice(0, match.index)));
+    const loop = { ...evidence, start: bodyStart + 1, end: bodyEnd - 1, items: [...new Set(items)], inputNames: [...new Set(inputNames)], emptyAccumulators, booleanBindings, arrayBindings, resettableArrays };
     if (loopStatementsProven(loopBody, loop)) loops.push(loop);
   }
   if (loops.length === 0) return false;
@@ -494,6 +549,7 @@ export function statefulTerminalRejectionEvidence(body, parameters, requestedErr
     const truthyOffset = writes.find((item) => item.write.value === "true").offset;
     const truthyTransition = transitions.find((item) => item?.write.value === "true");
     if (!loopConditionsProven(ranges, loop, state) || transitions.some((item) => !item) || !transitionShapeProven(body, transitions)
+      || !escapedQuoteBranchProven(body, loop, ranges, state, transitions)
       || !counterFlowProven(body, loop, ranges, state, truthyOffset)
       || !priorSiblingControlProven(body, loop, ranges, state, truthyOffset)
       || !truthyTransitionTailProven(body, loop, truthyTransition)) continue;