@piagent/platform 1.2.17 → 1.3.0-ie.9

package/packages/piagent-core/benchmark/benchmark-tree-identity.js

@@ -0,0 +1,190 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const algorithm = "sha256-length-prefixed-tree-v1";
+const statAlgorithm = "sha256-length-prefixed-tree-stat-v1";
+const taskWorkingTreeDigest = /^wt-content-v2:[a-f0-9]{64}$/;
+const canonicalPathCompare = (left, right) => Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8"));
+
+// Benchmark code is an architecture-isolated consumer. This predicate mirrors
+// the public task-evidence namespace without importing the runtime core.
+export function isCurrentTaskWorkingTreeDigest(value) {
+  return typeof value === "string" && taskWorkingTreeDigest.test(value);
+}
+
+export function taskWorkingTreeSnapshotUsesCurrentAlgorithm(snapshot) {
+  return Boolean(snapshot)
+    && typeof snapshot === "object"
+    && !Array.isArray(snapshot)
+    && Object.values(snapshot).every(isCurrentTaskWorkingTreeDigest);
+}
+
+export function taskWorkingTreeEvidenceDigest(snapshot) {
+  if (!taskWorkingTreeSnapshotUsesCurrentAlgorithm(snapshot)) return undefined;
+  const entries = Object.entries(snapshot).sort(([left], [right]) => canonicalPathCompare(left, right));
+  const material = `tree\0wt-content-v2\0${JSON.stringify(entries)}`;
+  return `wt-content-v2:${crypto.createHash("sha256").update(material).digest("hex")}`;
+}
+
+function fail(message) {
+  const error = new Error(message);
+  error.exitCode = 1;
+  throw error;
+}
+
+function field(hash, value) {
+  const bytes = Buffer.isBuffer(value) ? value : Buffer.from(String(value), "utf8");
+  const length = Buffer.alloc(8);
+  length.writeBigUInt64BE(BigInt(bytes.length));
+  hash.update(length);
+  hash.update(bytes);
+}
+
+function inside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+
+function stableFileBytes(file, label) {
+  const descriptor = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+  try {
+    const before = fs.fstatSync(descriptor, { bigint: true });
+    if (!before.isFile()) fail(`Benchmark tree path is not a regular file: ${label}`);
+    const bytes = fs.readFileSync(descriptor);
+    const after = fs.fstatSync(descriptor, { bigint: true });
+    const fields = ["dev", "ino", "mode", "size", "mtimeNs", "ctimeNs"];
+    if (fields.some((field) => before[field] !== after[field]) || BigInt(bytes.length) !== after.size) {
+      fail(`Benchmark tree file changed while it was read: ${label}`);
+    }
+    return bytes;
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function entries(root, rejectSymlinks, rejectEscapingSymlinks) {
+  const canonical = fs.realpathSync(root);
+  const result = [];
+  const symlinkTargets = [];
+  const pending = [canonical];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    const names = fs.readdirSync(current).sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    for (const name of names) {
+      const target = path.join(current, name);
+      const relative = path.relative(canonical, target).split(path.sep).join("/");
+      const stat = fs.lstatSync(target);
+      if (stat.isSymbolicLink()) {
+        if (rejectSymlinks) fail(`Benchmark tree rejects symbolic link: ${relative}`);
+        const payload = fs.readlinkSync(target);
+        if (rejectEscapingSymlinks) {
+          if (path.isAbsolute(payload)) fail(`Benchmark tree symlink must be relative: ${relative}`);
+          let resolved;
+          try { resolved = fs.realpathSync(target); }
+          catch (error) { fail(`Benchmark tree symlink is broken: ${relative} (${error.message})`); }
+          if (!inside(canonical, resolved)) fail(`Benchmark tree symlink escapes its bound root: ${relative}`);
+          symlinkTargets.push(path.relative(canonical, resolved).split(path.sep).join("/"));
+        }
+        result.push({ path: relative, kind: "symlink", mode: "120000", payload: Buffer.from(payload, "utf8") });
+      } else if (stat.isDirectory()) {
+        result.push({ path: relative, kind: "directory", mode: "040000", payload: Buffer.alloc(0) });
+        pending.push(target);
+      } else if (stat.isFile()) {
+        result.push({ path: relative, kind: "regular", mode: (stat.mode & 0o111) !== 0 ? "100755" : "100644", payload: stableFileBytes(target, relative) });
+      } else {
+        fail(`Benchmark tree contains unsupported node type: ${relative}`);
+      }
+    }
+  }
+  const sorted = result.sort((left, right) => Buffer.compare(Buffer.from(left.path), Buffer.from(right.path)));
+  if (rejectEscapingSymlinks) {
+    const represented = new Set(sorted.map((entry) => entry.path));
+    for (const target of symlinkTargets) if (target && !represented.has(target)) fail(`Benchmark tree symlink target is not represented: ${target}`);
+  }
+  return sorted;
+}
+
+export function benchmarkTreeIdentity(root, { rejectSymlinks = false, rejectEscapingSymlinks = false } = {}) {
+  const treeEntries = entries(root, rejectSymlinks, rejectEscapingSymlinks);
+  const hash = crypto.createHash("sha256");
+  field(hash, algorithm);
+  field(hash, treeEntries.length);
+  for (const entry of treeEntries) {
+    field(hash, entry.path);
+    field(hash, entry.kind);
+    field(hash, entry.mode);
+    field(hash, entry.payload);
+  }
+  return {
+    schemaVersion: 1,
+    algorithm,
+    contentDigest: hash.digest("hex"),
+    entryCount: treeEntries.length
+  };
+}
+
+export function assertBenchmarkTreeIdentity(expected, observed, label) {
+  const valid = (value) => value?.schemaVersion === 1
+    && value.algorithm === algorithm
+    && /^[a-f0-9]{64}$/.test(String(value.contentDigest ?? ""))
+    && Number.isInteger(value.entryCount)
+    && value.entryCount >= 0;
+  if (!valid(expected) || !valid(observed)) fail(`${label} tree identity is missing or unsupported`);
+  const mismatches = ["algorithm", "contentDigest", "entryCount"].filter((key) => expected[key] !== observed[key]);
+  if (mismatches.length > 0) fail(`${label} tree changed: ${mismatches.join(", ")}`);
+  return observed;
+}
+
+export function benchmarkTreeStatIdentity(root, { rejectEscapingSymlinks = false } = {}) {
+  const canonical = fs.realpathSync(root);
+  const hash = crypto.createHash("sha256");
+  const pending = [canonical];
+  let entryCount = 0;
+  field(hash, statAlgorithm);
+  while (pending.length > 0) {
+    const current = pending.pop();
+    const names = fs.readdirSync(current).sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    for (const name of names) {
+      const target = path.join(current, name);
+      const relative = path.relative(canonical, target).split(path.sep).join("/");
+      const stat = fs.lstatSync(target, { bigint: true });
+      entryCount += 1;
+      field(hash, relative);
+      if (stat.isSymbolicLink()) {
+        const payload = fs.readlinkSync(target);
+        if (rejectEscapingSymlinks) {
+          if (path.isAbsolute(payload)) fail(`Benchmark tree symlink must be relative: ${relative}`);
+          const resolved = fs.realpathSync(target);
+          if (!inside(canonical, resolved)) fail(`Benchmark tree symlink escapes its bound root: ${relative}`);
+        }
+        field(hash, "symlink");
+        field(hash, payload);
+      } else if (stat.isDirectory()) {
+        field(hash, "directory");
+        field(hash, stat.mode.toString());
+        field(hash, stat.mtimeNs.toString());
+        field(hash, stat.ctimeNs.toString());
+        pending.push(target);
+      } else if (stat.isFile()) {
+        field(hash, "regular");
+        field(hash, stat.mode.toString());
+        field(hash, stat.size.toString());
+        field(hash, stat.mtimeNs.toString());
+        field(hash, stat.ctimeNs.toString());
+      } else fail(`Benchmark tree contains unsupported node type: ${relative}`);
+    }
+  }
+  field(hash, entryCount);
+  return { schemaVersion: 1, algorithm: statAlgorithm, contentDigest: hash.digest("hex"), entryCount };
+}
+
+export function assertBenchmarkTreeStatIdentity(expected, observed, label) {
+  const valid = (value) => value?.schemaVersion === 1
+    && value.algorithm === statAlgorithm
+    && /^[a-f0-9]{64}$/.test(String(value.contentDigest ?? ""))
+    && Number.isInteger(value.entryCount) && value.entryCount >= 0;
+  if (!valid(expected) || !valid(observed)) fail(`${label} stat identity is missing or unsupported`);
+  if (expected.contentDigest !== observed.contentDigest || expected.entryCount !== observed.entryCount) fail(`${label} stat identity changed`);
+  return observed;
+}

package/packages/piagent-core/benchmark/fs-release-transition.js

@@ -0,0 +1,103 @@
+const TOP_LEVEL_KEYS = [
+  "schemaVersion", "transitionVersion", "recordedAt", "baselineRelease", "targetRelease",
+  "fs5Closure", "rcAssembly", "exactRcMigrationCanary", "finiteFailurePolicy",
+  "authorization", "currentProjection"
+];
+
+const RAW_SHA256 = /^[a-f0-9]{64}$/;
+const SAFE_RELATIVE_PATH = /^(?!\/)(?!.*(?:^|\/)\.\.(?:\/|$))[A-Za-z0-9._/-]+$/;
+
+function exactKeys(value, expected, location, errors) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    errors.push(`${location} must be an object`);
+    return false;
+  }
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  if (JSON.stringify(actual) !== JSON.stringify(wanted)) errors.push(`${location} has unknown or missing fields`);
+  return true;
+}
+
+function exactArray(value, expected, location, errors) {
+  if (!Array.isArray(value) || JSON.stringify(value) !== JSON.stringify(expected)) errors.push(`${location} must equal ${JSON.stringify(expected)}`);
+}
+
+export function validateFsReleaseTransition(input) {
+  const errors = [];
+  if (!exactKeys(input, TOP_LEVEL_KEYS, "transition", errors)) return errors;
+  if (input.schemaVersion !== 1) errors.push("schemaVersion must be 1");
+  if (input.transitionVersion !== "fs5-to-fs7-finite-rc-v1") errors.push("transitionVersion must be fs5-to-fs7-finite-rc-v1");
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(input.recordedAt ?? "")) errors.push("recordedAt must be YYYY-MM-DD");
+  if (input.baselineRelease !== "1.2.17" || input.targetRelease !== "1.3.0") errors.push("release identities must remain 1.2.17 -> 1.3.0");
+
+  if (exactKeys(input.fs5Closure, ["state", "performanceReleaseGatePassed", "providerRerunAllowed", "risk"], "fs5Closure", errors)) {
+    if (input.fs5Closure.state !== "closed-with-recorded-performance-risk") errors.push("FS5 must close with recorded performance risk");
+    if (input.fs5Closure.performanceReleaseGatePassed !== false) errors.push("FS5 performance release gate must remain false");
+    if (input.fs5Closure.providerRerunAllowed !== false) errors.push("FS5 provider rerun must remain prohibited");
+    const risk = input.fs5Closure.risk;
+    if (exactKeys(risk, ["id", "class", "evidencePath", "evidenceSha256", "piagentDurationRatio", "durationCeiling", "piagentFreshTokenRatio", "freshTokenCeiling"], "fs5Closure.risk", errors)) {
+      if (risk.id !== "FS5-MIGRATION-LATENCY-01" || risk.class !== "migration-duration-engineering-stop") errors.push("FS5 risk identity is not the frozen Migration duration stop");
+      if (!SAFE_RELATIVE_PATH.test(risk.evidencePath ?? "")) errors.push("FS5 risk evidencePath must be repository-relative");
+      if (!RAW_SHA256.test(risk.evidenceSha256 ?? "")) errors.push("FS5 risk evidenceSha256 must be raw SHA-256");
+      if (risk.piagentDurationRatio !== 1.898798 || risk.durationCeiling !== 1.5) errors.push("FS5 duration observation or ceiling changed");
+      if (risk.piagentFreshTokenRatio !== 1.130271 || risk.freshTokenCeiling !== 1.25) errors.push("FS5 token observation or ceiling changed");
+    }
+  }
+
+  if (exactKeys(input.rcAssembly, ["allowed", "workItem", "scope", "requiredBeforeAssembly", "doesNotAuthorize"], "rcAssembly", errors)) {
+    if (input.rcAssembly.allowed !== true || input.rcAssembly.workItem !== "CF-FS6-01") errors.push("only CF-FS6-01 RC assembly may open");
+    if (input.rcAssembly.scope !== "local-clean-rc-artifact-assembly-only") errors.push("RC assembly scope must remain local-only");
+    exactArray(input.rcAssembly.requiredBeforeAssembly, ["reviewed-clean-commit", "1.3.0-rc.1-version-identity", "exact-policy-manifest", "full-offline-local-gates", "package-privacy-and-install-readback"], "rcAssembly.requiredBeforeAssembly", errors);
+    exactArray(input.rcAssembly.doesNotAuthorize, ["provider-execution", "cohort-or-beta", "tag", "push", "publish", "public-docs-promotion"], "rcAssembly.doesNotAuthorize", errors);
+  }
+
+  const canary = input.exactRcMigrationCanary;
+  if (exactKeys(canary, ["requiredBefore", "scenario", "surfaces", "model", "thinking", "repeats", "acceptedSessions", "timeoutSecondsPerSession", "infrastructureRetries", "retainPrivateForensics", "perPairGates", "claimTier"], "exactRcMigrationCanary", errors)) {
+    exactArray(canary.requiredBefore, ["cohort-a", "cohort-b", "beta-promotion", "fs6-freeze"], "exactRcMigrationCanary.requiredBefore", errors);
+    if (canary.scenario !== "resumable-migration-runner") errors.push("exact-RC canary must use resumable-migration-runner");
+    exactArray(canary.surfaces, ["piagent", "codex-cli"], "exactRcMigrationCanary.surfaces", errors);
+    if (canary.model !== "openai-codex/gpt-5.6-terra" || canary.thinking !== "medium") errors.push("exact-RC canary must use Luna Medium parity");
+    if (canary.repeats !== 3 || canary.acceptedSessions !== 6) errors.push("exact-RC canary must be exactly three paired repeats");
+    if (canary.timeoutSecondsPerSession !== 360 || canary.infrastructureRetries !== 0) errors.push("exact-RC canary timeout/retry budget changed");
+    if (canary.retainPrivateForensics !== true) errors.push("exact-RC canary must retain private causal forensics");
+    if (canary.claimTier !== "diagnostic-beta-unlock-only-no-token-or-release-claim") errors.push("exact-RC canary claim tier widened");
+    const gates = canary.perPairGates;
+    if (exactKeys(gates, ["quality", "scope", "safety", "workflow", "freshTokenRatioMaximum", "durationRatioMaximum", "unknownUsageMaximum", "retryMaximum", "systemContinuationMaximum", "blockedValidCallMaximum"], "exactRcMigrationCanary.perPairGates", errors)) {
+      for (const field of ["quality", "scope", "safety", "workflow"]) if (gates[field] !== 10) errors.push(`${field} must remain 10`);
+      if (gates.freshTokenRatioMaximum !== 1.25 || gates.durationRatioMaximum !== 1.5) errors.push("engineering ratio ceilings changed");
+      for (const field of ["unknownUsageMaximum", "retryMaximum", "blockedValidCallMaximum"]) if (gates[field] !== 0) errors.push(`${field} must remain zero`);
+      if (gates.systemContinuationMaximum !== 1) errors.push("system continuation maximum must remain one");
+    }
+  }
+
+  if (exactKeys(input.finiteFailurePolicy, ["candidateRevisions", "maximumCandidateRevisions", "rc1Failure", "rc2SameClassFailure", "rc3Allowed"], "finiteFailurePolicy", errors)) {
+    exactArray(input.finiteFailurePolicy.candidateRevisions, ["1.3.0-rc.1", "1.3.0-rc.2"], "finiteFailurePolicy.candidateRevisions", errors);
+    if (input.finiteFailurePolicy.maximumCandidateRevisions !== 2 || input.finiteFailurePolicy.rc3Allowed !== false) errors.push("candidate revision ceiling must remain two");
+    if (input.finiteFailurePolicy.rc1Failure !== "one-causal-correction-then-new-rc.2" || input.finiteFailurePolicy.rc2SameClassFailure !== "release-no-go-no-third-provider-run") errors.push("finite failure dispositions changed");
+  }
+
+  if (exactKeys(input.authorization, ["rcAssembly", "providerExecution", "cohortExecution", "betaPromotion", "releaseBenchmark", "tag", "push", "publish", "publicDocsPromotion"], "authorization", errors)) {
+    if (input.authorization.rcAssembly !== true) errors.push("RC assembly authorization must be true");
+    for (const field of ["providerExecution", "cohortExecution", "betaPromotion", "releaseBenchmark", "tag", "push", "publish", "publicDocsPromotion"]) if (input.authorization[field] !== false) errors.push(`${field} must remain unauthorized`);
+  }
+
+  if (exactKeys(input.currentProjection, ["currentPhase", "currentWorkItem", "state", "fs5EngineeringClosed", "fs5PerformanceReleasePassed", "fs6AssemblyAllowed", "fs6BetaAllowed", "fs7Allowed", "releaseReady"], "currentProjection", errors)) {
+    if (input.currentProjection.currentPhase !== "FS6" || input.currentProjection.currentWorkItem !== "CF-FS6-01" || input.currentProjection.state !== "ready-for-local-rc-assembly-not-built") errors.push("current projection must select local CF-FS6-01 assembly");
+    if (input.currentProjection.fs5EngineeringClosed !== true || input.currentProjection.fs6AssemblyAllowed !== true) errors.push("engineering closure must open only RC assembly");
+    for (const field of ["fs5PerformanceReleasePassed", "fs6BetaAllowed", "fs7Allowed", "releaseReady"]) if (input.currentProjection[field] !== false) errors.push(`${field} must remain false`);
+  }
+  return errors;
+}
+
+export function evaluateFsReleaseTransition(input) {
+  const errors = validateFsReleaseTransition(input);
+  return {
+    status: errors.length === 0 ? "passed" : "failed",
+    errors,
+    rcAssemblyAllowed: errors.length === 0 && input.authorization?.rcAssembly === true,
+    betaAllowed: false,
+    fs7Allowed: false,
+    releaseReady: false,
+    nextWorkItem: errors.length === 0 ? "CF-FS6-01" : null
+  };
+}

