@piagent/platform 1.6.1 → 1.7.1

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

@@ -1,3 +1,5 @@
+import { explicitUndefinedTemporalContract } from "./acceptance-temporal-contract.js";
+
 function normalizedText(value) {
   return String(value ?? "")
     .normalize("NFD")
@@ -9,6 +11,201 @@ function uniqueStrings(values) {
   return [...new Set(values.filter(Boolean))];
 }
 
+export function isoTimestampProofGuidance(raw) {
+  if (!/\biso\b[^.\n]{0,80}\btimestamp\b|\btimestamp\b[^.\n]{0,80}\biso\b/.test(normalizedText(raw))) return [];
+  const expiryPredicate = /\b(?:isexpired|expir(?:ed|es|y|ation))\b/.test(normalizedText(raw));
+  return [
+    "For ISO timestamps, prove valid shapes with and without fractional seconds and contract-supported omitted seconds; optional capturing groups shift later match indexes. Prove leap-day validity for years 0000 through 0099; Date.UTC(year, ...) remaps years 0 through 99.",
+    expiryPredicate
+      ? "Test numeric UTC offsets of both signs, including a negative sub-hour offset: independently derive t, then assert false/true/true immediately before, at, and after t. After-only checks miss lost signs. Preserve millisecond truncation for long fractional strings without rounding into the next second."
+      : "Test numeric UTC offsets of both signs, including a negative sub-hour offset, immediately before, at, and after the same instant. Preserve millisecond truncation for long fractional strings: converting the whole fraction to a floating-point number can round into the next second."
+  ];
+}
+
+export function temporalProofReasonGuidance(reasons = []) {
+  if (reasons.some((reason) => ["typeerror-rejection-unproven", "rejection-message-effect-unproven"].includes(reason))) {
+    return ["Check an invalid Date whose toString or Symbol.toPrimitive throws RangeError, in each argument position. Coercing invalid input while formatting a TypeError can throw the wrong class; repair only after reproducing the counterexample."];
+  }
+  if (reasons.some((reason) => ["unsupported-temporal-syntax", "temporal-helper-composition-unproven", "iso-offset-arithmetic-unproven", "date-timeclip-unproven"].includes(reason))) {
+    return ["For an expiry predicate, independently trace 1970-01-01T00:00:00-00:30 to UTC t=1800000 ms. At t-1/t/t+1 expect false/true/true. After-only assertions cannot detect premature expiry. This is a diagnostic example, not proof that the source is wrong or permission to edit it."];
+  }
+  return [];
+}
+
+export function rejectionClassProofGuidance(raw, errorName) {
+  const coercion = /\bdates?\b/.test(normalizedText(raw))
+    ? " Include invalid Date objects with throwing toString/Symbol.toPrimitive; formatting the error must not change its class." : "";
+  return `Assert ${errorName} for every rejected partition named by the request; a different error class is not equivalent.${coercion}`;
+}
+
+export function identifierFieldNames(raw) {
+  const source = String(raw ?? "");
+  const names = [];
+  const identifierName = (value) => (
+    /^id$/i.test(value)
+    || /^[A-Za-z_$][A-Za-z0-9_$]*(?:Id|ID)$/.test(value)
+    || /^[A-Za-z_$][A-Za-z0-9_$]*[_-]id$/i.test(value)
+  ) ? value.toLowerCase() : undefined;
+  for (const match of source.matchAll(/`([^`\r\n]{1,64})`/g)) {
+    const preceding = source.slice(Math.max(0, (match.index ?? 0) - 80), match.index ?? 0);
+    const following = source.slice((match.index ?? 0) + match[0].length);
+    if (/\b(?:callable|function|method)(?:\s+(?:called|named))?\s*$/i.test(preceding)
+      || /^\s*(?:callable|function|method)\b/i.test(following)
+      || /^\s*(?:accepts?|applies?|builds?|calls?|creates?|deletes?|finds?|gets?|loads?|parses?|reads?|rejects?|removes?|replays?|resolves?|returns?|runs?|saves?|sets?|throws?|updates?|validates?|writes?)\b/i.test(following)) continue;
+    const name = identifierName(match[1].trim());
+    if (name) names.push(name);
+  }
+  for (const match of source.matchAll(/\b(?:field|key|property)\s+(?:named|called)\s+([A-Za-z_$][A-Za-z0-9_$]*)\b/gi)) {
+    const name = identifierName(match[1]);
+    if (name) names.push(name);
+  }
+  for (const match of source.matchAll(/\b(?:has|contains|includes|requires|receives|with)\s+(?:an?\s+|the\s+|unique\s+)*([A-Za-z_$][A-Za-z0-9_$]*(?:Id|ID))\b/g)) {
+    names.push(match[1].toLowerCase());
+  }
+  for (const match of source.matchAll(/(?:\.|\b)([A-Za-z_$][A-Za-z0-9_$]*(?:Id|ID))\s*:/g)) names.push(match[1].toLowerCase());
+  return uniqueStrings(names);
+}
+
+function namesIdentifierField(raw) {
+  return identifierFieldNames(raw).length > 0
+    || /\bidentifier\s+(?:field|input|key|property|value)s?\b/i.test(String(raw ?? ""));
+}
+
+function contractClauses(raw) {
+  const source = String(raw ?? "")
+    .replace(/\r\n?/g, "\n")
+    .replace(/\n(?=[ \t]*(?:[-*+]|\d+[.)])[ \t]+)/g, "\u0000")
+    .replace(/\n[ \t]*\n+/g, "\u0000")
+    .replace(/\n+/g, " ")
+    .replace(/\u0000/g, "\n");
+  return source.split(/(?<=[.!?;])\s+|\n+/)
+    .map((clause) => clause.trim().replace(/^(?:[-*+]|\d+[.)])\s+/, ""))
+    .filter(Boolean);
+}
+
+function isExplicitRejectionClause(clause) {
+  if (/\bwithout\s+throwing\b|\b(?:do|must|shall|should)\s+not\s+throw\b|\bnever\s+throw\b/i.test(clause)) return false;
+  return /\b(?:invalid|malformed|reject(?:s|ed|ing|ion)?)\b/i.test(clause)
+    || /\b(?:must|should|shall)\s+throw\s+(?:an?\s+)?TypeError\b/i.test(clause)
+    || /\bthrow\s+(?:an?\s+)?TypeError\s+(?:for|on|when)\b/i.test(clause);
+}
+
+export function hasExplicitInputRejection(raw) {
+  return contractClauses(raw).some(isExplicitRejectionClause);
+}
+
+function malformedShapeSubjects(clause) {
+  const subjects = [];
+  for (const match of normalizedText(clause).matchAll(/\b([a-z][a-z0-9_-]{1,40})\s+(?:objects?|records?|shapes?)\b/g)) {
+    if (!["data", "input", "value", "values"].includes(match[1])) subjects.push(match[1]);
+  }
+  return uniqueStrings(subjects);
+}
+
+function taggedFieldList(raw) {
+  const source = String(raw ?? "").trim().replace(/^(?:the\s+)?(?:required\s+)?fields?\s+/i, "");
+  const fields = [...source.matchAll(/`([A-Za-z_$][A-Za-z0-9_$]*)`/g)].map((match) => match[1]);
+  if (fields.length === 0 || fields.length > 6) return [];
+  const shape = source.replace(/`[A-Za-z_$][A-Za-z0-9_$]*`/g, "@").replace(/\s+/g, " ").trim();
+  return /^@(?:\s*,\s*@)*(?:\s*,?\s+and\s+@)?$/i.test(shape) ? uniqueStrings(fields) : [];
+}
+
+function unsupportedTaggedRequirement() {
+  return [{ variant: "__unsupported_tagged_event_contract__", field: null, partitions: [] }];
+}
+
+function explicitTaggedEventRequirements(clauses) {
+  const taggedClauses = clauses.filter((clause) => /\btagged[- ]event\s+variant\b/i.test(clause));
+  if (taggedClauses.length === 0) return [];
+  const declarations = [], optionals = [];
+  let foreignConstraint = false, unsupportedDeclaration = false;
+  for (const clause of taggedClauses) {
+    const declaration = clause.match(/^(?:the\s+)?tagged[- ]event\s+variant\s+`([^`\r\n]{1,64})`\s+requires\s+(.+?)\s+to\s+be\s+(?:a\s+)?non-empty\s+strings?\.?$/i);
+    if (declaration) {
+      const fields = taggedFieldList(declaration[2]);
+      if (fields.length === 0) unsupportedDeclaration = true;
+      else declarations.push({ variant: declaration[1], fields });
+      continue;
+    }
+    const optional = clause.match(/^for\s+(?:the\s+)?tagged[- ]event\s+variant\s+`([^`\r\n]{1,64})`,?\s+(?:its\s+|the\s+)?optional\s+(?:field\s+|override\s+)?`([A-Za-z_$][A-Za-z0-9_$]*)`(?:\s+(?:field|override))?,?\s+when\s+supplied,?\s+must\s+be\s+(?:a\s+)?non-empty\s+string\.?$/i);
+    if (optional) optionals.push({ variant: optional[1], field: optional[2] });
+    else if (/^(?:the\s+)?tagged[- ]event\s+variant\s+`[^`\r\n]{1,64}`\s+requires\b/i.test(clause)
+      && !/\bnon-empty\s+strings?\b/i.test(clause)) foreignConstraint = true;
+    else unsupportedDeclaration = true;
+  }
+  const unparsedEventConstraint = clauses.some((clause) => !taggedClauses.includes(clause)
+    && !isExplicitRejectionClause(clause)
+    && declarations.some((item) => clause.includes(`\`${item.variant}\``))
+    && /\b(?:event|field|override|tagged|variant)\b/i.test(clause)
+    && /\b(?:field|override|required|requires?|must)\b/i.test(clause));
+  const productionSequencingClause = (clause) => /^validate\s+the\s+required\s+fields?\s+and\s+any\s+supplied\s+override\s+before\s+applying\s+duplicate\s+handling\.?$/i.test(clause)
+    || /^for\s+a\s+non-duplicate\s+message\s+with\s+no\s+own\s+`[^`]+`\s+override,\s+`[^`]+`\s+must\s+be\s+a\s+non-empty\s+string\s+or\s+the\s+reducer\s+throws\s+`typeerror`\.?$/i.test(clause);
+  const genericFieldConstraint = clauses.some((clause) => !taggedClauses.includes(clause)
+    && !isExplicitRejectionClause(clause)
+    && !productionSequencingClause(clause)
+    && /\b(?:events?|tagged|variants?|fields?|overrides?|propert(?:y|ies))\b/i.test(clause)
+    && /\b(?:must|shall|should|required|requires?|validation|validates?|validated|validating)\b/i.test(clause));
+  const rejectionWithExtraConstraint = clauses.some((clause) => {
+    if (!isExplicitRejectionClause(clause)) return false;
+    const rejection = clause.search(/\b(?:malformed|reject(?:s|ed|ing|ion)?|throw(?:s|ing)?\s+(?:an?\s+)?typeerror)\b/i);
+    const tail = rejection === -1 ? "" : clause.slice(rejection);
+    return /\b(?:and|but|plus)\b[\s\S]*\b(?:events?|tagged|variants?|fields?|overrides?|propert(?:y|ies))\b/i.test(tail)
+      && /\b(?:requires?|required|validation|validates?|validated|validating|must\s+(?!throw\b))\b/i.test(tail);
+  });
+  if (unparsedEventConstraint || genericFieldConstraint || rejectionWithExtraConstraint) unsupportedDeclaration = true;
+  const variants = uniqueStrings(declarations.map((item) => item.variant));
+  if (foreignConstraint) return declarations.length > 0 ? unsupportedTaggedRequirement() : [];
+  if (unsupportedDeclaration) return unsupportedTaggedRequirement();
+  if (variants.length < 2) return [];
+  if (!clauses.some((clause) => isExplicitRejectionClause(clause)
+    && /\b(?:tagged[- ]event|named\s+event\s+variants?)\b/i.test(clause))) return [];
+  if (optionals.some((item) => !variants.includes(item.variant))) return unsupportedTaggedRequirement();
+  const requirements = declarations.flatMap((item) => item.fields.map((field) => ({
+    variant: item.variant, field, optional: false,
+    partitions: ["missing", "non-string", "empty-string"]
+  })));
+  requirements.push(...optionals.map((item) => ({
+    ...item, optional: true, partitions: ["non-string", "empty-string"]
+  })));
+  const keys = requirements.map((item) => `${item.variant}\u0000${item.field}`);
+  const foldedKeys = requirements.map((item) => `${item.variant}\u0000${item.field.toLowerCase()}`);
+  return requirements.length <= 16 && keys.length === new Set(keys).size && foldedKeys.length === new Set(foldedKeys).size
+    ? requirements : unsupportedTaggedRequirement();
+}
+
+/**
+ * Return a closed, bounded proof matrix only for explicit multi-variant malformed
+ * tagged-event contracts. Ordinary invalid-input prose deliberately returns no
+ * matrix and keeps the established flat proof path unchanged.
+ */
+export function malformedTaggedEventRequirements(raw) {
+  const clauses = contractClauses(raw);
+  return hasExplicitInputRejection(raw) ? explicitTaggedEventRequirements(clauses) : [];
+}
+
+export function malformedIdentifierContractText(raw) {
+  const clauses = contractClauses(raw);
+  const declarations = clauses.filter(namesIdentifierField);
+  if (declarations.length === 0) return "";
+  const matched = [];
+  for (const clause of clauses.filter(isExplicitRejectionClause)) {
+    if (namesIdentifierField(clause)) {
+      matched.push(clause);
+      continue;
+    }
+    const subjects = malformedShapeSubjects(clause);
+    const related = declarations.filter((declaration) => subjects.some((subject) => (
+      new RegExp(`\\b${subject}\\b`, "i").test(declaration)
+    )));
+    if (related.length > 0) matched.push(...related, clause);
+  }
+  return uniqueStrings(matched).join("\n");
+}
+
+export function malformedIdentifierContract(raw) {
+  return Boolean(malformedIdentifierContractText(raw));
+}
+
 /**
  * Derive bounded, auditable proof obligations for stateful boundary contracts.
  *
@@ -20,6 +217,23 @@ export function acceptanceBoundaryProofGuidance(raw) {
   const guidance = [];
   const replayContract = /\b(?:replay(?:ed|s)?|idempot(?:ent|ency))\b/.test(value);
 
+  if (
+    /\biso(?:[-\s]+8601)?(?:[-\s]+timestamp)?(?:[-\s]+strings?)?\b/.test(value)
+    && /\b(?:invalid|malformed)\s+(?:date|dates|timestamp|timestamps)\b|\b(?:date|dates|timestamp|timestamps)\b[^.\n]{0,80}\b(?:throw|reject)/.test(value)
+  ) {
+    guidance.push("For an ISO date-string contract, separately reject a parseable non-ISO string, a syntactically ISO but impossible calendar date, and an invalid Date object; a finite Date.parse result alone does not prove ISO validity.");
+  }
+
+  if (explicitUndefinedTemporalContract(value)) {
+    guidance.push("Distinguish an omitted time argument from explicitly supplied undefined, null, false, and zero; a default parameter conflates omission with explicit undefined and cannot prove this contract.");
+  }
+  if (malformedIdentifierContract(raw)) {
+    guidance.push("For malformed identifier input, exercise missing, wrong-type, and empty-string values separately; add whitespace-only when the contract requires non-whitespace.");
+  }
+  if (malformedTaggedEventRequirements(raw).length > 0) {
+    guidance.push("For every malformed tagged-event variant, use fresh literal non-event inputs, one valid control per variant, and vary one constrained field at a time; evidence for one variant or field does not cover another.");
+  }
+
   if (
     /\b(?:safe[-\s]+integer|number\.max_safe_integer|number\.issafeinteger)\b/.test(value)
     && /\b(?:advance|bump|cursor|decrement|increment|next|revision|successor)\b|(?:\+|-)\s*1\b/.test(value)

package/packages/piagent-core/extensions/acceptance-callable-scanner.js

@@ -0,0 +1,244 @@
+import { evidenceTopLevelArguments } from "./acceptance-executable-evidence.js";
+
+const MAX_SCAN_LENGTH = 64_000;
+const MAX_CALLABLES = 128;
+const MAX_STATEMENTS = 128;
+
+function balancedEnd(text, openIndex, opening = "(", closing = ")", ceiling = 8_000) {
+  if (text[openIndex] !== opening) return -1;
+  let depth = 0;
+  for (let index = openIndex; index < Math.min(text.length, openIndex + ceiling); index += 1) {
+    if (text[index] === opening) depth += 1;
+    else if (text[index] === closing && --depth === 0) return index + 1;
+  }
+  return -1;
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim()))];
+}
+
+function formalParameterNames(parameters, preserveCase = false) {
+  const wrapped = `(${String(parameters ?? "")})`;
+  const names = [];
+  for (const raw of evidenceTopLevelArguments(wrapped, 0, wrapped.length)) {
+    const value = raw.trim().replace(/^(?:public|private|protected|readonly)\s+/, "").replace(/^\.\.\./, "");
+    const direct = value.match(/^([a-z_$][a-z0-9_$]*)\s*(?:[?:=]|$)/i);
+    if (direct) {
+      names.push(direct[1]);
+      continue;
+    }
+    const object = value.match(/^\{([^}]*)\}/)?.[1];
+    if (object) {
+      for (const item of object.split(",")) {
+        const binding = item.trim().match(/^(?:[a-z_$][a-z0-9_$]*\s*:\s*)?([a-z_$][a-z0-9_$]*)/i);
+        if (binding) names.push(binding[1]);
+      }
+      continue;
+    }
+    const array = value.match(/^\[([^\]]*)\]/)?.[1];
+    if (array) names.push(...(array.match(/[a-z_$][a-z0-9_$]*/gi) ?? []));
+  }
+  const result = uniqueStrings(names).slice(0, 16);
+  return preserveCase ? result : result.map((item) => item.toLowerCase());
+}
+
+function defaultedFormalParameterNames(parameters, preserveCase = false) {
+  const wrapped = `(${String(parameters ?? "")})`;
+  const names = [];
+  for (const raw of evidenceTopLevelArguments(wrapped, 0, wrapped.length)) {
+    const value = raw.trim().replace(/^(?:public|private|protected|readonly)\s+/, "").replace(/^\.\.\./, "");
+    const direct = value.match(/^([a-z_$][a-z0-9_$]*)\s*(?:\?\s*)?=/i);
+    if (direct) names.push(direct[1]);
+  }
+  const result = uniqueStrings(names).slice(0, 16);
+  return preserveCase ? result : result.map((item) => item.toLowerCase());
+}
+
+function braceDepthAt(text, offset) {
+  let depth = 0;
+  for (let index = 0; index < Math.min(text.length, Math.max(0, offset)); index += 1) {
+    if (text[index] === "{") depth += 1;
+    else if (text[index] === "}") depth -= 1;
+    if (depth < 0) return -1;
+  }
+  return depth;
+}
+
+function declarationStart(code, keywordStart) {
+  const prefixStart = Math.max(0, keywordStart - 48);
+  const prefix = code.slice(prefixStart, keywordStart);
+  const exported = prefix.match(/\bexport\s+(?:default\s+)?$/i);
+  return exported ? prefixStart + exported.index : keywordStart;
+}
+
+function withOptionalSemicolon(code, end) {
+  let cursor = end;
+  while (/\s/.test(code[cursor] ?? "")) cursor += 1;
+  return code[cursor] === ";" ? cursor + 1 : end;
+}
+
+function statementKind(source) {
+  const value = source.trim();
+  if (/^(?:export\s+(?:default\s+)?)?(?:async\s+)?function\b/i.test(value)) return "function-declaration";
+  if (/^(?:export\s+)?const\b/i.test(value)) return "immutable-binding";
+  if (/^(?:export\s+)?(?:let|var)\b/i.test(value)) return "mutable-binding";
+  return "statement";
+}
+
+function statementEnd(code, start, ceiling) {
+  let braces = 0, parentheses = 0, brackets = 0;
+  const prefix = code.slice(start, Math.min(ceiling, start + 80)).trimStart();
+  const closesWithBlock = /^(?:(?:export\s+(?:default\s+)?)?(?:async\s+)?function\b|class\b|if\b|for\b|while\b|switch\b|try\b|\{)/i.test(prefix);
+  for (let index = start; index < ceiling; index += 1) {
+    const character = code[index];
+    if (character === "(") parentheses += 1;
+    else if (character === ")") parentheses -= 1;
+    else if (character === "[") brackets += 1;
+    else if (character === "]") brackets -= 1;
+    else if (character === "{") braces += 1;
+    else if (character === "}") {
+      braces -= 1;
+      if (braces === 0 && parentheses === 0 && brackets === 0 && closesWithBlock) {
+        const rest = code.slice(index + 1, Math.min(ceiling, index + 32));
+        if (!/^\s*(?:else|catch|finally|while\b)/i.test(rest)) return index + 1;
+      }
+    } else if (character === ";" && braces === 0 && parentheses === 0 && brackets === 0) return index + 1;
+    if (braces < 0 || parentheses < 0 || brackets < 0) return index;
+  }
+  return ceiling;
+}
+
+/** Return a bounded, case-preserving inventory of complete module statements. */
+export function boundedTopLevelStatements(code, declarations = []) {
+  const ceiling = Math.min(String(code ?? "").length, MAX_SCAN_LENGTH);
+  const callableRanges = declarations.filter((item) => item.braceDepth === 0)
+    .sort((left, right) => left.start - right.start);
+  const statements = [];
+  let cursor = 0;
+  while (cursor < ceiling && statements.length < MAX_STATEMENTS) {
+    while (/\s/.test(code[cursor] ?? "")) cursor += 1;
+    if (cursor >= ceiling) break;
+    const declaration = callableRanges.find((item) => item.start === cursor);
+    const end = declaration?.end ?? statementEnd(code, cursor, ceiling);
+    if (end <= cursor) break;
+    const source = code.slice(cursor, end);
+    statements.push({
+      start: cursor, end, braceDepth: braceDepthAt(code, cursor), source,
+      kind: declaration ? declaration.kind : statementKind(source),
+      declarationName: declaration?.name ?? null
+    });
+    cursor = end;
+  }
+  const remainder = code.slice(cursor, ceiling).trim();
+  return { statements, complete: code.length <= MAX_SCAN_LENGTH && statements.length < MAX_STATEMENTS && !remainder };
+}
+
+/**
+ * Collect bounded callable bodies from already-sanitized JavaScript evidence.
+ * Besides the legacy lower-case lookup keys, each callable keeps exact declared
+ * names/parameters and structural spans. Consumers that prove a closed shape
+ * must use those exact fields instead of case-folded semantic identifiers.
+ */
+export function callableBodies(rawCode) {
+  const code = String(rawCode ?? "");
+  const bodies = new Map();
+  const declarations = [];
+  const add = (name, parameters, start, open, end, asynchronous, ownsArguments, kind, body) => {
+    if (declarations.length >= MAX_CALLABLES) return;
+    const exactParameters = formalParameterNames(parameters, true);
+    const closeEnd = open === -1 ? end : balancedEnd(code, open, "{", "}");
+    const callable = {
+      name: name.toLowerCase(), declarationName: name, exactDeclarationName: name,
+      body, parameters: exactParameters.map((item) => item.toLowerCase()), exactParameters,
+      parameterSource: parameters, exactParameterSource: parameters,
+      defaultedParameters: defaultedFormalParameterNames(parameters),
+      exactDefaultedParameters: defaultedFormalParameterNames(parameters, true),
+      sourceCode: code, asynchronous, ownsArguments, declarationKind: kind,
+      declarationStart: start, declarationEnd: end, bodyOpen: open,
+      bodyStart: open === -1 ? null : open + 1, bodyEnd: open === -1 ? end : closeEnd - 1,
+      braceDepth: braceDepthAt(code, start), exactDeclarationKind: kind
+    };
+    callable.exactBraceDepth = callable.braceDepth;
+    callable.exactDeclarationStart = start;
+    callable.exactDeclarationEnd = end;
+    const declaration = { name, normalizedName: name.toLowerCase(), parameters: exactParameters,
+      start, end, open, braceDepth: callable.braceDepth, kind, callable };
+    declarations.push(declaration);
+    if (!bodies.has(callable.name)) bodies.set(callable.name, callable);
+  };
+  const afterParameters = (open) => {
+    const end = balancedEnd(code, open);
+    if (end === -1) return null;
+    let cursor = end;
+    while (/\s/.test(code[cursor] ?? "")) cursor += 1;
+    return { end, cursor };
+  };
+
+  for (const match of code.matchAll(/\b(async\s+)?function\s+([a-z_$][a-z0-9_$]*)\s*\(/gi)) {
+    const open = match.index + match[0].lastIndexOf("(");
+    const parameters = afterParameters(open);
+    if (!parameters || code[parameters.cursor] !== "{") continue;
+    const bodyEnd = balancedEnd(code, parameters.cursor, "{", "}");
+    if (bodyEnd === -1) continue;
+    const start = declarationStart(code, match.index);
+    add(match[2], code.slice(open + 1, parameters.end - 1), start, parameters.cursor,
+      withOptionalSemicolon(code, bodyEnd), Boolean(match[1]), true, "function-declaration",
+      code.slice(parameters.cursor + 1, bodyEnd - 1));
+  }
+  for (const match of code.matchAll(/^\s*(async\s+)?([a-z_$][a-z0-9_$]*)\s*\(/gim)) {
+    if (["catch", "for", "function", "if", "switch", "while", "with"].includes(match[2].toLowerCase())) continue;
+    const open = match.index + match[0].lastIndexOf("(");
+    const parameters = afterParameters(open);
+    if (!parameters || code[parameters.cursor] !== "{") continue;
+    const bodyEnd = balancedEnd(code, parameters.cursor, "{", "}");
+    if (bodyEnd === -1) continue;
+    add(match[2], code.slice(open + 1, parameters.end - 1),
+      match.index + (match[0].match(/^\s*/)?.[0].length ?? 0), parameters.cursor, bodyEnd,
+      Boolean(match[1]), true, "method-declaration", code.slice(parameters.cursor + 1, bodyEnd - 1));
+  }
+  for (const match of code.matchAll(/\b(?:const|let|var)\s+([a-z_$][a-z0-9_$]*)\s*=\s*(async\s+)?/gi)) {
+    let cursor = match.index + match[0].length;
+    let parameters = "";
+    if (code[cursor] === "(") {
+      const parsed = afterParameters(cursor);
+      if (!parsed) continue;
+      parameters = code.slice(cursor + 1, parsed.end - 1);
+      cursor = parsed.cursor;
+    } else {
+      const direct = code.slice(cursor).match(/^([a-z_$][a-z0-9_$]*)/i);
+      if (!direct) continue;
+      parameters = direct[1];
+      cursor += direct[0].length;
+      while (/\s/.test(code[cursor] ?? "")) cursor += 1;
+    }
+    if (code.slice(cursor, cursor + 2) !== "=>") continue;
+    cursor += 2;
+    while (/\s/.test(code[cursor] ?? "")) cursor += 1;
+    const start = declarationStart(code, match.index);
+    if (code[cursor] === "{") {
+      const bodyEnd = balancedEnd(code, cursor, "{", "}");
+      if (bodyEnd !== -1) add(match[1], parameters, start, cursor, withOptionalSemicolon(code, bodyEnd),
+        Boolean(match[2]), false, "arrow-declaration", code.slice(cursor + 1, bodyEnd - 1));
+    } else {
+      const end = [code.indexOf(";", cursor), code.indexOf("\n", cursor)].filter((item) => item >= 0).sort((a, b) => a - b)[0] ?? code.length;
+      add(match[1], parameters, start, -1, code[end] === ";" ? end + 1 : end,
+        Boolean(match[2]), false, "arrow-expression", code.slice(cursor, end));
+    }
+  }
+
+  declarations.sort((left, right) => left.start - right.start);
+  const inventory = boundedTopLevelStatements(code, declarations);
+  const folded = new Map();
+  for (const declaration of declarations) {
+    const names = folded.get(declaration.normalizedName) ?? [];
+    names.push(declaration.name);
+    folded.set(declaration.normalizedName, names);
+  }
+  bodies.declarations = declarations;
+  bodies.topLevelStatements = inventory.statements;
+  bodies.scanComplete = code.length <= MAX_SCAN_LENGTH && inventory.complete && declarations.length < MAX_CALLABLES;
+  bodies.caseFoldCollisions = new Set([...folded].filter(([, names]) => new Set(names).size > 1 || names.length > 1).map(([name]) => name));
+  for (const callable of bodies.values()) callable.topLevelStatements = bodies.topLevelStatements;
+  return bodies;
+}

package/packages/piagent-core/extensions/acceptance-clause-group.js

@@ -0,0 +1,45 @@
+import crypto from 'node:crypto';
+import { acceptanceCriterionBindingValid } from './acceptance-behavior-proof.js';
+
+const hash = text => crypto.createHash('sha256').update(text).digest('hex');
+
+// Derived children are projections of one already bound parent, never new
+// operator criteria. Offsets and the unchanged full context preserve every
+// clause and its qualifiers across packing, resume and receipt refresh.
+export function boundAcceptanceClauseGroup(task, receipt, criterion, index) {
+  if (!Array.isArray(receipt?.criteria) || !criterion || !Number.isInteger(index) || index < 0 || !acceptanceCriterionBindingValid(task, receipt, criterion, index)) return null;
+  const text = task.acceptanceCriteria[index];
+  if (text.length > 600 || !text.includes('\n') || text.includes('\r')
+    || typeof task.operatorRequest !== 'string'
+    || task.operatorRequestDigest !== `operator-request-v1:${hash(task.operatorRequest)}`) return null;
+  const normalize = value => value.replace(/\s+/g, ' ').trim();
+  if (!normalize(task.operatorRequest).includes(normalize(text))) return null;
+  const lines = text.split('\n');
+  if (lines.length < 2 || lines.length > 32 || lines.some(line => !line.trim() || line !== line.trim()
+    || (line.match(/`/g)?.length ?? 0) % 2 !== 0)) return null;
+  let offset = 0;
+  const children = lines.map((line, ordinal) => {
+    const child = {id: `clause-${hash(`${criterion.id}\0${ordinal}\0${line}`).slice(0, 24)}`,
+      text: line, hash: hash(line), ordinal, start: offset, end: offset + line.length};
+    offset = child.end + 1; return child;
+  });
+  return {parentId: criterion.id, parentHash: criterion.hash, requestDigest: task.operatorRequestDigest,
+    context: task.operatorRequest, text, children};
+}
+
+export function allClauseEvidence(group, childEvidence, workingTreeDigest) {
+  if (!group || !Array.isArray(group.children) || group.children.length < 2 || !Array.isArray(childEvidence)
+    || childEvidence.length !== group.children.length || !workingTreeDigest) return undefined;
+  const accepted = group.children.map((child, index) => {
+    const item = childEvidence[index];
+    return item?.id === child.id && item?.hash === child.hash && item.evidence?.workingTreeDigest === workingTreeDigest
+      && item.evidence.exitCode === 0 && typeof item.evidence.command === 'string' && item.evidence.command.trim()
+      ? item.evidence : null;
+  });
+  if (accepted.some(item => item === null)) return undefined;
+  const binding = hash(JSON.stringify({request: group.requestDigest, parent: group.parentHash,
+    children: group.children.map((child, index) => ({hash: child.hash, start: child.start, end: child.end, evidence: accepted[index]}))}));
+  return {kind: 'all-clause-proof', summary: `All ${accepted.length} lossless clauses have current evidence; binding sha256:${binding}.`,
+    command: accepted[0].command, exitCode: 0, workingTreeDigest,
+    paths: [...new Set(accepted.flatMap(item => item.paths ?? []))]};
+}