@piagent/platform 1.6.1 → 1.8.0

package/packages/piagent-core/benchmark/benchmark-workflow.js

@@ -66,10 +66,97 @@ const RUNTIME_MANAGED_BENCHMARK_TOOLS = new Set([
   "piagent_tools"
 ]);
 
-export function evaluateWorkflowEvidence(task, changedFiles, toolNames = {}, options = {}) {
+function uniqueSorted(values) {
+  return [...new Set(values)].sort();
+}
+
+function taskTreeEvidence(task, actual) {
+  const baselineFiles = Object.keys(plainObject(task?.baselineFileDigests) ? task.baselineFileDigests : {}).sort();
+  const finalFiles = Object.keys(plainObject(task?.finalFileDigests) ? task.finalFileDigests : {}).sort();
+  const baselineFileClaims = Array.isArray(task?.baselineChangedFiles) ? [...task.baselineChangedFiles].sort() : [];
+  const finalFileClaims = Array.isArray(task?.finalWorkingTreeFiles) ? [...task.finalWorkingTreeFiles].sort() : [];
+  const migrationReady = task?.workingTreeDigestMigration === undefined;
+  const current = task?.workingTreeDigestAlgorithm === "wt-content-v2"
+    && migrationReady
+    && Array.isArray(task?.baselineChangedFiles)
+    && Array.isArray(task?.finalWorkingTreeFiles)
+    && taskWorkingTreeSnapshotUsesCurrentAlgorithm(task?.baselineFileDigests)
+    && taskWorkingTreeSnapshotUsesCurrentAlgorithm(task?.finalFileDigests)
+    && JSON.stringify(baselineFiles) === JSON.stringify(baselineFileClaims)
+    && JSON.stringify(finalFiles) === JSON.stringify(finalFileClaims)
+    && JSON.stringify(finalFiles) === JSON.stringify(actual);
+  return {
+    current,
+    digest: current ? taskWorkingTreeEvidenceDigest(task.finalFileDigests) : undefined
+  };
+}
+
+function normalizedTasks(taskOrTasks) {
+  return (Array.isArray(taskOrTasks) ? taskOrTasks : taskOrTasks ? [taskOrTasks] : [])
+    .filter((task) => plainObject(task));
+}
+
+function taskStartChoreography(tasks, task, options) {
+  const evidence = plainObject(options.taskStartEvidence) ? options.taskStartEvidence : undefined;
+  const acceptedTaskStartCount = Number.isInteger(evidence?.acceptedTaskStartCount)
+    ? Math.max(0, evidence.acceptedTaskStartCount)
+    : Number.isInteger(options.acceptedTaskStartCount)
+      ? Math.max(0, options.acceptedTaskStartCount)
+      : task?.taskRunId ? 1 : 0;
+  if (tasks.length <= 1) {
+    const starts = Array.isArray(evidence?.starts) ? evidence.starts : [];
+    const structuredBindingValid = !evidence || (
+      starts.length === 1
+      && starts[0]?.taskRunId === task?.taskRunId
+      && Number(evidence.conflictingTaskTurnCount ?? 0) === 0
+      && Number(evidence.duplicateTurnCount ?? 0) === 0
+    );
+    return {
+      acceptedTaskStartCount,
+      passed: acceptedTaskStartCount === 1 && structuredBindingValid,
+      checkId: "single-task-start"
+    };
+  }
+  const starts = Array.isArray(evidence?.starts) ? evidence.starts : [];
+  const expectedTaskRunIds = uniqueSorted(tasks.map((item) => item?.taskRunId).filter(Boolean));
+  const observedTaskRunIds = uniqueSorted(starts.map((item) => item?.taskRunId).filter(Boolean));
+  const expectedTurnCount = Number.isInteger(options.expectedTurnCount) && options.expectedTurnCount > 0
+    ? options.expectedTurnCount
+    : undefined;
+  const distinctTurnCount = Number.isInteger(evidence?.distinctTurnCount) ? evidence.distinctTurnCount : 0;
+  const missingTurnIdCount = Number.isInteger(evidence?.missingTurnIdCount) ? evidence.missingTurnIdCount : acceptedTaskStartCount;
+  const conflictingTaskTurnCount = Number.isInteger(evidence?.conflictingTaskTurnCount) ? evidence.conflictingTaskTurnCount : acceptedTaskStartCount;
+  const duplicateTurnCount = Number.isInteger(evidence?.duplicateTurnCount) ? evidence.duplicateTurnCount : acceptedTaskStartCount;
+  return {
+    acceptedTaskStartCount,
+    distinctTurnCount,
+    missingTurnIdCount,
+    conflictingTaskTurnCount,
+    duplicateTurnCount,
+    passed: Boolean(evidence)
+      && acceptedTaskStartCount > 0
+      && acceptedTaskStartCount === expectedTaskRunIds.length
+      && JSON.stringify(observedTaskRunIds) === JSON.stringify(expectedTaskRunIds)
+      && missingTurnIdCount === 0
+      && conflictingTaskTurnCount === 0
+      && duplicateTurnCount === 0
+      && distinctTurnCount === acceptedTaskStartCount
+      && (expectedTurnCount === undefined || acceptedTaskStartCount <= expectedTurnCount),
+    checkId: "turn-bounded-task-start"
+  };
+}
+
+export function evaluateWorkflowEvidence(taskOrTasks, changedFiles, toolNames = {}, options = {}) {
+  const tasks = normalizedTasks(taskOrTasks);
+  const task = tasks[0];
   const scenarioKind = options.scenarioKind ?? "source-change";
-  const planned = meaningfulVerifyCommands(task?.verifyCommands);
-  const verifyEvidence = Array.isArray(task?.verifyEvidence) ? task.verifyEvidence : [];
+  const evidenceTasks = scenarioKind === "read-only"
+    ? tasks
+    : tasks.filter((item) => item?.changeMode !== "read-only");
+  const planned = [...new Set(evidenceTasks
+    .flatMap((item) => meaningfulVerifyCommands(item?.verifyCommands))
+    .map((command) => command.trim()))];
+  const verifyEvidence = evidenceTasks.flatMap((item) => Array.isArray(item?.verifyEvidence) ? item.verifyEvidence : []);
   const latestConfiguredEvidence = planned.map((command) => latestObservedTaskEvidence(verifyEvidence, command));
   const terminalVerifierDigests = new Set(latestConfiguredEvidence
     .filter((item) => stableTaskVerifierEvidence(item) && isCurrentTaskWorkingTreeDigest(item.workingTreeDigest))
@@ -83,40 +170,41 @@ export function evaluateWorkflowEvidence(task, changedFiles, toolNames = {}, opt
   const passed = new Set(latestConfiguredEvidence
     .filter((item) => terminalVerifierDigest && item?.exitCode === 0 && item.workingTreeDigest === terminalVerifierDigest)
     .map((item) => item.command?.trim()));
-  const actual = [...new Set(changedFiles ?? [])].sort();
-  const claimed = [...new Set(task?.changedFiles ?? [])].sort();
-  const baselineFiles = Object.keys(plainObject(task?.baselineFileDigests) ? task.baselineFileDigests : {}).sort();
-  const finalFiles = Object.keys(plainObject(task?.finalFileDigests) ? task.finalFileDigests : {}).sort();
-  const baselineFileClaims = Array.isArray(task?.baselineChangedFiles) ? [...task.baselineChangedFiles].sort() : [];
-  const finalFileClaims = Array.isArray(task?.finalWorkingTreeFiles) ? [...task.finalWorkingTreeFiles].sort() : [];
-  const migrationReady = task?.workingTreeDigestMigration === undefined;
-  const rootTreeContractCurrent = task?.workingTreeDigestAlgorithm === "wt-content-v2"
-    && migrationReady
-    && Array.isArray(task?.baselineChangedFiles)
-    && Array.isArray(task?.finalWorkingTreeFiles)
-    && taskWorkingTreeSnapshotUsesCurrentAlgorithm(task?.baselineFileDigests)
-    && taskWorkingTreeSnapshotUsesCurrentAlgorithm(task?.finalFileDigests)
-    && JSON.stringify(baselineFiles) === JSON.stringify(baselineFileClaims)
-    && JSON.stringify(finalFiles) === JSON.stringify(finalFileClaims)
-    && JSON.stringify(finalFiles) === JSON.stringify(actual);
-  const finalTreeDigest = rootTreeContractCurrent ? taskWorkingTreeEvidenceDigest(task.finalFileDigests) : undefined;
-  const currentTreeEvidence = rootTreeContractCurrent
-    && (scenarioKind === "read-only" || (Boolean(terminalVerifierDigest) && terminalVerifierDigest === finalTreeDigest));
+  const actual = uniqueSorted(changedFiles ?? []);
+  const claimed = uniqueSorted(tasks.flatMap((item) => Array.isArray(item?.changedFiles) ? item.changedFiles : []));
+  const currentTreeCandidates = evidenceTasks
+    .map((item) => ({ task: item, ...taskTreeEvidence(item, actual) }))
+    .filter((item) => item.current);
+  const finalTreeDigest = scenarioKind === "read-only"
+    ? currentTreeCandidates[0]?.digest
+    : currentTreeCandidates.find((item) => item.digest === terminalVerifierDigest)?.digest;
+  const currentTreeEvidence = Boolean(finalTreeDigest)
+    && (scenarioKind === "read-only" || terminalVerifierDigest === finalTreeDigest);
   const taskStartCalls = Number(toolNames?.piagent_task_start ?? 0);
-  const acceptedTaskStartCount = Number.isInteger(options.acceptedTaskStartCount)
-    ? Math.max(0, options.acceptedTaskStartCount)
-    : task?.taskRunId ? 1 : 0;
-  const intakeMode = task?.intakeMode === "runtime" ? "runtime" : "model";
-  const acceptanceCriteria = Array.isArray(task?.acceptanceReceipt?.criteria) ? task.acceptanceReceipt.criteria : [];
+  const startChoreography = taskStartChoreography(tasks, task, options);
+  const intakeMode = tasks.length > 0 && tasks.every((item) => item?.intakeMode === "runtime") ? "runtime" : "model";
+  const acceptanceCriteria = evidenceTasks.flatMap((item) => Array.isArray(item?.acceptanceReceipt?.criteria) ? item.acceptanceReceipt.criteria : []);
   const criticalAcceptance = acceptanceCriteria.filter((criterion) => criterion?.priority === "critical");
-  const requireSemanticAcceptanceEvidence = semanticAcceptanceEvidenceRequired(task);
+  const requireSemanticAcceptanceEvidence = evidenceTasks.some(semanticAcceptanceEvidenceRequired);
   const runtimeManagedCalls = Object.entries(toolNames ?? {})
     .filter(([name]) => RUNTIME_MANAGED_BENCHMARK_TOOLS.has(name))
     .reduce((sum, [, count]) => sum + Number(count ?? 0), 0);
   const checks = [
-    { id: "session-bound-task", passed: Boolean(task?.schemaVersion === 2 && task.taskRunId && task.sessionId), weight: 1 },
-    { id: "terminal-completion", passed: task?.trace?.outcome === "completed", weight: 1 },
-    { id: "completed-work-plan", passed: Array.isArray(task?.workPlan) && task.workPlan.length > 0 && task.workPlan.every((step) => ["done", "skipped"].includes(step.status)), weight: 1 },
+    {
+      id: "session-bound-task",
+      passed: tasks.length > 0
+        && tasks.every((item) => item?.schemaVersion === 2 && item.taskRunId && item.sessionId)
+        && new Set(tasks.map((item) => item.sessionId)).size === 1,
+      weight: 1
+    },
+    { id: "terminal-completion", passed: tasks.length > 0 && tasks.every((item) => item?.trace?.outcome === "completed"), weight: 1 },
+    {
+      id: "completed-work-plan",
+      passed: tasks.length > 0 && tasks.every((item) => Array.isArray(item?.workPlan)
+        && item.workPlan.length > 0
+        && item.workPlan.every((step) => ["done", "skipped"].includes(step.status))),
+      weight: 1
+    },
     { id: "current-tree-evidence", passed: currentTreeEvidence, weight: 1 },
     scenarioKind === "read-only"
       ? { id: "truthful-no-changes", passed: actual.length === 0 && claimed.length === 0, weight: 1 }
@@ -139,11 +227,7 @@ export function evaluateWorkflowEvidence(task, changedFiles, toolNames = {}, opt
         weight: requireSemanticAcceptanceEvidence ? 1 : 0.25
       }
     ] : []),
-    {
-      id: "single-task-start",
-      passed: acceptedTaskStartCount === 1,
-      weight: 1
-    },
+    { id: startChoreography.checkId, passed: startChoreography.passed, weight: 1 },
     { id: "runtime-managed-evidence", passed: runtimeManagedCalls === 0, weight: 1 }
   ];
   const earned = checks.reduce((sum, check) => sum + (check.passed ? check.weight : 0), 0);
@@ -151,9 +235,23 @@ export function evaluateWorkflowEvidence(task, changedFiles, toolNames = {}, opt
   return {
     score: rounded(10 * earned / available, 2),
     checks,
-    choreography: { intakeMode, taskStartCalls, acceptedTaskStartCount, runtimeManagedCalls },
+    choreography: tasks.length <= 1
+      ? { intakeMode, taskStartCalls, acceptedTaskStartCount: startChoreography.acceptedTaskStartCount, runtimeManagedCalls }
+      : {
+          intakeMode,
+          taskStartCalls,
+          acceptedTaskStartCount: startChoreography.acceptedTaskStartCount,
+          runtimeManagedCalls,
+          taskCount: tasks.length,
+          distinctTaskStartTurns: startChoreography.distinctTurnCount,
+          missingTaskStartTurnIds: startChoreography.missingTurnIdCount,
+          conflictingTaskStartTurns: startChoreography.conflictingTaskTurnCount,
+          duplicateTaskStartTurns: startChoreography.duplicateTurnCount
+        },
     taskEvidence: {
-      outcome: task?.trace?.outcome ?? "missing",
+      outcome: tasks.length > 0 && tasks.every((item) => item?.trace?.outcome === "completed")
+        ? "completed"
+        : tasks.find((item) => item?.trace?.outcome !== "completed")?.trace?.outcome ?? "missing",
       acceptance: {
         criteria: acceptanceCriteria.length,
         satisfied: acceptanceCriteria.filter((criterion) => criterion?.status === "satisfied").length,

package/packages/piagent-core/benchmark/fs5-pilot-protocol.js

@@ -1,4 +1,17 @@
-const SHA256 = /^[a-f0-9]{64}$/;
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { benchmarkArtifactBindingErrors, benchmarkArtifactBindingShapeErrors } from "./benchmark-artifact-binding.js";
+
+const sourceRoot = path.resolve(import.meta.dirname, "../../..");
+// Historical expectations are immutable. Source evolution needs a new protocol,
+// not rebinding an old protocol identity to different bytes.
+const artifactBindingsDigests = Object.freeze({
+  1: "8e3d82197ea226f698b0aa83f63b39652f2d2ad775aad402a5b0462feb360853",
+  2: "494b2c1068f07eb0612c345ac518ee9bd510cd8f600a900d79d13b65553e7bbd",
+  3: "2d72c44b5b82b53f3f2af57ec55f25069cb1879e1be17ccccd7fdc1260feaf11",
+  4: "4a37903084120dbebb46ab926e94bbbaf287e17864c407b43c76c0d46fe2f128",
+  5: "5c64de2a50d19419a8ffd89e8c1bdaec1795a9352cbda4bcc8fd62bdf7322c86"
+});
 const stageIds = ["canary-a-fullstack", "canary-b-migration", "six-family-pilot"];
 const pilotScenarios = [
   "tenant-role-authorization", "stale-search-response", "quoted-csv",
@@ -53,8 +66,10 @@ export function fs5PilotProtocolValidationErrors(protocol) {
   }
   if (!Array.isArray(protocol.artifactBindings) || protocol.artifactBindings.length < 5) {
     errors.push("artifactBindings must bind the authority, suites and evidence schemas");
-  } else if (protocol.artifactBindings.some((item) => !record(item) || typeof item.id !== "string" || typeof item.path !== "string" || !SHA256.test(String(item.sha256)))) {
+  } else if (benchmarkArtifactBindingShapeErrors(protocol.artifactBindings).length) {
     errors.push("artifactBindings contain an invalid entry");
+  } else if (createHash("sha256").update(JSON.stringify(protocol.artifactBindings)).digest("hex") !== artifactBindingsDigests[protocol.schemaVersion]) {
+    errors.push("historical artifactBindings must not be rebound");
   }
   const identity = protocol.runIdentityContract ?? {};
   if (!Array.isArray(identity.required) || identity.required.length < 10 || identity.anyChangeInvalidatesRun !== true
@@ -169,6 +184,10 @@ export function fs5StageArguments(protocol, stageId, { mode = "dry-run", operato
   if (!stage) throw new Error(`Unknown FS5 protocol stage: ${stageId}`);
   if (!new Set(["dry-run", "preflight", "execute"]).has(mode)) throw new Error(`Unsupported FS5 stage mode: ${mode}`);
   if (mode === "execute" && operatorAuthorized !== true) throw new Error("FS5 provider execution requires explicit operator authorization");
+  if (mode !== "dry-run") {
+    const bindingErrors = benchmarkArtifactBindingErrors(protocol.artifactBindings, sourceRoot);
+    if (bindingErrors.length) throw new Error(`FS5 source binding refused: ${bindingErrors.join("; ")}`);
+  }
   const args = [
     "--suite", stage.suite,
     "--surfaces", `${protocol.comparison.candidateSurface},${protocol.comparison.baselineSurface}`,

package/packages/piagent-core/capabilities/runtime-integrity.js

@@ -132,6 +132,7 @@ export const CORE_RUNTIME_INTEGRITY_FILES = Object.freeze([
   "packages/piagent-core/runtime/registration/task-start-tool.ts",
   "packages/piagent-core/runtime/registration/workflow-commands.ts",
   "packages/piagent-core/runtime/runtime-limits.ts",
+  "packages/piagent-core/runtime/session/completion-signals.ts",
   "packages/piagent-core/runtime/session/message-signals.ts",
   "packages/piagent-core/runtime/session/model-authorship-state.ts",
   "packages/piagent-core/runtime/session/operator-request-carry.ts",
@@ -139,6 +140,7 @@ export const CORE_RUNTIME_INTEGRITY_FILES = Object.freeze([
   "packages/piagent-core/runtime/session/runtime-state.ts",
   "packages/piagent-core/runtime/session/system-prompt.ts",
   "packages/piagent-core/runtime/session/tool-result-compaction.ts",
+  "packages/piagent-core/runtime/session/uncertain-send-continuation.ts",
   "packages/piagent-core/runtime/session/usage.ts",
   "packages/piagent-core/runtime/solver/solver-types.ts",
   "packages/piagent-core/runtime/solver/task-features.ts",
@@ -153,6 +155,7 @@ export const CORE_RUNTIME_INTEGRITY_FILES = Object.freeze([
   "packages/piagent-core/runtime/trajectory/trajectory-runtime.ts",
   "packages/piagent-core/runtime/trajectory/trajectory-observability.ts",
   "packages/piagent-core/runtime/tools/tool-groups.ts",
+  "packages/piagent-core/runtime/workflows/change-clarification.ts",
   "packages/piagent-core/runtime/tools/phase-tools.ts",
   "packages/piagent-core/runtime/tools/phase-tool-runtime.ts",
   "packages/piagent-core/runtime/workflows/input-routing.ts",

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

@@ -0,0 +1,24 @@
+// Core consumes a reader supplied by the runtime composition root. It never
+// imports the runtime's private baseline store or grants proof without it.
+const apiClause = /^(?:keep|preserve|do\s+not\s+change)\s+(?:the\s+)?(?:(?:public|exported)\s+)?api(?:\s+unchanged)?(?:\s+and\s+(?:verify\s+(?:the\s+)?project|run\s+(?:the\s+)?configured\s+verification))?[.!;]?$/i;
+export const isApiPreservationCriterion = text => typeof text === "string" && apiClause.test(text.trim());
+
+export function apiBaselineCriterionEvidence(input) {
+  const index = input.task?.acceptanceReceipt?.criteria?.findIndex(item => item.id === input.criterion?.id) ?? -1;
+  if (!isApiPreservationCriterion(input.task?.acceptanceCriteria?.[index])) return { handled: false };
+  return typeof input.apiBaselineEvidence === "function" ? input.apiBaselineEvidence(input)
+    : { handled: true, reason: "api-baseline-reader-unavailable" };
+}
+
+export function apiBaselineRecoveryProjection(input) {
+  const result = apiBaselineCriterionEvidence(input);
+  if (!result.handled || result.evidence) return { handled: result.handled };
+  const changed = ["api-contract-changed", "api-unrelated-implementation-changed"].includes(result.reason);
+  return { handled: true, projection: {
+    criterionId: input.criterion.id, criterionHash: input.criterion.hash,
+    criterionText: input.criterionText, targets: [], missingDimensions: [result.reason],
+    proofHints: [changed
+      ? "The task-start comparison found a changed public contract or an unrequested implementation change. Inspect that difference; do not waive the API requirement."
+      : "API baseline proof is unavailable or unsupported at the recorded boundary. Restore current task-bound evidence or obtain an approved assessment; this is not an observed source defect."]
+  } };
+}

package/packages/piagent-core/extensions/acceptance-assessment.js

@@ -0,0 +1,153 @@
+import { isCurrentWorkingTreeDigest } from "./working-tree-digest.js";
+
+export const ACCEPTANCE_ASSESSMENT_VERSION = "contract-assessment-v1";
+const HASH = /^[a-f0-9]{64}$/;
+const ID = /^[a-zA-Z0-9][a-zA-Z0-9:._-]{0,159}$/;
+const STATUSES = new Set(["pass", "fail", "unknown", "error"]);
+const COMPLETIONS = new Set(["completed", "timeout", "crashed", "cancelled"]);
+const MAX_CHECKS = 256;
+
+function record(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw new TypeError(`Invalid ${label}`);
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string" || !("value" in descriptors[key]))) {
+    throw new TypeError(`Invalid ${label} properties`);
+  }
+  return value;
+}
+
+function identifier(value, label) {
+  if (typeof value !== "string" || !ID.test(value)) throw new TypeError(`Invalid ${label}`);
+  return value;
+}
+
+function hash(value, label) {
+  if (typeof value !== "string" || !HASH.test(value)) throw new TypeError(`Invalid ${label}`);
+  return value;
+}
+
+function tree(value, label) {
+  if (!isCurrentWorkingTreeDigest(value)) throw new TypeError(`Invalid ${label}`);
+  return value;
+}
+
+function denseArray(value, label, allowEmpty = true) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype
+    || value.length > MAX_CHECKS || (!allowEmpty && value.length === 0)) throw new TypeError(`Invalid ${label}`);
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(descriptors).length !== value.length + 1) throw new TypeError(`Invalid ${label} properties`);
+  const copy = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const descriptor = descriptors[index];
+    if (!descriptor || !("value" in descriptor)) throw new TypeError(`Invalid ${label} entry`);
+    copy.push(descriptor.value);
+  }
+  return copy;
+}
+
+function contractSnapshot(input) {
+  record(input, "assessment contract");
+  const requiredCheckIds = denseArray(input.requiredCheckIds, "required checks", false).map((value) => identifier(value, "check id"));
+  if (new Set(requiredCheckIds).size !== requiredCheckIds.length) throw new TypeError("Duplicate required check");
+  return Object.freeze({
+    taskRunId: identifier(input.taskRunId, "task run id"),
+    criterionHash: hash(input.criterionHash, "criterion hash"),
+    workingTreeDigest: tree(input.workingTreeDigest, "working tree digest"),
+    verifierDigest: hash(input.verifierDigest, "verifier digest"),
+    requiredCheckIds: Object.freeze(requiredCheckIds)
+  });
+}
+
+function observedCheck(input, required) {
+  record(input, "observed check");
+  const id = identifier(input.id, "observed check id");
+  if (!required.has(id) || !STATUSES.has(input.status)
+    || !Number.isSafeInteger(input.caseCount) || input.caseCount < 0
+    || (["pass", "fail"].includes(input.status) && input.caseCount === 0)) throw new TypeError("Invalid observed check result");
+  const counterexampleRef = input.counterexampleRef === undefined || input.counterexampleRef === null ? null : hash(input.counterexampleRef, "counterexample reference");
+  if ((input.status === "fail") !== (counterexampleRef !== null)) throw new TypeError("Counterexample must identify a failed check");
+  return Object.freeze({ id, status: input.status, caseCount: input.caseCount, counterexampleRef });
+}
+
+function result(verdict, action, reasons, options = {}) {
+  return Object.freeze({
+    schemaVersion: 1,
+    policyVersion: ACCEPTANCE_ASSESSMENT_VERSION,
+    verdict,
+    action,
+    completionAllowed: verdict === "pass",
+    // A decision never grants mutation authority; the recovery policy must
+    // additionally authorize a concrete repair and consume its durable budget.
+    repairEligible: verdict === "fail",
+    sourceMutationAllowed: false,
+    assurance: verdict === "pass" ? "bounded-contract-tested" : "none",
+    reasons: Object.freeze(reasons),
+    failedChecks: Object.freeze(options.failedChecks ?? []),
+    missingChecks: Object.freeze(options.missingChecks ?? [])
+  });
+}
+
+/**
+ * One-shot host-side assessment boundary. Only an approved executor may hold
+ * observeExecution. Neither method is a model tool or a candidate-code binding.
+ *
+ * A receipt is a live capability, not authenticated JSON: copies, deserialized
+ * objects, and receipts from another session are rejected. Durable admission
+ * must be implemented separately; this module never trusts a public digest as
+ * proof of who produced a receipt. It does not execute project JavaScript.
+ */
+export function createAcceptanceAssessmentSession(input) {
+  const contract = contractSnapshot(input);
+  const required = new Set(contract.requiredCheckIds);
+  const observations = new WeakMap();
+  let observed = false;
+
+  function observeExecution(input) {
+    if (observed) throw new Error("Assessment session already observed an execution");
+    record(input, "execution observation");
+    const runId = identifier(input.runId, "execution run id");
+    if (!COMPLETIONS.has(input.completion)) {
+      throw new TypeError("Invalid execution observation");
+    }
+    const checks = denseArray(input.checks, "observed checks").map((check) => observedCheck(check, required));
+    if (new Set(checks.map((check) => check.id)).size !== checks.length) throw new TypeError("Duplicate observed check");
+    const snapshot = Object.freeze({
+      taskRunId: identifier(input.taskRunId, "observed task run id"),
+      criterionHash: hash(input.criterionHash, "observed criterion hash"),
+      verifierDigest: hash(input.verifierDigest, "observed verifier digest"),
+      beforeWorkingTreeDigest: tree(input.beforeWorkingTreeDigest, "pre-execution tree"),
+      afterWorkingTreeDigest: tree(input.afterWorkingTreeDigest, "post-execution tree"),
+      completion: input.completion,
+      checks: Object.freeze(checks)
+    });
+    const receipt = Object.freeze({ schemaVersion: 1, runId, ...snapshot });
+    observations.set(receipt, snapshot);
+    observed = true;
+    return receipt;
+  }
+
+  function assess({ receipt, currentWorkingTreeDigest, policy = "unknown", projectVerifierCurrent = false } = {}) {
+    if (policy !== "allow") return result("unknown", "resolve-policy", [policy === "deny" ? "policy-denied" : "policy-unestablished"]);
+    if (!isCurrentWorkingTreeDigest(currentWorkingTreeDigest) || currentWorkingTreeDigest !== contract.workingTreeDigest) {
+      return result("unknown", "reverify-current-tree", ["current-tree-mismatch"]);
+    }
+    if (projectVerifierCurrent !== true) return result("unknown", "run-project-verifier", ["current-project-verifier-missing"]);
+    const observation = receipt && typeof receipt === "object" ? observations.get(receipt) : undefined;
+    if (!observation) return result("unknown", "run-independent-verifier", [receipt == null ? "independent-observation-missing" : "untrusted-observation"]);
+    if (observation.taskRunId !== contract.taskRunId || observation.criterionHash !== contract.criterionHash
+      || observation.verifierDigest !== contract.verifierDigest) return result("unknown", "reverify-contract", ["observation-binding-mismatch"]);
+    if (observation.beforeWorkingTreeDigest !== contract.workingTreeDigest
+      || observation.afterWorkingTreeDigest !== contract.workingTreeDigest) return result("unknown", "reverify-current-tree", ["execution-tree-mismatch"]);
+    if (observation.completion !== "completed") return result("error", "diagnose-executor", [`executor-${observation.completion}`]);
+    if (observation.checks.some((check) => check.status === "error")) return result("error", "diagnose-executor", ["check-execution-error"]);
+    const failedChecks = observation.checks.filter((check) => check.status === "fail").map((check) => check.id);
+    if (failedChecks.length) return result("fail", "repair-counterexample", ["observed-contract-counterexample"], { failedChecks });
+    const passed = new Set(observation.checks.filter((check) => check.status === "pass").map((check) => check.id));
+    const missingChecks = contract.requiredCheckIds.filter((id) => !passed.has(id));
+    if (missingChecks.length) return result("unknown", "complete-verification", ["required-check-coverage-missing"], { missingChecks });
+    return result("pass", "accept-covered-contract", ["all-required-checks-observed"]);
+  }
+
+  return Object.freeze({ contract, observeExecution, assess });
+}

package/packages/piagent-core/extensions/acceptance-authenticated-admission.d.ts

@@ -0,0 +1,41 @@
+export const AUTHENTICATED_ADMISSION_VERSION: "authenticated-acceptance-admission-v1";
+export type AuthenticatedAssessment = Readonly<{
+  version: typeof AUTHENTICATED_ADMISSION_VERSION;
+  verdict: "pass" | "fail" | "unknown" | "error";
+  completionAllowed: boolean;
+  repairEligible: boolean;
+  sourceMutationAllowed: false;
+  assurance: "none" | "bounded-contract-tested";
+  reasons: readonly string[];
+  failedChecks: readonly string[];
+  missingChecks: readonly string[];
+  attemptId?: string;
+  criterionId?: string;
+  factId?: string;
+  taskRunId?: string;
+  criterionHash?: string;
+  sourcePath?: string;
+  sourcePaths?: readonly string[];
+  workingTreeDigest?: string;
+  snapshotDigest?: string;
+  projectVerificationDigest?: string;
+  contractVersion?: string;
+  profileDigest?: string;
+  planDigest?: string;
+  backendDigest?: string;
+  checks?: readonly Readonly<{ id: string; status: "pass" | "fail" | "unknown" | "error";
+    caseCount: number; counterexampleRef?: string }> [];
+  executionDiagnostics?: Readonly<{
+    status: "completed" | "timeout" | "cancelled" | "error";
+    cleanupConfirmed: boolean; reasons: readonly string[];
+    unsupportedCaseCount: number; errorCaseCount: number;
+  }>;
+  counterexamples?: readonly Readonly<{ digest: string; evidence: Readonly<{
+    checkId: string; input: unknown; expected: unknown; observed: unknown;
+  }> }>[];
+}>;
+export function unavailableAuthenticatedAssessment(reason: string): AuthenticatedAssessment;
+export function currentAuthenticatedAssessment(receipt: unknown, current: {
+  taskRunId: string; criterionId: string; criterionHash: string;
+  workingTreeDigest: string; projectVerificationDigest: string | null; factId?: string; policy?: string;
+}): AuthenticatedAssessment | null;

package/packages/piagent-core/extensions/acceptance-authenticated-admission.js

@@ -0,0 +1,120 @@
+import { createHash } from "node:crypto";
+import { createAcceptanceAssessmentSession } from "./acceptance-assessment.js";
+import { FACT_EVIDENCE_SCOPE_VERSION, isAcceptanceEvidenceStore } from "./acceptance-evidence-store.js";
+import { captureExecutionSnapshot, snapshotPlanSource } from "./acceptance-execution-snapshot.js";
+import { compileIndependentContract, compareIndependentExecution } from "./acceptance-independent-contract.js";
+import { parseRequest, parseResponse } from "./acceptance-executor/protocol.mjs";
+import { executionDiagnostics } from "./acceptance-execution-diagnostics.js";
+
+export const AUTHENTICATED_ADMISSION_VERSION = "authenticated-acceptance-admission-v1";
+const receipts = new WeakMap();
+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;
+};
+
+export function unavailableAuthenticatedAssessment(reason) {
+  return freeze({ version: AUTHENTICATED_ADMISSION_VERSION, verdict: "unknown", completionAllowed: false,
+    repairEligible: false, sourceMutationAllowed: false, assurance: "none", reasons: [reason], failedChecks: [], missingChecks: [] });
+}
+
+/** Host-only factory. Only a branded, authenticated store can admit evidence. */
+export function createAuthenticatedAdmission({ store, snapshotRequest, verifierDigest, imageId, exportName, checks, profile }) {
+  const nodeProfile = profile !== undefined;
+  const plan = source => ({ schemaVersion: nodeProfile ? 2 : 1, ...(nodeProfile ? { profile } : {}), ...source, exportName, checks });
+  const approved = compileIndependentContract(JSON.stringify(plan({ source: "export const placeholder=0;" })));
+  function issue({ scope, binding, event, expectedChecks }) {
+    if (!isAcceptanceEvidenceStore(store)) return unavailableAuthenticatedAssessment("untrusted-evidence-store");
+    const current = store.latest(scope);
+    if (!current || current.phase !== "settled" || current.attemptId !== event.attemptId || current.sequence !== event.sequence
+      || JSON.stringify(current.binding) !== JSON.stringify(binding)) return unavailableAuthenticatedAssessment("latest-evidence-changed");
+    // Read authenticated bytes, never the caller's diagnostic result object.
+    const evidence = JSON.parse(current.evidenceText), observed = evidence.observed, result = observed?.result;
+    const snapshot = captureExecutionSnapshot(snapshotRequest);
+    const compiled = compileIndependentContract(JSON.stringify({ ...plan(snapshotPlanSource(snapshot)), checks: approved.plan.checks }));
+    if (snapshot.snapshotDigest !== binding.snapshotDigest || evidence.snapshotDigest !== binding.snapshotDigest
+      || evidence.planDigest !== binding.planDigest || observed?.snapshotDigest !== binding.snapshotDigest
+      || result?.version !== approved.version || result.planDigest !== binding.planDigest
+      || result.execution?.runId !== current.attemptId || result.execution.sourceDigest !== snapshot.binding.sourceDigest
+      || result.execution.imageId !== imageId || compiled.planDigest !== binding.planDigest
+      || result.execution.requestDigest !== hash(compiled.requestText)
+      || nodeProfile && result.execution.profileDigest !== approved.plan.profile.digest) {
+      return unavailableAuthenticatedAssessment("execution-admission-binding-mismatch");
+    }
+    if (result.execution.observation) {
+      const response = parseResponse(JSON.stringify(result.execution.observation), parseRequest(compiled.requestText), result.execution.requestDigest);
+      if (response.status !== result.execution.status) return unavailableAuthenticatedAssessment("execution-observation-status-conflict");
+    } else if (result.execution.status === "completed") return unavailableAuthenticatedAssessment("execution-observation-missing");
+    const compared = compareIndependentExecution(compiled, result.execution);
+    if (compared.verdict !== result.verdict || JSON.stringify(compared.checks) !== JSON.stringify(result.checks)
+      || JSON.stringify(compared.counterexamples) !== JSON.stringify(result.counterexamples)) {
+      return unavailableAuthenticatedAssessment("execution-comparison-conflict");
+    }
+    if (!Array.isArray(result.checks) || result.checks.length !== expectedChecks.length || !Array.isArray(result.counterexamples)) {
+      return unavailableAuthenticatedAssessment("execution-admission-coverage-missing");
+    }
+    const counterexamples = new Map(result.counterexamples.map((item) => [item.digest, item.evidence]));
+    for (const expected of expectedChecks) {
+      const check = result.checks.find((item) => item.id === expected.id);
+      if (!check || !Number.isSafeInteger(check.caseCount) || check.caseCount < 0 || check.caseCount > expected.caseCount
+        || (check.status === "pass" && check.caseCount !== expected.caseCount)) return unavailableAuthenticatedAssessment("execution-admission-case-count-mismatch");
+      if (check.status === "fail") {
+        const example = counterexamples.get(check.counterexampleRef);
+        if (!example || hash(JSON.stringify(example)) !== check.counterexampleRef || example.checkId !== check.id
+          || example.runId !== current.attemptId || example.planDigest !== binding.planDigest
+          || example.sourceDigest !== snapshot.binding.sourceDigest || example.imageId !== imageId) {
+          return unavailableAuthenticatedAssessment("execution-admission-counterexample-missing");
+        }
+      }
+    }
+    const session = createAcceptanceAssessmentSession({ taskRunId: scope.taskRunId, criterionHash: binding.criterionHash,
+      workingTreeDigest: snapshot.binding.workingTreeDigest, verifierDigest, requiredCheckIds: expectedChecks.map((check) => check.id) });
+    const diagnostic = executionDiagnostics(result);
+    // Non-completed execution or uncertain cleanup can be authenticated as a
+    // diagnostic, but never as completion or source-repair evidence.
+    const completion = !diagnostic.cleanupConfirmed || diagnostic.status === "error" ? "crashed" : diagnostic.status;
+    const receipt = session.observeExecution({ runId: current.attemptId, taskRunId: scope.taskRunId, criterionHash: binding.criterionHash,
+      verifierDigest, beforeWorkingTreeDigest: snapshot.binding.workingTreeDigest, afterWorkingTreeDigest: snapshot.binding.workingTreeDigest,
+      completion, checks: result.checks });
+    const assessment = session.assess({ receipt, currentWorkingTreeDigest: snapshot.binding.workingTreeDigest, policy: "allow", projectVerifierCurrent: true });
+    if (assessment.verdict !== evidence.verdict || assessment.verdict !== observed.verdict || assessment.verdict !== result.verdict) {
+      return unavailableAuthenticatedAssessment("execution-admission-verdict-conflict");
+    }
+    const admitted = freeze({ ...assessment, reasons: [...new Set([...assessment.reasons, ...diagnostic.reasons])],
+      executionDiagnostics: diagnostic, version: AUTHENTICATED_ADMISSION_VERSION, attemptId: current.attemptId,
+      criterionId: scope.criterionId, taskRunId: scope.taskRunId, criterionHash: binding.criterionHash,
+      ...(scope.version === FACT_EVIDENCE_SCOPE_VERSION ? { factId: scope.factId } : {}),
+      sourcePath: snapshot.binding.sourcePath, workingTreeDigest: snapshot.binding.workingTreeDigest,
+      contractVersion: approved.version, ...(nodeProfile ? { profileDigest: approved.plan.profile.digest } : {}),
+      planDigest: binding.planDigest, backendDigest: binding.backendDigest,
+      checks: result.checks.map((check) => ({ id: check.id, status: check.status, caseCount: check.caseCount,
+        ...(check.counterexampleRef ? { counterexampleRef: check.counterexampleRef } : {}) })),
+      ...(snapshot.binding.moduleFiles ? { sourcePaths: snapshot.binding.moduleFiles.map((file) => file.sourcePath) } : {}),
+      snapshotDigest: binding.snapshotDigest, projectVerificationDigest: binding.projectVerificationDigest,
+      counterexamples: result.checks.filter((check) => assessment.verdict === "fail" && check.status === "fail").map((check) => ({
+        digest: check.counterexampleRef, evidence: counterexamples.get(check.counterexampleRef)
+      })) });
+    receipts.set(admitted, { store, snapshotRequest, scope: { ...scope }, binding: { ...binding }, sequence: current.sequence,
+      attemptId: current.attemptId, evidenceDigest: hash(current.evidenceText) });
+    return admitted;
+  }
+  return Object.freeze({ issue });
+}
+
+/** A serialized/cross-instance receipt is never completion or repair authority. */
+export function currentAuthenticatedAssessment(receipt, { taskRunId, criterionId, criterionHash, workingTreeDigest,
+  projectVerificationDigest, factId, policy = "unknown" } = {}) {
+  const owned = receipt && typeof receipt === "object" ? receipts.get(receipt) : undefined;
+  if (!owned || policy !== "allow" || owned.scope.taskRunId !== taskRunId || owned.scope.criterionId !== criterionId
+    || (owned.scope.version === FACT_EVIDENCE_SCOPE_VERSION ? owned.scope.factId !== factId : factId !== undefined)
+    || owned.binding.criterionHash !== criterionHash || owned.binding.projectVerificationDigest !== projectVerificationDigest) return null;
+  try {
+    const latest = owned.store.latest(owned.scope);
+    if (latest?.phase !== "settled" || latest.attemptId !== owned.attemptId || latest.sequence !== owned.sequence
+      || JSON.stringify(latest.binding) !== JSON.stringify(owned.binding) || hash(latest.evidenceText) !== owned.evidenceDigest) return null;
+    const source = captureExecutionSnapshot(owned.snapshotRequest);
+    if (source.snapshotDigest !== owned.binding.snapshotDigest || source.binding.workingTreeDigest !== workingTreeDigest) return null;
+    return receipt;
+  } catch { return null; }
+}