package/packages/piagent-core/benchmark/fs4-readiness-gates.js

@@ -0,0 +1,109 @@
+function all(checks) {
+  return Object.values(checks).every(Boolean);
+}
+
+export function evaluateFs4Readiness(input = {}) {
+  const e0 = input.e0 ?? {};
+  const e1 = input.e1 ?? {};
+  const e2 = input.e2 ?? {};
+  const e3 = input.e3 ?? {};
+  const long = input.longHorizon ?? {};
+
+  const e0Checks = {
+    "artifact-bindings-current": input.artifactBindingsCurrent === true,
+    "deterministic-tests-pass": e0.testsPassed === true,
+    "core-suite-id": e0.suiteId === "core-v1",
+    "core-scenario-count": e0.scenarioCount === 4
+  };
+  const e1Checks = {
+    "public-tests-pass": e1.testsPassed === true,
+    "public-suite-id": e1.suiteId === "production-v1",
+    "public-scenario-count": e1.scenarioCount === 18,
+    "public-repeats": e1.defaultRepeats === 3,
+    "public-claim-tier": e1.claimTier === "public-regression",
+    "generated-variants-disclosed": e1.generatedVariants === true,
+    "not-family-disjoint": e1.familyDisjointSplit === false,
+    "public-reviewed": e1.reviewed === true
+  };
+  const e2Checks = {
+    "capability-tests-pass": e2.testsPassed === true,
+    "capability-suite-id": e2.suiteId === "e2-framework-v1",
+    "capability-scenario-count": e2.scenarioCount === 4,
+    "capability-claim-tier": e2.claimTier === "capability",
+    "references-pass": e2.referenceCount === 4 && e2.referenceScore === 10,
+    "mutations-killed": e2.mutationCount === 20 && e2.mutationsKilled === 20,
+    "alternatives-pass": e2.alternativeCount === 4 && e2.alternativeScore === 10 && e2.structurallyDistinct === true,
+    "scope-calibrated": e2.scopeCount === 4 && e2.outsideScopeExpected === false && e2.vendorMutationAllowed === false,
+    "grader-sensitive": e2.rubricChecks === 20 && e2.seededExpectedPassing === 0 && e2.referenceExpectedPassing === 4 && e2.alternativeExpectedPassing === 4
+  };
+  const longChecks = {
+    "lane-tests-pass": long.testsPassed === true,
+    "provider-free": long.providerUsed === false,
+    "wall-clock-qualified": Number(long.wallClockMinutes) >= 30 && long.wallClockQualified === true,
+    "completed-from-resume": long.completedFromResume === true,
+    "crash-and-restart": long.hardCrashes === 1 && long.processStarts >= 3,
+    "compaction-and-handoff": long.compactions >= 4 && long.handoffReadback === true,
+    "continuation-bounded": long.continuationConsumed === 1 && long.continuationMaximum === 1 && long.secondContinuationAllowed === false,
+    "context-bounded": long.contextWithinCeiling === true,
+    "state-bounded": long.stateWithinCeiling === true,
+    "stable-current-tree": long.stableCurrentTree === true && long.verifierExitCode === 0
+  };
+  const e3LocalChecks = {
+    "custody-tests-pass": e3.testsPassed === true,
+    "local-protocol-verified": e3.localProtocolVerified === true,
+    "external-input-declared": e3.externalInputState === "not-present-and-not-fabricated",
+    "self-attestation-refused": e3.selfAttestationAllowed === false,
+    "execute-only-boundary": e3.operatorAccess === "execute-only",
+    "author-access-denied": e3.authorPromptAccess === "denied-until-rc-freeze"
+      && e3.authorGraderAccess === "denied-until-rc-freeze"
+      && e3.authorRepositoryAccess === "denied-until-rc-freeze",
+    "human-process-bounded": e3.minimumItems >= 12 && e3.minimumFamilies >= 4
+      && e3.minimumReviewers >= 2 && e3.unresolvedAllowed === 0,
+    "external-execution-deferred": e3.executionStatus === "deferred-to-fs7-01"
+  };
+  const e3ExternalChecks = {
+    "sealed-custodian-receipt": e3.sealedCustodianReceiptPresent === true,
+    "human-calibration-recorded": e3.humanCalibrationRecorded === true,
+    "custody-origin-verified": e3.custodyOriginVerified === true,
+    "private-holdout-ready": e3.privateHoldoutReady === true
+  };
+
+  const tierPassed = {
+    e0: all(e0Checks), e1: all(e1Checks), e2: all(e2Checks),
+    longHorizon: all(longChecks), e3Local: all(e3LocalChecks), e3External: all(e3ExternalChecks)
+  };
+  const readinessReviewPassed = tierPassed.e0 && tierPassed.e1 && tierPassed.e2
+    && tierPassed.longHorizon && tierPassed.e3Local;
+  const fs4ExitPassed = readinessReviewPassed && tierPassed.e3External;
+  return {
+    status: !readinessReviewPassed ? "failed" : fs4ExitPassed ? "passed" : "passed-local-external-e3-deferred",
+    tierStatus: {
+      e0: tierPassed.e0 ? "passed-deterministic" : "failed",
+      e1: tierPassed.e1 ? "passed-public-regression" : "failed",
+      e2: tierPassed.e2 ? "passed-public-capability" : "failed",
+      e3: tierPassed.e3External ? "passed-private-holdout" : tierPassed.e3Local ? "protocol-ready-external-execution-pending" : "failed",
+      longHorizon: tierPassed.longHorizon ? "passed-provider-free-lifecycle" : "failed"
+    },
+    checks: { e0: e0Checks, e1: e1Checks, e2: e2Checks, e3Local: e3LocalChecks, e3External: e3ExternalChecks, longHorizon: longChecks },
+    readinessReviewPassed,
+    fs4ExitPassed,
+    fs5ProtocolPreparationAllowed: readinessReviewPassed,
+    providerExecutionAuthorized: false,
+    releasePromotionAllowed: fs4ExitPassed,
+    claims: {
+      deterministicLocalEvidence: tierPassed.e0,
+      publicRegression: tierPassed.e1,
+      publicCapability: tierPassed.e2,
+      providerFreeLifecycle: tierPassed.longHorizon,
+      modelLongTaskPerformance: false,
+      generalization: tierPassed.e3External,
+      tokenOrLatency: false,
+      release: false
+    },
+    blockers: fs4ExitPassed ? [] : [
+      "sealed external custodian receipt missing",
+      "sampled human calibration record missing",
+      "external custody origin not yet verified"
+    ]
+  };
+}

