@piagent/platform 1.6.0 → 1.7.1

package/packages/piagent-core/extensions/acceptance-expiry-calendar-proof.js

@@ -0,0 +1,162 @@
+import { callableBodies } from "./acceptance-callable-scanner.js";
+
+const EXACT_BODY = [
+  "if(expiresAt instanceof Date){",
+  "const timestamp=expiresAt.getTime();",
+  "if(Number.isNaN(timestamp))throw new TypeError(__pi_string_literal__);",
+  "return timestamp;",
+  "}",
+  "if(typeof expiresAt!==__pi_typeof_string_literal__)throw new TypeError(__pi_string_literal__);",
+  "const match=__pi_iso_expiry_calendar_regex_literal__.exec(expiresAt);",
+  "if(!match)throw new TypeError(__pi_string_literal__);",
+  "const[,year,month,day,hour,minute,second=__pi_two_digit_zero_string_literal__]=match;",
+  "const yearNumber=Number(year);",
+  "const monthNumber=Number(month);",
+  "const dayNumber=Number(day);",
+  "const hourNumber=Number(hour);",
+  "const minuteNumber=Number(minute);",
+  "const secondNumber=Number(second);",
+  "const leapYear=yearNumber%4===0&&(yearNumber%100!==0||yearNumber%400===0);",
+  "const daysInMonth=[31,leapYear?29:28,31,30,31,30,31,31,30,31,30,31][monthNumber-1]||0;",
+  "if(monthNumber<1||monthNumber>12||dayNumber<1||dayNumber>daysInMonth||hourNumber>23||minuteNumber>59||secondNumber>59){",
+  "throw new TypeError(__pi_string_literal__);",
+  "}",
+  "const timestamp=Date.parse(expiresAt);",
+  "if(Number.isNaN(timestamp))throw new TypeError(__pi_string_literal__);",
+  "return timestamp;"
+].join("").replace(/\s+/g, "");
+const DIRECT_DAYS_BODY = EXACT_BODY.replace(
+  "constdaysInMonth=[31,leapYear?29:28,31,30,31,30,31,31,30,31,30,31][monthNumber-1]||0;",
+  "constdaysInMonth=monthNumber===2?(leapYear?29:28):[4,6,9,11].includes(monthNumber)?30:31;"
+);
+
+const PARTITIONS = [
+  "empty-string", "invalid-calendar-date-string", "invalid-date-object", "invalid-date-string",
+  "missing", "non-string", "null", "zero"
+];
+const ID = "[A-Za-z_$][A-Za-z0-9_$]*";
+
+function compact(value) {
+  return String(value ?? "").replace(/\s+/g, "");
+}
+
+function explicitAsiStatements(value) {
+  return String(value ?? "").split("\n").map((line) => {
+    const trimmed = line.trim();
+    return !trimmed.endsWith(";") && (/^(?:const|let)\b|^return\b|^throw\b/.test(trimmed) || /throw\s+new\s+TypeError\([^)]*\)$/.test(trimmed)) ? `${line};` : line;
+  }).join("\n");
+}
+
+function structuralTokens(value) {
+  return String(value ?? "").match(/__pi_[a-z0-9_]+__|[A-Za-z_$][A-Za-z0-9_$]*|\d+|===|!==|>=|<=|&&|\|\||=>|[{}()[\].,;?:%+\-*/<>!=]/g) ?? [];
+}
+
+function sameStructuralProgram(left, right) {
+  const actual = structuralTokens(left), expected = structuralTokens(right);
+  return actual.length === expected.length && actual.every((token, index) => token === expected[index]);
+}
+
+function canonicalSurfaceForms(value) {
+  return String(value ?? "")
+    .replace(/if\(([^{}]+)\)\{thrownewTypeError\((__pi_string_literal__)\);?\}/g, "if($1)thrownewTypeError($2);")
+    .replace(/let\[,/g, "const[,")
+    .replace(/;/g, "");
+}
+
+function replaceIdentifiers(body, bindings) {
+  return [...bindings.entries()].sort(([left], [right]) => right.length - left.length)
+    .reduce((text, [name, canonical]) => text.replace(new RegExp(`\\b${name}\\b`, "g"), canonical), body);
+}
+
+function intrinsicEnvironmentIsSafe(source) {
+  const code = String(source ?? "");
+  if (/\b(?:Object|Reflect|Proxy|eval|Function)\b/.test(code)) return false;
+  const residual = code
+    .replace(/\binstanceof\s+Date\b/g, "")
+    .replace(/\bDate\s*\.\s*(?:now|parse)\s*\(/g, "(")
+    .replace(/\bNumber\s*\.\s*(?:isFinite|isNaN)\s*\(/g, "(")
+    .replace(/\bNumber\s*\(/g, "(")
+    .replace(/\bnew\s+TypeError\s*\(/g, "(");
+  return !/\b(?:Date|Number|TypeError)\b/.test(residual);
+}
+
+function alphaNormalizedCalendarBody(callable) {
+  const exactBody = explicitAsiStatements(callable?.exactBody);
+  let body = compact(exactBody);
+  const input = body.match(new RegExp(`^if\\((${ID})instanceofDate\\)`))?.[1];
+  if (!input) return null;
+  const bindings = new Map([[input, "expiresAt"]]);
+  const dateTimestamp = body.match(new RegExp(`^if\\(${input}instanceofDate\\)\\{const(${ID})=${input}\\.getTime\\(\\);`))?.[1];
+  const exec = body.match(new RegExp(`const(${ID})=__pi_iso_expiry_calendar_regex_literal__\\.exec\\(${input}\\);`));
+  const matchCall = body.match(new RegExp(`const(${ID})=${input}\\.match\\(__pi_iso_expiry_calendar_regex_literal__\\);`));
+  const match = exec ?? matchCall;
+  const captures = match && body.match(new RegExp(`(?:const|let)\\[,(${ID}),(${ID}),(${ID}),(${ID}),(${ID}),(${ID})=__pi_two_digit_zero_string_literal__\\]=${match[1]};`));
+  if (!dateTimestamp || !match || !captures) return null;
+  bindings.set(dateTimestamp, "timestamp"); bindings.set(match[1], "match");
+  ["year", "month", "day", "hour", "minute", "second"].forEach((name, index) => bindings.set(captures[index + 1], name));
+  for (const [capture, canonical] of [...bindings.entries()].filter(([, value]) => ["year", "month", "day", "hour", "minute", "second"].includes(value))) {
+    const numeric = body.match(new RegExp(`const(${ID})=Number\\(${capture}\\);`))?.[1];
+    if (!numeric) return null;
+    bindings.set(numeric, `${canonical}Number`);
+  }
+  const normalizedForCalendar = compact(replaceIdentifiers(exactBody, bindings));
+  const leap = normalizedForCalendar.match(new RegExp(`const(${ID})=yearNumber%4===0&&\\(yearNumber%100!==0\\|\\|yearNumber%400===0\\);`))?.[1];
+  if (!leap) return null;
+  bindings.set(leap, "leapYear");
+  const withLeap = compact(replaceIdentifiers(exactBody, bindings));
+  const namedTable = withLeap.match(new RegExp(`const(${ID})=\\[31,leapYear\\?29:28,31,30,31,30,31,31,30,31,30,31\\];const(${ID})=\\1\\[monthNumber-1\\]\\|\\|0;`));
+  const days = (withLeap.match(new RegExp(`const(${ID})=\\[31,leapYear\\?29:28,31,30,31,30,31,31,30,31,30,31\\]\\[monthNumber-1\\]\\|\\|0;`))
+    ?? withLeap.match(new RegExp(`const(${ID})=\\[0,31,leapYear\\?29:28,31,30,31,30,31,31,30,31,30,31\\]\\[monthNumber\\]\\|\\|0;`))
+    ?? withLeap.match(new RegExp(`const(${ID})=monthNumber===2\\?\\(leapYear\\?29:28\\):\\[4,6,9,11\\]\\.includes\\(monthNumber\\)\\?30:31;`)))?.[1] ?? namedTable?.[2];
+  if (!days) return null;
+  bindings.set(days, "daysInMonth");
+  body = compact(replaceIdentifiers(exactBody, bindings));
+  if (namedTable) body = body.replace(`const${namedTable[1]}=[31,leapYear?29:28,31,30,31,30,31,31,30,31,30,31];constdaysInMonth=${namedTable[1]}[monthNumber-1]||0;`, "constdaysInMonth=[31,leapYear?29:28,31,30,31,30,31,31,30,31,30,31][monthNumber-1]||0;");
+  body = body.replace("constdaysInMonth=[0,31,leapYear?29:28,31,30,31,30,31,31,30,31,30,31][monthNumber]||0;", "constdaysInMonth=[31,leapYear?29:28,31,30,31,30,31,31,30,31,30,31][monthNumber-1]||0;");
+  body = body.replace("if(monthNumber<1||monthNumber>12||dayNumber<1||dayNumber>daysInMonth){thrownewTypeError(__pi_string_literal__);}if(hourNumber>23||minuteNumber>59||secondNumber>59){thrownewTypeError(__pi_string_literal__);}", "if(monthNumber<1||monthNumber>12||dayNumber<1||dayNumber>daysInMonth||hourNumber>23||minuteNumber>59||secondNumber>59){thrownewTypeError(__pi_string_literal__);}");
+  if (matchCall) body = body.replace(`constmatch=expiresAt.match(__pi_iso_expiry_calendar_regex_literal__);`, "constmatch=__pi_iso_expiry_calendar_regex_literal__.exec(expiresAt);");
+  return { body, input };
+}
+
+/** Bounded alpha/dataflow proof for the strict ISO calendar parser shape. */
+export function retainedExpiryCalendarProof(callable, requestedErrors = []) {
+  const normalized = alphaNormalizedCalendarBody(callable);
+  const recognized = callable?.parameters?.length === 1
+    && normalized !== null
+    && normalized.input.toLowerCase() === callable.parameters[0]
+    && requestedErrors.includes("typeerror")
+    && intrinsicEnvironmentIsSafe(callable.exactSourceCode)
+    && (sameStructuralProgram(canonicalSurfaceForms(normalized.body), canonicalSurfaceForms(EXACT_BODY))
+      || sameStructuralProgram(canonicalSurfaceForms(normalized.body), canonicalSurfaceForms(DIRECT_DAYS_BODY)));
+  return {
+    recognized,
+    generic: recognized,
+    candidate: recognized,
+    partitions: new Set(recognized ? PARTITIONS : [])
+  };
+}
+
+export function casePreservingCallableBodies(exactCode, normalizedCode) {
+  const exactBodies = callableBodies(explicitAsiStatements(exactCode)), normalizedBodies = callableBodies(explicitAsiStatements(normalizedCode));
+  let exactMappingComplete = true;
+  for (const [name, callable] of normalizedBodies) {
+    const candidates = (exactBodies.declarations ?? []).filter((item) => item.normalizedName === name
+      && item.start === callable.declarationStart && item.kind === callable.declarationKind);
+    const exact = candidates.length === 1 ? candidates[0].callable : null;
+    if (!exact) exactMappingComplete = false;
+    if (exact) Object.assign(callable, {
+      exactBody: exact.body, exactSourceCode: exact.sourceCode,
+      exactDeclarationName: exact.declarationName, exactParameters: exact.exactParameters,
+      exactParameterSource: exact.parameterSource, exactDefaultedParameters: exact.exactDefaultedParameters,
+      exactDeclarationStart: exact.declarationStart, exactDeclarationEnd: exact.declarationEnd,
+      exactBraceDepth: exact.braceDepth, exactDeclarationKind: exact.declarationKind,
+      exactTopLevelStatements: exactBodies.topLevelStatements
+    });
+  }
+  normalizedBodies.exactDeclarations = exactBodies.declarations;
+  normalizedBodies.exactTopLevelStatements = exactBodies.topLevelStatements;
+  normalizedBodies.exactScanComplete = exactBodies.scanComplete;
+  normalizedBodies.exactMappingComplete = exactMappingComplete;
+  normalizedBodies.exactCaseFoldCollisions = exactBodies.caseFoldCollisions;
+  return normalizedBodies;
+}

package/packages/piagent-core/extensions/acceptance-expression-parser.js

@@ -0,0 +1,155 @@
+// A deliberately bounded grammar for already-sanitized, native-syntax-checked
+// evidence. Unknown syntax abstains; this never evaluates project JavaScript.
+const PRECEDENCE = { "??": 1, "||": 2, "&&": 3, "===": 4, "!==": 4, "<": 5, "<=": 5, ">": 5, ">=": 5, instanceof: 5, "+": 6, "-": 6, "*": 7, "/": 7, "%": 7 };
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+export function parseEvidenceStatements(source) {
+  const tokens = [];
+  const lexer = /\s+|[A-Za-z_$][A-Za-z0-9_$]*|(?:0|[1-9](?:_?[0-9])*)|===|!==|>=|<=|&&|\|\||\?\?|[{}()[\].,;?:%+\-*/<>!=]/gy;
+  let offset = 0;
+  while (offset < source.length) {
+    lexer.lastIndex = offset;
+    const match = lexer.exec(source);
+    if (!match || tokens.length > 2400) throw new Error("unsupported-temporal-syntax");
+    offset = lexer.lastIndex;
+    if (!/^\s+$/.test(match[0])) tokens.push(match[0]);
+  }
+  let cursor = 0, depth = 0;
+  const fail = () => { throw new Error("unsupported-temporal-syntax"); };
+  const take = (token) => tokens[cursor] === token && (cursor += 1);
+  const expect = (token) => { if (!take(token)) fail(); };
+  const identifier = () => {
+    const token = tokens[cursor++];
+    if (!IDENTIFIER.test(token ?? "") || /^(?:if|else|for|while|switch|case|break|continue|return|throw|try|catch|finally|function|class|const|let|var|export|import|default|new|typeof|instanceof|await|yield|delete|void|in|of|with|this|super)$/.test(token)) fail();
+    return token;
+  };
+  const argumentsList = () => {
+    const args = [];
+    expect("(");
+    if (!take(")")) {
+      do { args.push(expression()); } while (take(","));
+      expect(")");
+    }
+    return args;
+  };
+  function primary() {
+    if (++depth > 64) fail();
+    let result;
+    if (take("(")) { result = expression(); expect(")"); }
+    else if (take("[")) {
+      const values = [];
+      if (!take("]")) {
+        do { values.push(expression()); } while (take(","));
+        expect("]");
+      }
+      result = ["array", values];
+    } else if (take("new")) {
+      let target = ["id", identifier()];
+      while (take(".")) target = ["member", target, identifier()];
+      result = ["new", target, argumentsList()];
+    } else if (/^(?:0|[1-9](?:_?[0-9])*)$/.test(tokens[cursor] ?? "")) {
+      const value = Number(tokens[cursor++].replaceAll("_", ""));
+      if (!Number.isSafeInteger(value)) fail();
+      result = ["number", value];
+    }
+    else result = ["id", identifier()];
+    while (true) {
+      if (take(".")) result = ["member", result, identifier()];
+      else if (take("[")) { result = ["index", result, expression()]; expect("]"); }
+      else if (tokens[cursor] === "(") result = ["call", result, argumentsList()];
+      else break;
+    }
+    depth -= 1;
+    return result;
+  }
+  function unary() {
+    if (["!", "-", "typeof"].includes(tokens[cursor])) {
+      const operator = tokens[cursor++];
+      if (++depth > 64) fail();
+      const result = ["unary", operator, unary()];
+      depth -= 1;
+      return result;
+    }
+    return primary();
+  }
+  function expression(minimum = 0) {
+    let left = unary();
+    while ((PRECEDENCE[tokens[cursor]] ?? -1) >= minimum) {
+      const operator = tokens[cursor++];
+      left = ["binary", operator, left, expression(PRECEDENCE[operator] + 1)];
+    }
+    if (minimum === 0 && take("?")) {
+      const yes = expression(); expect(":");
+      left = ["select", left, yes, expression()];
+    }
+    return left;
+  }
+  function statement() {
+    if (++depth > 64) fail();
+    let result;
+    if (take("{")) { result = ["block", statements("}")]; expect("}"); }
+    else if (take("if")) {
+      expect("("); const condition = expression(); expect(")");
+      const yes = statement(), no = take("else") ? statement() : ["block", []];
+      result = ["if", condition, yes, no];
+    } else if (take("const")) {
+      const declarations = [];
+      do {
+        let binding;
+        if (take("[")) {
+          const slots = [];
+          while (!take("]")) {
+            if (take(",")) { slots.push(null); continue; }
+            const name = identifier(), fallback = take("=") ? expression() : null;
+            slots.push([name, fallback]);
+            if (!take(",")) { expect("]"); break; }
+          }
+          binding = ["destructure", slots];
+        } else binding = ["bind", identifier()];
+        expect("="); declarations.push([binding, expression()]);
+      } while (take(","));
+      expect(";"); result = ["const", declarations];
+    } else if (take("return")) { result = ["return", expression()]; expect(";"); }
+    else if (take("throw")) { result = ["throw", expression()]; expect(";"); }
+    else { result = ["expression", expression()]; expect(";"); }
+    depth -= 1;
+    return result;
+  }
+  function statements(end) {
+    const result = [];
+    while (cursor < tokens.length && tokens[cursor] !== end) result.push(statement());
+    return result;
+  }
+  const result = statements(null);
+  if (cursor !== tokens.length) fail();
+  return result;
+}
+
+// Reduced ordered Boolean decision diagrams compare all symbolic input paths,
+// not a sample of dates. Node/operation bounds keep evidence processing finite.
+export function evidenceBooleanAlgebra() {
+  const nodes = [null, null], unique = new Map(), memo = new Map();
+  const node = (name, low, high) => {
+    if (low === high) return low;
+    const key = JSON.stringify([name, low, high]);
+    if (!unique.has(key)) {
+      if (nodes.length >= 8192) throw new Error("temporal-proof-complexity-limit");
+      unique.set(key, nodes.length); nodes.push({ name, low, high });
+    }
+    return unique.get(key);
+  };
+  const apply = (operator, a, b) => {
+    if (a < 2 && b < 2) return Number(operator === "and" ? a && b : operator === "or" ? a || b : a !== b);
+    const key = `${operator}:${a}:${b}`;
+    if (memo.has(key)) return memo.get(key);
+    if (memo.size >= 32768) throw new Error("temporal-proof-complexity-limit");
+    const name = [nodes[a]?.name, nodes[b]?.name].filter((value) => value !== undefined).sort()[0];
+    const edge = (id, side) => nodes[id]?.name === name ? nodes[id][side] : id;
+    const result = node(name, apply(operator, edge(a, "low"), edge(b, "low")), apply(operator, edge(a, "high"), edge(b, "high")));
+    memo.set(key, result); return result;
+  };
+  const and = (...values) => values.reduce((a, b) => apply("and", a, b), 1);
+  const or = (...values) => values.reduce((a, b) => apply("or", a, b), 0);
+  const not = (value) => apply("xor", value, 1);
+  return { atom: (name) => node(name, 0, 1), and, or, not, implies: (a, b) => and(a, not(b)) === 0 };
+}

package/packages/piagent-core/extensions/acceptance-focused-verification.js

@@ -0,0 +1,40 @@
+import { isCurrentWorkingTreeDigest } from './working-tree-digest.js';
+import { isWorkspaceRevisionDigest } from './workspace-revision.js';
+
+// Recognize bounded observed test summaries; these can add obligations, never
+// replace a configured verifier or independently grant acceptance proof.
+export function observedFocusedTestSummary(output) {
+  const text = String(output ?? '');
+  return /^(?:#|ℹ)\s+tests [1-9]\d*\s*$/m.test(text)
+    && /^(?:#|ℹ)\s+pass \d+\s*$/m.test(text)
+    && /^(?:#|ℹ)\s+fail \d+\s*$/m.test(text);
+}
+
+export function unresolvedFocusedVerification(evidence, digest, revision) {
+  const latest = new Map(), failed = new Set();
+  for (const entry of evidence ?? []) {
+    if (entry.observed !== true || entry.matchedProfileCommand !== false || !entry.command) continue;
+    latest.set(entry.command, entry);
+    if (entry.exitCode !== 0 || entry.isError === true) failed.add(entry.command);
+  }
+  return [...failed].filter(command => {
+    const e = latest.get(command);
+    return !(e.exitCode === 0 && e.isError !== true && isCurrentWorkingTreeDigest(digest)
+      && isWorkspaceRevisionDigest(revision) && e.preWorkingTreeDigest === digest && e.workingTreeDigest === digest
+      && e.preWorkspaceRevisionDigest === revision && e.workspaceRevisionDigest === revision);
+  });
+}
+
+// Keep the recent history plus the observations needed to represent every
+// unresolved focused failure. Routine successful commands cannot evict a failure.
+export function retainFocusedVerification(evidence, digest, revision) {
+  const unresolved = new Set(unresolvedFocusedVerification(evidence, digest, revision));
+  const lastFailure = new Map(), lastObservation = new Map();
+  evidence.forEach((entry, index) => {
+    if (entry.observed !== true || entry.matchedProfileCommand !== false || !unresolved.has(entry.command)) return;
+    lastObservation.set(entry.command, index);
+    if (entry.exitCode !== 0 || entry.isError === true) lastFailure.set(entry.command, index);
+  });
+  const retained = new Set([...lastFailure.values(), ...lastObservation.values()]);
+  return evidence.filter((_, index) => index >= evidence.length - 100 || retained.has(index));
+}