@piagent/platform 1.6.1 → 1.8.0

package/packages/piagent-core/extensions/acceptance-declared-api.js

@@ -0,0 +1,126 @@
+import { parse } from "@babel/parser";
+import { protocolShape as shape, validateValue, numberValue } from "./acceptance-executor/values.mjs";
+
+export const DECLARED_API_VERSION = "declared-positional-api-v1";
+const NAME = /^[a-zA-Z_$][\w$]{0,127}$/;
+const fail = () => { throw new TypeError("declared-api-unsupported"); };
+
+/** Explicit host expectation for declarations only. Parameter names and function
+ * bodies are not API proofs; behavior/default results require the other cases.
+ * This comparator never executes source or reads a model-supplied expectation.
+ */
+export function validateDeclaredApi(value) {
+  shape(value, ["version", "exports"]);
+  if (value.version !== DECLARED_API_VERSION || !Array.isArray(value.exports) || value.exports.length < 1 || value.exports.length > 32) fail();
+  let previous = "";
+  for (const entry of value.exports) {
+    if (typeof entry.name !== "string" || !NAME.test(entry.name) || entry.name <= previous) fail(); previous = entry.name;
+    if (entry.kind === "function") {
+      shape(entry, ["name", "kind", "async", "generator", "parameters"]);
+      if (typeof entry.async !== "boolean" || typeof entry.generator !== "boolean" || !Array.isArray(entry.parameters) || entry.parameters.length > 16) fail();
+      for (const parameter of entry.parameters) {
+        if (parameter === "required") continue;
+        if (parameter?.kind === "default-binding") {
+          shape(parameter, ["kind", "name", "value", "frozen"]); if (typeof parameter.name !== "string" || !NAME.test(parameter.name) || typeof parameter.frozen !== "boolean") fail();
+          validateValue(parameter.value, false);
+        } else {
+          shape(parameter, ["kind", "value"]); if (parameter.kind !== "default") fail();
+          validateValue(parameter.value, false);
+        }
+      }
+    } else {
+      shape(entry, ["name", "kind", "value", "frozen"]);
+      if (entry.kind !== "const-value" || typeof entry.frozen !== "boolean") fail();
+      validateValue(entry.value, false);
+    }
+  }
+  if (JSON.stringify(value).length > 65536) fail();
+  return value;
+}
+
+/** Closed, bounded declaration inspection, not a return-type or equivalence
+ * prover. Dynamic/re-exported APIs, destructuring, rest parameters and arbitrary
+ * initializer execution remain unknown. Const values must be inert literals.
+ */
+export function observeDeclaredApi(source) {
+  try {
+    if (typeof source !== "string" || Buffer.byteLength(source) > 64000) fail();
+    const ast = parse(source, { sourceType: "module", errorRecovery: false, attachComment: false });
+    const bindings = new Map(), exported = new Map(); let nodes = 0;
+    function visit(node, depth = 0) {
+      if (!node || typeof node.type !== "string") return;
+      if (++nodes > 12000 || depth > 128) fail();
+      // Conservative refusal of rebinding a public name, including ambiguous
+      // shadowing. Do not certify a declaration that source later replaces.
+      const target = node.type === "AssignmentExpression" ? node.left : node.type === "UpdateExpression" ? node.argument : null;
+      if (target?.type === "Identifier" && [...exported.values()].includes(target.name)) fail();
+      for (const [key, value] of Object.entries(node)) {
+        if (["loc", "extra", "comments", "tokens", "errors"].includes(key)) continue;
+        if (Array.isArray(value)) value.forEach(item => visit(item, depth + 1));
+        else if (value && typeof value === "object") visit(value, depth + 1);
+      }
+    }
+    for (const statement of ast.program.body) {
+      const isExport = statement.type === "ExportNamedDeclaration";
+      if (isExport && statement.source) fail();
+      const node = isExport ? statement.declaration : statement;
+      if (isExport && !node) {
+        for (const item of statement.specifiers) {
+          if (item.type !== "ExportSpecifier" || item.local.type !== "Identifier" || item.exported.type !== "Identifier" || exported.has(item.exported.name)) fail();
+          exported.set(item.exported.name, item.local.name);
+        }
+        continue;
+      }
+      const declarations = node?.type === "FunctionDeclaration" ? [[node.id?.name, node]]
+        : node?.type === "VariableDeclaration" && node.kind === "const" ? node.declarations.map(item => [item.id.type === "Identifier" ? item.id.name : null, item]) : null;
+      if (!declarations) fail();
+      for (const [name, declaration] of declarations) {
+        if (!name || bindings.has(name)) fail(); bindings.set(name, declaration);
+        if (isExport) { if (exported.has(name)) fail(); exported.set(name, name); }
+      }
+    }
+    visit(ast);
+    const literal = node => {
+      if (node?.type === "NullLiteral") return { type: "null" };
+      if (node?.type === "Identifier" && node.name === "undefined" && !bindings.has("undefined")) return { type: "undefined" };
+      if (node?.type === "NumericLiteral") return { type: "number", value: numberValue(node.value) };
+      if (node?.type === "StringLiteral") return { type: "string", value: node.value };
+      if (node?.type === "BooleanLiteral") return { type: "boolean", value: node.value };
+      if (node?.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "NumericLiteral") return { type: "number", value: numberValue(-node.argument.value) };
+      if (node?.type === "ArrayExpression") return { type: "array", value: node.elements.map(literal) };
+      if (node?.type === "ObjectExpression") {
+        const keys = new Set();
+        return { type: "record", value: node.properties.map(item => {
+          if (item.type !== "ObjectProperty" || item.computed || item.method || item.shorthand) fail();
+          const key = item.key.type === "Identifier" ? item.key.name : item.key.type === "StringLiteral" ? item.key.value : null;
+          if (key === null || key === "__proto__" || keys.has(key)) fail(); keys.add(key);
+          return { key, value: literal(item.value) };
+        }) };
+      }
+      return fail();
+    };
+    const constValue = node => {
+      if (node?.type !== "VariableDeclarator") fail();
+      let value = node.init, frozen = false;
+      if (value?.type === "CallExpression" && !value.optional && value.arguments.length === 1 && value.callee.type === "MemberExpression"
+        && !value.callee.computed && value.callee.object.type === "Identifier" && value.callee.object.name === "Object"
+        && value.callee.property.name === "freeze" && !bindings.has("Object")) { value = value.arguments[0]; frozen = true; }
+      return { value: literal(value), frozen };
+    };
+    const entries = [...exported].map(([name, local]) => {
+      const node = bindings.get(local); if (!node) fail();
+      if (node.type !== "FunctionDeclaration") return { name, kind: "const-value", ...constValue(node) };
+      const parameters = node.params.map(parameter => {
+        if (parameter.type === "Identifier") return "required";
+        if (parameter.type !== "AssignmentPattern" || parameter.left.type !== "Identifier") fail();
+        const right = parameter.right;
+        if (right.type === "Identifier" && bindings.has(right.name)) {
+          return { kind: "default-binding", name: right.name, ...constValue(bindings.get(right.name)) };
+        }
+        return { kind: "default", value: literal(right) };
+      });
+      return { name, kind: "function", async: node.async, generator: node.generator, parameters };
+    }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    return { status: "observed", value: validateDeclaredApi({ version: DECLARED_API_VERSION, exports: entries }) };
+  } catch { return { status: "unsupported", reason: "declared-api-unsupported" }; }
+}

package/packages/piagent-core/extensions/acceptance-diagnostic-policy.ts

@@ -0,0 +1,14 @@
+import type { BasePolicy, FinalGateConfig } from "./guard-types.ts";
+
+export function finalGateConfig(policy: BasePolicy, fallback: BasePolicy): Required<FinalGateConfig> {
+  const diagnostic = policy.finalGate?.acceptanceProofMode === "diagnostic";
+  return {
+    acceptanceProofMode: diagnostic ? "diagnostic" : "enforce",
+    defaultMode: policy.finalGate?.defaultMode ?? fallback.finalGate?.defaultMode ?? "enforce",
+    requireTaskContract: diagnostic || (policy.finalGate?.requireTaskContract ?? true),
+    requireContextManifest: diagnostic || (policy.finalGate?.requireContextManifest ?? true),
+    requireVerifyEvidence: diagnostic || (policy.finalGate?.requireVerifyEvidence ?? true),
+    requireTrace: diagnostic || (policy.finalGate?.requireTrace ?? true),
+    requirePassingVerify: diagnostic || (policy.finalGate?.requirePassingVerify ?? true)
+  };
+}

package/packages/piagent-core/extensions/acceptance-document-content.js

@@ -0,0 +1,73 @@
+import crypto from 'node:crypto';
+import { acceptanceCriterionBindingValid } from './acceptance-behavior-proof.js';
+import { durableContextEvidenceEntries } from './context-evidence.js';
+import { matchesAnyPath } from './policy-core.js';
+import { captureWorkspaceVerificationSnapshot } from './workspace-verification-snapshot.js';
+import { readWorkspaceFile } from '../security/workspace-file-reader.ts';
+
+const sha = value => crypto.createHash('sha256').update(value).digest('hex');
+const normalize = value => value.replace(/\s+/g, ' ').trim();
+const safePath = value => /^[A-Za-z0-9_./-]{1,240}$/.test(value)
+  && value.split('/').every(part => part && part !== '.' && part !== '..' && !part.startsWith('.'));
+
+// Only operator-bound literal-copy requests qualify. Data values never supply
+// paths, commands, permission or new obligations to this reader.
+export function documentContentRule(request) {
+  if (typeof request !== 'string' || request.length > 16000) return null;
+  const text = normalize(request);
+  const update = [...text.matchAll(/(?:^|[.!?] )Update `([^`]+)` with the ([A-Za-z][A-Za-z ,_-]{1,140}) from `([^`]+)`\./g)];
+  const scope = [...text.matchAll(/(?:^|[.!?] )Change only `([^`]+)`, include (both|all) configuration values verbatim, and run the configured verification\./g)];
+  if (update.length !== 1 || scope.length !== 1) return null;
+  const [, documentPath, names, configPath] = update[0];
+  if (scope[0][1] !== documentPath || !safePath(documentPath) || !safePath(configPath)
+    || !/\.(?:md|txt)$/.test(documentPath) || !/\.json$/.test(configPath)) return null;
+  const labels = names.split(/,\s*(?:and\s+)?|\s+and\s+/).map(value => value.trim());
+  if (labels.length < 2 || labels.length > 8 || labels.some(value => !/^[A-Za-z][A-Za-z _-]{0,50}$/.test(value))
+    || new Set(labels).size !== labels.length || scope[0][2] === 'both' && labels.length !== 2) return null;
+  return { documentPath, configPath, labels, clauses: [update[0][0].replace(/^[.!?] /, ''), scope[0][0].replace(/^[.!?] /, '')] };
+}
+
+export function documentContentCriterionEvidence({task, criterion, corpus, cwd, passingVerifier, verifierEvidence, currentWorkingTreeDigest, workspaceRevisionDigest}) {
+  const rule = documentContentRule(task?.operatorRequest);
+  if (!rule) return {handled: false};
+  const index = task.acceptanceReceipt?.criteria.findIndex(item => item.id === criterion?.id) ?? -1;
+  const selected = task.acceptanceCriteria?.[index];
+  if (typeof selected !== 'string' || !rule.clauses.includes(normalize(selected))) return {handled: false};
+  const missing = {handled: true};
+  if (task.operatorRequestDigest !== `operator-request-v1:${sha(task.operatorRequest)}`
+    || !acceptanceCriterionBindingValid(task, task.acceptanceReceipt, criterion, index)
+    || task.changeMode !== 'source-change' || !passingVerifier || !verifierEvidence || !cwd
+    || verifierEvidence.workingTreeDigest !== currentWorkingTreeDigest || verifierEvidence.exitCode !== 0
+    || corpus.files.length !== 1 || corpus.files[0] !== rule.documentPath) return missing;
+  const forbidden = [...(task.protectedPaths ?? []), ...(task.outOfScope ?? [])];
+  if ([rule.documentPath, rule.configPath].some(file => matchesAnyPath(file, forbidden))) return missing;
+  if (!durableContextEvidenceEntries(task).some(entry => entry.path === rule.configPath)) return missing;
+  try {
+    const before = captureWorkspaceVerificationSnapshot(cwd);
+    if (!before.proofCapable || before.digest !== currentWorkingTreeDigest
+      || before.workspaceRevisionDigest !== workspaceRevisionDigest) return missing;
+    const configBytes = readWorkspaceFile(cwd, rule.configPath, 65536);
+    const documentBytes = readWorkspaceFile(cwd, rule.documentPath, 262144);
+    const decode = bytes => new TextDecoder('utf-8', {fatal: true}).decode(bytes);
+    const config = JSON.parse(decode(configBytes)), document = decode(documentBytes);
+    if (!config || typeof config !== 'object' || Array.isArray(config)) return missing;
+    const keyName = value => value.replace(/[ _-]/g, '').toLowerCase();
+    const keys = rule.labels.map(label => {
+      const labels = new Set([keyName(label), keyName(label.replace(/ name$/i, ''))]);
+      const candidates = Object.keys(config).filter(key => labels.has(keyName(key)));
+      return candidates.length === 1 ? candidates[0] : null;
+    });
+    if (keys.some(key => key === null) || new Set(keys).size !== keys.length) return missing;
+    if (keys.some(key => typeof config[key] !== 'string' || !config[key].trim() || !document.includes(config[key]))) return missing;
+    // Recheck both reads before publishing their combined content binding.
+    if (!configBytes.equals(readWorkspaceFile(cwd, rule.configPath, 65536))
+      || !documentBytes.equals(readWorkspaceFile(cwd, rule.documentPath, 262144))) return missing;
+    const after = captureWorkspaceVerificationSnapshot(cwd);
+    if (!after.proofCapable || before.digest !== after.digest || before.workspaceRevisionDigest !== after.workspaceRevisionDigest) return missing;
+    const binding = sha(JSON.stringify({version: 1, request: task.operatorRequestDigest,
+      criterion: criterion.hash, config: sha(configBytes), document: sha(documentBytes), keys}));
+    return {handled: true, evidence: {...verifierEvidence, kind: 'document-content-proof',
+      summary: `Operator-requested configuration values occur verbatim in the sole changed document; content binding sha256:${binding}.`,
+      paths: [rule.documentPath, rule.configPath]}};
+  } catch { return missing; }
+}

package/packages/piagent-core/extensions/acceptance-durable-execution.d.ts

@@ -0,0 +1,59 @@
+import type { openAcceptanceEvidenceStore } from "./acceptance-evidence-store.js";
+import type { captureExecutionSnapshot } from "./acceptance-execution-snapshot.js";
+import type { AuthenticatedAssessment } from "./acceptance-authenticated-admission.js";
+
+export const DURABLE_EXECUTION_VERSION: "durable-module-contract-v2";
+export type LegacyDurableContractScope = { taskRunId: string; criterionId: string };
+export type FactDurableContractScope = { version: "authenticated-contract-fact-scope-v2";
+  taskRunId: string; criterionId: string; factId: string };
+export type DurableContractScope = LegacyDurableContractScope | FactDurableContractScope;
+export type ProjectVerificationRequest = DurableContractScope & {
+  criterionHash: string;
+  snapshot: ReturnType<typeof captureExecutionSnapshot>["binding"];
+  snapshotDigest: string;
+};
+export type DurableContractConfiguration = {
+  store: ReturnType<typeof openAcceptanceEvidenceStore>;
+  projectRoot: string;
+  sourcePath: string;
+  modulePaths?: readonly string[];
+  authorizeSourceRead: (input: { projectRoot: string; sourcePath: string }) => boolean;
+  exportName: string;
+  checks: unknown[];
+  profile?: Readonly<{ id: string; digest: string; workerVersion: string }>;
+  imageId: string;
+  dockerSocket: string;
+  dockerCommand?: Readonly<{ path: string; sha256: string }>;
+  verifierDigest: string;
+  getProjectVerificationDigest: (input: ProjectVerificationRequest) => string | null | Promise<string | null>;
+  timeoutMs?: number;
+  /** Extra attached-command wait; guest watchdog and CPU/wall budgets are unchanged. */
+  startupAllowanceMs?: number;
+};
+export type DurableContractResult = Readonly<{
+  version: typeof DURABLE_EXECUTION_VERSION;
+  verdict: "pass" | "fail" | "unknown" | "error";
+  completionAllowed: false;
+  reason?: string;
+  attemptId?: string;
+  reused?: boolean;
+  evidence?: Readonly<{
+    version: typeof DURABLE_EXECUTION_VERSION;
+    verdict: "pass" | "fail" | "unknown" | "error";
+    snapshotDigest: string;
+    planDigest: string;
+    reason?: string;
+    observed: unknown;
+  }>;
+}>;
+export function createDurableContractRunner(configuration: DurableContractConfiguration): Readonly<{
+  version: typeof DURABLE_EXECUTION_VERSION;
+  run(input: {
+    scope: DurableContractScope;
+    criterionHash: string;
+    maxAttempts: number;
+    retry?: boolean;
+    signal?: AbortSignal;
+  }): Promise<DurableContractResult>;
+  assess(result: unknown, options?: { policy?: string }): Promise<AuthenticatedAssessment>;
+}>;

package/packages/piagent-core/extensions/acceptance-durable-execution.js

@@ -0,0 +1,139 @@
+import { createHash } from "node:crypto";
+import { isAbsolute, normalize } from "node:path";
+import { compileIndependentContract } from "./acceptance-independent-contract.js";
+import { captureExecutionSnapshot, EXECUTION_SNAPSHOT_VERSION, runSnapshotBoundContract, snapshotPlanSource } from "./acceptance-execution-snapshot.js";
+import { validateModulePaths } from "./acceptance-executor/module-graph.mjs";
+import { createAuthenticatedAdmission, unavailableAuthenticatedAssessment } from "./acceptance-authenticated-admission.js";
+import { FACT_EVIDENCE_SCOPE_VERSION, ROOT_AGGREGATE_FACT_ID } from "./acceptance-evidence-store.js";
+
+export const DURABLE_EXECUTION_VERSION = "durable-module-contract-v2";
+const HASH = /^[a-f0-9]{64}$/;
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const freeze = (value) => {
+  if (value && typeof value === "object") { for (const child of Object.values(value)) freeze(child); Object.freeze(value); }
+  return value;
+};
+const unavailable = (reason, attemptId) => Object.freeze({ version: DURABLE_EXECUTION_VERSION,
+  verdict: "unknown", reason, completionAllowed: false, ...(attemptId ? { attemptId } : {}) });
+
+/**
+ * HOST-ONLY durable diagnostic runner, not a completion gate or model tool.
+ * All configuration/checks and the evidence-store handle must be host-approved.
+ * verifierDigest identifies the installed host verifier code; the project
+ * verification callback must return the digest of a current, actually observed
+ * project verifier, bound to this snapshot and task (or null if unavailable).
+ * Neither model-provided expected results nor project-authored receipt JSON may
+ * supply these capabilities. Runtime approval/observation wiring is separate.
+ *
+ * Only the current authenticated store event can be reused. A pending run never
+ * starts another worker automatically. Explicit retries consume the same finite
+ * attempt budget. Interruption reconciliation must establish worker termination
+ * before the store's recordStoppedAttempt capability can be used.
+ */
+export function createDurableContractRunner({ store, projectRoot, sourcePath, modulePaths, authorizeSourceRead,
+  exportName, checks, profile, imageId, dockerSocket, dockerCommand, verifierDigest,
+  getProjectVerificationDigest, timeoutMs = 10000, startupAllowanceMs = 0 } = {}) {
+  if (!store || typeof store.reserve !== "function" || typeof store.settle !== "function"
+    || typeof verifierDigest !== "string" || !HASH.test(verifierDigest) || typeof getProjectVerificationDigest !== "function"
+    || typeof imageId !== "string" || !/^sha256:[a-f0-9]{64}$/.test(imageId)
+    || typeof dockerSocket !== "string" || !dockerSocket.startsWith("/") || dockerSocket.includes("\0")
+    || dockerCommand !== undefined && (!dockerCommand || typeof dockerCommand !== "object"
+      || Array.isArray(dockerCommand)
+      || JSON.stringify(Object.keys(dockerCommand)) !== JSON.stringify(["path", "sha256"])
+      || typeof dockerCommand.path !== "string" || !isAbsolute(dockerCommand.path)
+      || normalize(dockerCommand.path) !== dockerCommand.path || dockerCommand.path.includes("\0")
+      || !HASH.test(String(dockerCommand.sha256 ?? "")))
+    || !Number.isSafeInteger(startupAllowanceMs) || startupAllowanceMs < 0 || startupAllowanceMs > 60000
+    || !Number.isSafeInteger(timeoutMs) || timeoutMs < 25 || timeoutMs > 30000) throw new TypeError("Invalid approved durable verifier configuration");
+  // Compile before retaining the plan to detach it from later caller mutations.
+  const nodeProfile = profile !== undefined;
+  const approvedDockerCommand = dockerCommand === undefined ? undefined
+    : Object.freeze({ path: dockerCommand.path, sha256: dockerCommand.sha256 });
+  const template = compileIndependentContract(JSON.stringify({ schemaVersion: nodeProfile ? 2 : 1,
+    ...(nodeProfile ? { profile } : {}), source: "export const placeholder = 0;", exportName, checks }));
+  const plan = source => ({ schemaVersion: nodeProfile ? 2 : 1,
+    ...(nodeProfile ? { profile: template.plan.profile } : {}), ...source, exportName, checks });
+  const approvedChecks = template.plan.checks;
+  const snapshotRequest = { projectRoot, sourcePath, authorizeSourceRead,
+    ...(modulePaths === undefined ? {} : { modulePaths: Object.freeze(validateModulePaths(sourcePath, modulePaths)) }) };
+  const admission = createAuthenticatedAdmission({ store, snapshotRequest, verifierDigest, imageId, exportName, checks: approvedChecks,
+    ...(nodeProfile ? { profile: template.plan.profile } : {}) });
+  const completed = new WeakMap();
+  const backendDigest = hash(JSON.stringify([DURABLE_EXECUTION_VERSION, template.version,
+    EXECUTION_SNAPSHOT_VERSION, imageId, dockerSocket, approvedDockerCommand ?? null,
+    timeoutMs, template.plan.profile ?? null, ...(startupAllowanceMs ? [startupAllowanceMs] : [])]));
+
+  async function run({ scope, criterionHash, maxAttempts, retry = false, signal } = {}) {
+    if (typeof criterionHash !== "string" || !HASH.test(criterionHash)) throw new TypeError("Invalid current criterion hash");
+    const factScoped = scope?.version === FACT_EVIDENCE_SCOPE_VERSION;
+    if (factScoped && scope.factId === ROOT_AGGREGATE_FACT_ID) throw new TypeError("The root aggregate is not a code child fact");
+    // Freeze identities before awaiting a host callback; the caller cannot swap
+    // tasks or criteria midway through a reserved execution.
+    const identity = Object.freeze({ ...(factScoped ? { version: FACT_EVIDENCE_SCOPE_VERSION, factId: scope.factId } : {}),
+      taskRunId: scope?.taskRunId, criterionId: scope?.criterionId, criterionHash });
+    const exactScope = Object.freeze({ ...(factScoped ? { version: FACT_EVIDENCE_SCOPE_VERSION } : {}),
+      taskRunId: identity.taskRunId, criterionId: identity.criterionId, ...(factScoped ? { factId: identity.factId } : {}) });
+    const before = captureExecutionSnapshot(snapshotRequest);
+    if (before.binding.projectId !== store.projectId) throw new Error("Evidence store belongs to another project");
+    const verificationDigest = await getProjectVerificationDigest({ ...identity, snapshot: before.binding, snapshotDigest: before.snapshotDigest });
+    if (typeof verificationDigest !== "string" || !HASH.test(verificationDigest)) return unavailable("current-project-verifier-missing");
+    const compiled = compileIndependentContract(JSON.stringify({ ...plan(snapshotPlanSource(before)), checks: approvedChecks }));
+    const binding = { criterionHash, snapshotDigest: before.snapshotDigest, verifierDigest,
+      projectVerificationDigest: verificationDigest, planDigest: compiled.planDigest, backendDigest };
+    if (signal?.aborted) return unavailable("cancelled-before-reservation");
+    const reserved = store.reserve({ scope: exactScope, binding, maxAttempts, retry });
+    if (!["current", "reserved"].includes(reserved.status)) return unavailable(`evidence-${reserved.status}`, reserved.event?.attemptId);
+
+    async function stillCurrent() {
+      try {
+        const after = captureExecutionSnapshot(snapshotRequest);
+        return after.snapshotDigest === before.snapshotDigest
+          && await getProjectVerificationDigest({ ...identity, snapshot: after.binding, snapshotDigest: after.snapshotDigest }) === verificationDigest;
+      } catch { return false; }
+    }
+    function diagnostic(evidence, event, reused) {
+      const result = freeze({ version: DURABLE_EXECUTION_VERSION, verdict: evidence.verdict, completionAllowed: false,
+        reused, attemptId: event.attemptId, evidence });
+      completed.set(result, { scope: exactScope, binding, event, stillCurrent,
+        expectedChecks: compiled.plan.checks.map((check) => ({ id: check.id, caseCount: check.cases.length })) });
+      return result;
+    }
+    if (reserved.status === "current") {
+      if (!await stillCurrent()) return unavailable("cached-evidence-binding-drift", reserved.event.attemptId);
+      const evidence = JSON.parse(reserved.event.evidenceText);
+      if (evidence.version !== DURABLE_EXECUTION_VERSION || evidence.snapshotDigest !== before.snapshotDigest
+        || evidence.planDigest !== compiled.planDigest || !["pass", "fail", "unknown", "error"].includes(evidence.verdict)) {
+        throw new Error("Authenticated evidence is incompatible with this verifier");
+      }
+      return diagnostic(evidence, reserved.event, true);
+    }
+
+    let observed;
+    try {
+      observed = await runSnapshotBoundContract({ ...snapshotRequest, exportName, checks: approvedChecks,
+        ...(nodeProfile ? { profile: template.plan.profile } : {}), imageId, dockerSocket,
+        ...(approvedDockerCommand === undefined ? {} : { dockerCommand: approvedDockerCommand }),
+        timeoutMs, startupAllowanceMs, signal, executionRunId: reserved.event.attemptId });
+    } catch {
+      observed = { verdict: "error", reason: "independent-execution-threw" };
+    }
+    const bound = observed.snapshotDigest === before.snapshotDigest && observed.result?.planDigest === compiled.planDigest;
+    const current = await stillCurrent();
+    const verdict = !current ? "unknown" : observed.verdict === "error" ? "error" : bound ? observed.verdict : "unknown";
+    const evidence = { version: DURABLE_EXECUTION_VERSION, snapshotDigest: before.snapshotDigest, planDigest: compiled.planDigest,
+      verdict, ...(!current || (!bound && observed.verdict !== "error") ? { reason: "execution-or-project-verifier-binding-drift" } : {}), observed };
+    // A failed settlement remains pending: there is no fallback to unsigned
+    // receipt files or a second execution. The host must reconcile explicitly.
+    const settled = store.settle(reserved.reservation, JSON.stringify(evidence));
+    return diagnostic(evidence, settled, false);
+  }
+  async function assess(result, { policy = "unknown" } = {}) {
+    if (policy !== "allow") return unavailableAuthenticatedAssessment("policy-unestablished-or-denied");
+    const observed = result && typeof result === "object" ? completed.get(result) : undefined;
+    if (!observed) return unavailableAuthenticatedAssessment("untrusted-durable-result");
+    if (!await observed.stillCurrent()) return unavailableAuthenticatedAssessment("current-project-or-source-binding-changed");
+    try { return admission.issue(observed); }
+    catch { return unavailableAuthenticatedAssessment("authenticated-admission-unavailable"); }
+  }
+  return Object.freeze({ version: DURABLE_EXECUTION_VERSION, run, assess });
+}

package/packages/piagent-core/extensions/acceptance-error-classes.js

@@ -147,7 +147,7 @@ export function rejectionStatementErrorClass(text, requestedErrors) {
   }
   if (close === -1) return null;
   const argument = text.slice(open + 1, close - 1).trim();
-  if (argument && !/^__pi_(?:(?:empty|double_quote|whitespace)_string|string|node_assert_module|code_generation_module|module_loader_module|error_name_[a-z]+)_literal__$/i.test(argument)) return null;
+  if (argument && !/^__pi_(?:(?:empty|double_quote|whitespace)_string|invalid_(?:calendar_)?date_string|unparseable_date_string|string|node_assert_module|code_generation_module|module_loader_module|error_name_[a-z]+)_literal__$/i.test(argument)) return null;
   if (!/^(?:[ \t]*;|[ \t]*(?:\}|$))/u.test(text.slice(close))) return null;
   return requestedErrors.length === 0 || requestedErrors.includes(errorClass) ? errorClass : null;
 }