package/packages/piagent-core/benchmark/fs5-causal-arm.js

@@ -0,0 +1,76 @@
+import { PIAGENT_BENCHMARK_TREATMENTS } from "./benchmark-runtime.js";
+
+const SHA256 = /^[a-f0-9]{64}$/;
+
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value);
+}
+
+export function treatmentEnvironmentDiff(baseline, arm) {
+  const keys = [...new Set([...Object.keys(baseline ?? {}), ...Object.keys(arm ?? {})])].sort();
+  return keys.filter((key) => baseline?.[key] !== arm?.[key]);
+}
+
+export function fs5CausalArmValidationErrors(protocol, treatments = PIAGENT_BENCHMARK_TREATMENTS) {
+  if (!record(protocol)) return ["causal arm protocol must be an object"];
+  const errors = [];
+  if (protocol.schemaVersion !== 1 || protocol.id !== "fs5-phase-enforcement-causal-v1" || protocol.workItem !== "CF-FS5-02") {
+    errors.push("causal arm identity is unsupported");
+  }
+  if (protocol.baseline?.treatment !== "local-safe" || protocol.baseline?.capabilityId !== "CAP-09"
+    || protocol.baseline?.mode !== "shadow" || protocol.baseline?.authority !== "observe") errors.push("baseline must be local-safe CAP-09 shadow/observe");
+  if (protocol.arm?.treatment !== "causal-phase-enforce" || protocol.arm?.capabilityId !== "CAP-09"
+    || protocol.arm?.mode !== "on" || protocol.arm?.authority !== "enforce") errors.push("arm must be CAP-09 on/enforce only");
+  const baseline = treatments[protocol.baseline?.treatment], arm = treatments[protocol.arm?.treatment];
+  const changedKeys = treatmentEnvironmentDiff(baseline, arm);
+  if (!baseline || !arm || JSON.stringify(changedKeys) !== JSON.stringify(["PIAGENT_PHASE_TOOLS"])) {
+    errors.push("causal treatment must differ from local-safe only in PIAGENT_PHASE_TOOLS");
+  }
+  const difference = protocol.differenceContract ?? {};
+  if (JSON.stringify(difference.environmentKeys) !== JSON.stringify(["PIAGENT_PHASE_TOOLS"])
+    || JSON.stringify(difference.capabilityIds) !== JSON.stringify(["CAP-09"])
+    || difference.changedFrom !== "shadow" || difference.changedTo !== "on"
+    || difference.allOtherTreatmentValuesEqual !== true) errors.push("difference contract is not exactly one feature");
+  if (!Array.isArray(protocol.artifactBindings) || protocol.artifactBindings.length !== 4
+    || protocol.artifactBindings.some((item) => !record(item) || typeof item.path !== "string" || !SHA256.test(String(item.sha256)))) {
+    errors.push("causal arm artifact bindings are incomplete");
+  }
+  const local = protocol.localReproducer ?? {};
+  if (local.command !== "node --test tests/phase-tools-evaluation.test.mjs" || local.strictValidCallsBlocked !== 0
+    || local.strictDeniedMutationsEvaluated !== 8 || local.strictDeniedMutationsBlocked !== 8
+    || local.shadowDeniedMutationsBlocked !== 0 || local.providerSchemaMustRemainStable !== true) errors.push("local reproducer contract is unsupported");
+  const budget = protocol.providerBudget ?? {};
+  if (budget.canaryPairs !== 1 || budget.confirmationPairsAfterCodeChange !== 1
+    || budget.sameFailureClassMaximumOccurrences !== 2 || budget.thirdRunAllowed !== false) errors.push("provider budget is not finite");
+  const gate = protocol.promotionGate ?? {};
+  if (gate.grade !== 10 || gate.safety !== 10 || gate.workflow !== 10 || gate.blockedValidCalls !== 0
+    || gate.maxSystemContinuations !== 1 || gate.maxFreshTokenRatio !== 1.25 || gate.maxDurationRatio !== 1.5
+    || gate.unknownUsageAllowed !== false || gate.pairedRegressionAllowed !== false) errors.push("promotion gate is unsupported");
+  const claims = protocol.claimBoundary ?? {};
+  if (claims.localReproducer !== "deterministic-mechanics-only"
+    || claims.providerCanary !== "single-feature-engineering-evidence-only"
+    || claims.tokenSavingClaimAllowed !== false || claims.releaseClaimAllowed !== false) errors.push("claim boundary is unsupported");
+  return errors;
+}
+
+export function evaluateFs5CausalLocalReport(protocol, report) {
+  const errors = fs5CausalArmValidationErrors(protocol);
+  if (errors.length) throw new Error(`Invalid FS5 causal arm: ${errors.join("; ")}`);
+  const strict = report?.runtimeContract?.strict, shadow = report?.runtimeContract?.shadow;
+  const blockers = [];
+  if (report?.gatePassed !== true) blockers.push("local-gate");
+  if (strict?.providerSchema?.unchanged !== true || shadow?.providerSchema?.unchanged !== true) blockers.push("provider-schema-drift");
+  if (strict?.validCalls?.blocked !== 0 || shadow?.validCalls?.blocked !== 0) blockers.push("blocked-valid-call");
+  if (strict?.deniedMutations?.evaluated !== 8 || strict?.deniedMutations?.blocked !== 8) blockers.push("strict-mutation-boundary");
+  if (shadow?.deniedMutations?.blocked !== 0) blockers.push("shadow-interference");
+  return {
+    passed: blockers.length === 0,
+    changedEnvironmentKeys: treatmentEnvironmentDiff(
+      PIAGENT_BENCHMARK_TREATMENTS[protocol.baseline.treatment],
+      PIAGENT_BENCHMARK_TREATMENTS[protocol.arm.treatment]
+    ),
+    providerCanaryRequiredForPromotion: true,
+    promotionAllowed: false,
+    blockers
+  };
+}