frontend-project-context 1.3.1 → 1.7.0

package/schemas/truth-reconciliation-review-bundle.schema.json

@@ -0,0 +1,155 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "urn:frontend-project-context:schema:truth-reconciliation-review-bundle:2",
+  "title": "Frontend Project Context Truth Reconciliation Review Bundle",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "project", "current", "task", "inputDigest", "summary", "candidateOutcomes", "collisionGroups", "findings", "resolutionOutcomes", "guarantees", "boundaries", "bundleDigest"],
+  "properties": {
+    "schemaVersion": { "const": 2 },
+    "kind": { "const": "truth-reconciliation-review-bundle" },
+    "project": { "$ref": "#/$defs/project" },
+    "current": { "$ref": "#/$defs/current" },
+    "task": { "$ref": "#/$defs/task" },
+    "inputDigest": { "$ref": "#/$defs/digest" },
+    "summary": { "$ref": "#/$defs/summary" },
+    "candidateOutcomes": { "type": "array", "items": { "$ref": "#/$defs/candidateOutcome" } },
+    "collisionGroups": { "type": "array", "items": { "$ref": "#/$defs/collisionGroup" } },
+    "findings": { "type": "array", "items": { "$ref": "#/$defs/finding" } },
+    "resolutionOutcomes": { "type": "array", "items": { "$ref": "#/$defs/resolutionOutcome" } },
+    "guarantees": { "$ref": "#/$defs/guarantees" },
+    "boundaries": { "$ref": "#/$defs/boundaries" },
+    "bundleDigest": { "$ref": "#/$defs/digest" }
+  },
+  "$defs": {
+    "id": { "type": "string", "pattern": "^[a-z0-9]+(?:[.-][a-z0-9]+)*$" },
+    "text": { "type": "string", "minLength": 1 },
+    "digest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+    "nullableDigest": { "oneOf": [{ "$ref": "#/$defs/digest" }, { "type": "null" }] },
+    "nullableText": { "oneOf": [{ "$ref": "#/$defs/text" }, { "type": "null" }] },
+    "ids": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/id" } },
+    "paths": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
+    "scope": {
+      "oneOf": [
+        { "type": "object", "additionalProperties": false, "required": ["kind"], "properties": { "kind": { "const": "project" } } },
+        { "type": "object", "additionalProperties": false, "required": ["kind", "path"], "properties": { "kind": { "enum": ["path-prefix", "file"] }, "path": { "type": "string", "minLength": 1 } } }
+      ]
+    },
+    "scopes": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/scope" } },
+    "snapshots": {
+      "type": "object", "additionalProperties": false,
+      "required": ["contract", "sourcesLock", "projectionsLock"],
+      "properties": { "contract": { "$ref": "#/$defs/digest" }, "sourcesLock": { "$ref": "#/$defs/digest" }, "projectionsLock": { "$ref": "#/$defs/digest" } }
+    },
+    "project": {
+      "type": "object", "additionalProperties": false, "required": ["id", "name"],
+      "properties": { "id": { "$ref": "#/$defs/id" }, "name": { "$ref": "#/$defs/text" } }
+    },
+    "current": {
+      "type": "object", "additionalProperties": false, "required": ["revision", "projectSnapshots"],
+      "properties": { "revision": { "$ref": "#/$defs/text" }, "projectSnapshots": { "$ref": "#/$defs/snapshots" } }
+    },
+    "task": {
+      "type": "object", "additionalProperties": false, "required": ["id", "paths"],
+      "properties": { "id": { "$ref": "#/$defs/id" }, "paths": { "$ref": "#/$defs/paths" } }
+    },
+    "summary": {
+      "type": "object", "additionalProperties": false,
+      "required": ["candidates", "eligibleCandidates", "collisionGroups", "findings", "taskHealth", "globalHealth", "existingDelivery"],
+      "properties": {
+        "candidates": { "type": "integer", "minimum": 0 },
+        "eligibleCandidates": { "type": "integer", "minimum": 0 },
+        "collisionGroups": { "type": "integer", "minimum": 0 },
+        "findings": { "type": "integer", "minimum": 0 },
+        "taskHealth": { "enum": ["ready", "blocked"] },
+        "globalHealth": { "enum": ["clean", "attention"] },
+        "existingDelivery": { "const": "not-blocked" }
+      }
+    },
+    "promotionEvidence": {
+      "type": "object", "additionalProperties": false,
+      "required": ["assurance", "currentEvidenceCount", "staleEvidenceCount", "localQaReusable", "integrationVerified"],
+      "properties": {
+        "assurance": { "const": "host-asserted" },
+        "currentEvidenceCount": { "type": "integer", "minimum": 0 },
+        "staleEvidenceCount": { "type": "integer", "minimum": 0 },
+        "localQaReusable": { "type": "boolean" },
+        "integrationVerified": { "type": "boolean" }
+      }
+    },
+    "candidateOutcome": {
+      "type": "object", "additionalProperties": false,
+      "required": ["candidateId", "lifecycle", "baseline", "promotionEvidence", "decisionCandidates", "eligibleForReconciliation"],
+      "properties": {
+        "candidateId": { "$ref": "#/$defs/id" },
+        "lifecycle": { "enum": ["active", "released", "withdrawn", "rolled-back"] },
+        "baseline": { "enum": ["current", "stale"] },
+        "promotionEvidence": { "$ref": "#/$defs/promotionEvidence" },
+        "decisionCandidates": { "enum": ["authority-free-candidates", "discarded-not-promoted"] },
+        "eligibleForReconciliation": { "type": "boolean" }
+      }
+    },
+    "resolutionKind": { "enum": ["keep-current-baseline", "accept-branch-change", "compose-compatible-changes", "split-scope-or-override", "replace-or-deprecate-source", "fix-source-and-rerun", "refresh-promotion-evidence", "defer-scoped-conflict", "external-implementation-fix-required"] },
+    "collisionGroup": {
+      "type": "object", "additionalProperties": false,
+      "required": ["kind", "key", "classification", "candidateIds", "candidateDigests", "affectedSourceIds", "affectedItemIds", "affectedSubjects", "affectedScopes", "resolutionKinds", "promoted"],
+      "properties": {
+        "kind": { "enum": ["source", "item", "subject"] },
+        "key": { "$ref": "#/$defs/id" },
+        "classification": { "enum": ["duplicate", "compatible-compose", "scope-split", "supersede", "semantic-conflict", "implementation-only"] },
+        "candidateIds": { "$ref": "#/$defs/ids" },
+        "candidateDigests": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/digest" } },
+        "affectedSourceIds": { "$ref": "#/$defs/ids" },
+        "affectedItemIds": { "$ref": "#/$defs/ids" },
+        "affectedSubjects": { "$ref": "#/$defs/ids" },
+        "affectedScopes": { "$ref": "#/$defs/scopes" },
+        "resolutionKinds": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/resolutionKind" } },
+        "promoted": { "const": false }
+      }
+    },
+    "baseline": {
+      "type": "object", "additionalProperties": false,
+      "required": ["expectedDigest", "actualDigest", "expectedLabel", "actualLabel"],
+      "properties": { "expectedDigest": { "$ref": "#/$defs/nullableDigest" }, "actualDigest": { "$ref": "#/$defs/nullableDigest" }, "expectedLabel": { "$ref": "#/$defs/nullableText" }, "actualLabel": { "$ref": "#/$defs/nullableText" } }
+    },
+    "invocation": {
+      "type": "object", "additionalProperties": false, "required": ["command", "args"],
+      "properties": { "command": { "$ref": "#/$defs/id" }, "args": { "type": "array", "items": { "type": "string" } } }
+    },
+    "externalAction": { "type": "object", "additionalProperties": false, "required": ["kind"], "properties": { "kind": { "type": "string" }, "affectedSourceIds": { "$ref": "#/$defs/ids" }, "affectedItemIds": { "$ref": "#/$defs/ids" }, "affectedPaths": { "$ref": "#/$defs/paths" } } },
+    "recoveryPreview": { "type": "object", "additionalProperties": false, "required": ["resolutionKind"], "properties": { "resolutionKind": { "$ref": "#/$defs/resolutionKind" }, "invocation": { "$ref": "#/$defs/invocation" }, "externalAction": { "$ref": "#/$defs/externalAction" }, "requiredHumanInputs": { "type": "array", "items": { "type": "string" } } } },
+    "resolutionContract": { "type": "object", "additionalProperties": false, "required": ["resolutionState", "resolutionKinds", "requiredHumanInputs", "nextActions", "requiredPostResolutionEvidence", "completionCriteria", "recomputeFromCurrentBaseline"], "properties": { "resolutionState": { "enum": ["needs-human-decision", "contract-action-required", "external-fix-required", "revalidation-required", "resolved", "deferred-open"] }, "resolutionKinds": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/resolutionKind" } }, "requiredHumanInputs": { "type": "array", "uniqueItems": true, "items": { "type": "string" } }, "nextActions": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/recoveryPreview" } }, "requiredPostResolutionEvidence": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "type": "string" } }, "completionCriteria": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "type": "string" } }, "recomputeFromCurrentBaseline": { "const": true } } },
+    "finding": {
+      "type": "object", "additionalProperties": false,
+      "required": ["code", "severity", "affectedSourceIds", "affectedItemIds", "affectedSubjects", "affectedScopes", "baseline", "blocksTask", "blocksExistingDelivery", "resolutionKinds", "recoveryPreviews", "humanRoles", "validateAfterResolution", "recomputeFromCurrentBaseline", "findingDigest", "resolutionContract"],
+      "properties": {
+        "code": { "$ref": "#/$defs/id" },
+        "severity": { "enum": ["attention", "conflict", "blocked"] },
+        "affectedSourceIds": { "$ref": "#/$defs/ids" },
+        "affectedItemIds": { "$ref": "#/$defs/ids" },
+        "affectedSubjects": { "$ref": "#/$defs/ids" },
+        "affectedScopes": { "$ref": "#/$defs/scopes" },
+        "baseline": { "$ref": "#/$defs/baseline" },
+        "blocksTask": { "type": "boolean" },
+        "blocksExistingDelivery": { "const": false },
+        "resolutionKinds": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/resolutionKind" } },
+        "recoveryPreviews": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/recoveryPreview" } },
+        "humanRoles": { "$ref": "#/$defs/ids" },
+        "validateAfterResolution": { "$ref": "#/$defs/ids" },
+        "recomputeFromCurrentBaseline": { "const": true },
+        "findingDigest": { "$ref": "#/$defs/digest" },
+        "resolutionContract": { "$ref": "#/$defs/resolutionContract" }
+      }
+    },
+    "resolutionOutcome": { "type": "object", "additionalProperties": false, "required": ["findingDigest", "resolutionKind", "resolutionState", "outcome", "completionCriteriaMet", "recomputedFromCurrentBaseline"], "properties": { "findingDigest": { "$ref": "#/$defs/digest" }, "resolutionKind": { "$ref": "#/$defs/resolutionKind" }, "resolutionState": { "enum": ["revalidation-required", "external-fix-required", "resolved", "deferred-open"] }, "outcome": { "enum": ["open", "deferred", "resolved", "rejected"] }, "completionCriteriaMet": { "type": "array", "uniqueItems": true, "items": { "type": "string" } }, "recomputedFromCurrentBaseline": { "const": true } } },
+    "guarantees": {
+      "type": "object", "additionalProperties": false, "required": ["projectContextVerified", "hostAsserted", "humanDecided"],
+      "properties": { "projectContextVerified": { "$ref": "#/$defs/ids" }, "hostAsserted": { "$ref": "#/$defs/ids" }, "humanDecided": { "$ref": "#/$defs/ids" } }
+    },
+    "boundaries": {
+      "type": "object", "additionalProperties": false,
+      "required": ["readOnly", "git", "ciClient", "network", "provider", "taskExecution", "automaticApproval", "automaticPromotion", "persistentQueue", "blocksExistingDelivery"],
+      "properties": { "readOnly": { "const": true }, "git": { "const": false }, "ciClient": { "const": false }, "network": { "const": false }, "provider": { "const": false }, "taskExecution": { "const": false }, "automaticApproval": { "const": false }, "automaticPromotion": { "const": false }, "persistentQueue": { "const": false }, "blocksExistingDelivery": { "const": false } }
+    }
+  }
+}

package/schemas/upgrade-assessment.schema.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "urn:frontend-project-context:schema:upgrade-assessment:1",
+  "title": "Frontend Project Context Upgrade Assessment",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "product", "fromVersion", "targetVersion", "fromVersionEvidence", "manifestSchemaVersion", "manifestDigest", "initialization", "health", "entryState", "findingCodes", "snapshots", "compatibility", "migrationPath", "rollbackClass", "requiresHumanReview", "state", "boundaries", "assessmentDigest"],
+  "properties": {
+    "schemaVersion": {"const": 1},
+    "kind": {"const": "upgrade-assessment"},
+    "product": {"type": "object", "additionalProperties": false, "required": ["name"], "properties": {"name": {"const": "frontend-project-context"}}},
+    "fromVersion": {"enum": ["1.3.1", "1.4.0", "1.5.0", "1.6.0"]},
+    "targetVersion": {"const": "1.7.0"},
+    "fromVersionEvidence": {"const": "host-asserted"},
+    "manifestSchemaVersion": {"const": 2},
+    "manifestDigest": {"$ref": "#/$defs/digest"},
+    "initialization": {"type": "object", "additionalProperties": false, "required": ["state", "present", "missing"], "properties": {"state": {"enum": ["uninitialized", "partial", "initialized", "invalid"]}, "present": {"$ref": "#/$defs/strings"}, "missing": {"$ref": "#/$defs/strings"}}},
+    "health": {"enum": ["uninitialized", "partial", "invalid", "attention", "conflict", "clean"]},
+    "entryState": {"type": "object", "additionalProperties": false, "required": ["state", "path", "rendererVersion"], "properties": {"state": {"type": "string"}, "path": {"type": ["string", "null"]}, "rendererVersion": {"type": ["integer", "null"]}}},
+    "findingCodes": {"$ref": "#/$defs/strings"},
+    "snapshots": {"anyOf": [{"type": "null"}, {"$ref": "#/$defs/snapshots"}]},
+    "compatibility": {"type": "object", "additionalProperties": false, "required": ["stores", "renderers", "protocols"], "properties": {"stores": {"$ref": "#/$defs/compatibility"}, "renderers": {"$ref": "#/$defs/compatibility"}, "protocols": {"$ref": "#/$defs/compatibility"}}},
+    "migrationPath": {"$ref": "#/$defs/strings"},
+    "rollbackClass": {"enum": ["package-only", "reversible-data", "forward-only"]},
+    "requiresHumanReview": {"type": "boolean"},
+    "state": {"enum": ["not-applicable", "blocked", "ready-for-plan", "core-complete"]},
+    "boundaries": {"$ref": "#/$defs/boundaries"},
+    "assessmentDigest": {"$ref": "#/$defs/digest"}
+  },
+  "$defs": {
+    "digest": {"type": "string", "pattern": "^sha256:[a-f0-9]{64}$"},
+    "strings": {"type": "array", "uniqueItems": true, "items": {"type": "string"}},
+    "snapshots": {"type": "object", "additionalProperties": false, "required": ["contract", "sourcesLock", "projectionsLock"], "properties": {"contract": {"$ref": "#/$defs/digest"}, "sourcesLock": {"$ref": "#/$defs/digest"}, "projectionsLock": {"$ref": "#/$defs/digest"}}},
+    "compatibility": {"type": "object", "additionalProperties": {"enum": ["compatible", "republish", "regenerate", "invalidate", "unsupported", "not-applicable"]}},
+    "boundaries": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["provider", "agentRuntime", "git", "network", "dependencyInstallation", "automaticApproval", "businessCodeWrites", "taskExecution", "stagePathBodyReads", "applyPlan", "scheduler", "daemon", "telemetry", "selfUpdate", "automaticEvidenceUpload", "packageManager", "automaticUpgrade"],
+      "properties": {
+        "provider": {"const": false}, "agentRuntime": {"const": false}, "git": {"const": false}, "network": {"const": false},
+        "dependencyInstallation": {"const": false}, "automaticApproval": {"const": false}, "businessCodeWrites": {"const": false},
+        "taskExecution": {"const": false}, "stagePathBodyReads": {"const": false}, "applyPlan": {"const": false},
+        "scheduler": {"const": false}, "daemon": {"const": false}, "telemetry": {"const": false}, "selfUpdate": {"const": false},
+        "automaticEvidenceUpload": {"const": false}, "packageManager": {"const": false}, "automaticUpgrade": {"const": false}
+      }
+    }
+  }
+}

package/schemas/upgrade-result-bundle.schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "urn:frontend-project-context:schema:upgrade-result-bundle:1",
+  "title": "Frontend Project Context Upgrade Result Bundle",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "product", "fromVersion", "targetVersion", "manifestDigest", "planDigest", "mode", "action", "written", "targets", "snapshots", "actionResult", "findingCodes", "coreMigration", "hostAcceptance", "overallUpgrade", "resultDigest"],
+  "properties": {
+    "schemaVersion": {"const": 1},
+    "kind": {"const": "upgrade-result-bundle"},
+    "product": {"type": "object", "additionalProperties": false, "required": ["name"], "properties": {"name": {"const": "frontend-project-context"}}},
+    "fromVersion": {"type": "string"},
+    "targetVersion": {"const": "1.7.0"},
+    "manifestDigest": {"$ref": "#/$defs/digest"},
+    "planDigest": {"$ref": "#/$defs/digest"},
+    "mode": {"enum": ["preview", "write"]},
+    "action": {"$ref": "#/$defs/action"},
+    "written": {"type": "boolean"},
+    "targets": {"type": "array", "items": {"type": "object", "additionalProperties": false, "required": ["path", "beforeDigest", "afterDigest"], "properties": {"path": {"$ref": "#/$defs/path"}, "beforeDigest": {"anyOf": [{"type": "null"}, {"$ref": "#/$defs/digest"}]}, "afterDigest": {"anyOf": [{"type": "null"}, {"$ref": "#/$defs/digest"}]}}}},
+    "snapshots": {"type": "object", "additionalProperties": false, "required": ["before", "after"], "properties": {"before": {"anyOf": [{"type": "null"}, {"$ref": "#/$defs/snapshots"}]}, "after": {"anyOf": [{"type": "null"}, {"$ref": "#/$defs/snapshots"}]}}},
+    "actionResult": {"type": "string"},
+    "findingCodes": {"type": "array", "uniqueItems": true, "items": {"type": "string"}},
+    "coreMigration": {"enum": ["previewed", "applied", "blocked", "complete"]},
+    "hostAcceptance": {"const": ["dependency-and-lockfile", "independent-new-window", "project-tests-or-ci"]},
+    "overallUpgrade": {"const": "host-validation-required"},
+    "resultDigest": {"$ref": "#/$defs/digest"}
+  },
+  "$defs": {
+    "digest": {"type": "string", "pattern": "^sha256:[a-f0-9]{64}$"},
+    "path": {"type": "string", "minLength": 1, "pattern": "^(?!/)(?![A-Za-z]:)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*\\\\).+$"},
+    "strings": {"type": "array", "uniqueItems": true, "items": {"type": "string"}},
+    "snapshots": {"type": "object", "additionalProperties": false, "required": ["contract", "sourcesLock", "projectionsLock"], "properties": {"contract": {"$ref": "#/$defs/digest"}, "sourcesLock": {"$ref": "#/$defs/digest"}, "projectionsLock": {"$ref": "#/$defs/digest"}}},
+    "action": {"type": "object", "additionalProperties": false, "required": ["id", "kind", "migrationId", "targets", "writes", "semanticImpact"], "properties": {"id": {"type": "string"}, "kind": {"enum": ["verify-complete", "republish-ai-entry", "republish-projection", "built-in-store-migration", "invalidate-ephemeral-protocol"]}, "migrationId": {"type": ["string", "null"]}, "targets": {"type": "array", "uniqueItems": true, "items": {"$ref": "#/$defs/path"}}, "writes": {"type": "boolean"}, "semanticImpact": {"enum": ["none", "managed-rendering", "store-structure", "protocol-artifact-invalidation"]}}}
+  }
+}

package/src/project-context/a130-evaluation.mjs

@@ -0,0 +1,91 @@
+import { canonicalJson, digestJson } from "./canonical-json.mjs";
+import { fail } from "./errors.mjs";
+
+function median(values) {
+  const sorted = [...values].sort((left, right) => left - right);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+
+function sameStringSet(left = [], right = []) {
+  return canonicalJson([...left].sort()) === canonicalJson([...right].sort());
+}
+
+function pairEntries(entries) {
+  return Array.from({ length: entries.length / 2 }, (_, index) => entries.slice(index * 2, index * 2 + 2));
+}
+
+function pairArms(pair) {
+  return {
+    full: pair.find((run) => run.arm === "full"),
+    candidate: pair.find((run) => run.arm === "candidate"),
+  };
+}
+
+function assertFailureEvidence(run) {
+  if (run.score < 8 && (!Array.isArray(run.failedChecks) || run.failedChecks.length === 0 || run.failedChecks.some((entry) => typeof entry !== "string" || !entry))) {
+    fail("a130-run-result-invalid", "a failed A-130 run must name its failed checks");
+  }
+}
+
+export function validateA130EvaluationPlan(plan, contract, readablePaths) {
+  if (!plan || typeof plan !== "object" || Array.isArray(plan)) fail("a130-evaluation-invalid", "evaluation plan must be an object");
+  const allowed = new Set(["arms", "cases", "forbiddenPaths", "model", "oracleApproval", "wrapper"]);
+  if (Object.keys(plan).some((key) => !allowed.has(key)) || !Array.isArray(plan.arms) || !Array.isArray(plan.cases)) fail("a130-evaluation-invalid", "evaluation plan structure is invalid");
+  if (plan.arms.length !== 2 || plan.arms.some((arm) => !arm || typeof arm !== "object" || arm.format !== plan.arms[0].format || canonicalJson(arm.wrapper) !== canonicalJson(plan.wrapper))) fail("arm-format-mismatch", "full and candidate arms must use the same delivery format and wrapper");
+  const approvedIds = new Set(contract.items.filter((item) => item.status === "approved").map((item) => item.id));
+  const readable = new Set(readablePaths);
+  for (const scenario of plan.cases) {
+    if (!Array.isArray(scenario.oracle) || scenario.oracle.length === 0) fail("oracle-evidence-missing", "every evaluation case needs a non-empty oracle");
+    for (const oracle of scenario.oracle) {
+      if (!oracle.contractItemId && !oracle.sourcePath) fail("oracle-evidence-missing", "oracle truth must be available to both arms through Contract or readable source");
+      if (oracle.contractItemId && !approvedIds.has(oracle.contractItemId)) fail("oracle-evidence-missing", `oracle item ${oracle.contractItemId} is not approved`);
+      if (oracle.sourcePath && !readable.has(oracle.sourcePath)) fail("oracle-evidence-missing", `oracle source ${oracle.sourcePath} is not readable by both arms`);
+      if (plan.forbiddenPaths.includes(oracle.sourcePath)) fail("oracle-evidence-forbidden", "forbidden oracle locators cannot be model evidence");
+    }
+  }
+  const oracleDigest = digestJson(plan.cases.map(({ id, oracle }) => ({ id, oracle })));
+  const approval = plan.oracleApproval;
+  if (!approval || typeof approval !== "object" || Array.isArray(approval) || Object.keys(approval).some((key) => !["at", "by", "oracleDigest"].includes(key)) || typeof approval.by !== "string" || !approval.by || typeof approval.at !== "string" || !approval.at || approval.oracleDigest !== oracleDigest) {
+    fail("oracle-human-approval-missing", "the exact A-130 oracle table must be digest-bound and explicitly approved by a human before Provider use");
+  }
+  return { planDigest: digestJson(plan), status: "ready", armFormat: plan.arms[0].format, oracleDigest, wrapperDigest: digestJson(plan.wrapper) };
+}
+
+export function evaluateA130Runs(runs) {
+  if (!Array.isArray(runs) || runs.length !== 8) fail("a130-run-set-invalid", "A-130 requires one S pair and three order-balanced L pairs (eight runs maximum)");
+  const expectedOrders = { S: ["full", "candidate"], L: ["full", "candidate", "candidate", "full", "full", "candidate"] };
+  for (const caseId of ["S", "L"]) {
+    const entries = runs.filter((run) => run.caseId === caseId);
+    if (canonicalJson(entries.map((run) => run.arm)) !== canonicalJson(expectedOrders[caseId])) fail("a130-run-order-invalid", `${caseId} does not match its frozen pair order`);
+    if (entries.some((run) => run.forbiddenAccess || run.targetWritten || run.gitChanged)) fail("a130-safety-gate-failed", `${caseId} contains a forbidden Host action`);
+    entries.forEach(assertFailureEvidence);
+  }
+  const small = runs.filter((run) => run.caseId === "S");
+  if (small[0].promptDigest !== small[1].promptDigest) fail("a130-small-prompt-mismatch", "A-130-S prompts must be byte-identical before Provider comparison");
+  if (small[0].score !== 8 || small[1].score !== 8) {
+    if (small[0].score < 8 && small[1].score < 8 && sameStringSet(small[0].failedChecks, small[1].failedChecks)) fail("a130-fixture-inconclusive", "byte-identical A-130-S arms failed the same checks; review the task/oracle without changing product selection");
+    fail("a130-provider-variance-inconclusive", "byte-identical A-130-S arms produced different quality and cannot identify a product defect");
+  }
+  const large = runs.filter((run) => run.caseId === "L");
+  const full = large.filter((run) => run.arm === "full");
+  const candidate = large.filter((run) => run.arm === "candidate");
+  if (candidate.some((run) => run.deliveryMode !== "adaptive" || run.requiredRecall !== 1)) fail("a130-adaptive-evidence-defect", "A-130-L candidate runs must be real adaptive deliveries with complete required-item recall");
+  const attributedFailures = [];
+  for (const pair of pairEntries(large)) {
+    const { full: fullRun, candidate: candidateRun } = pairArms(pair);
+    if (fullRun.score < 8 && candidateRun.score < 8 && sameStringSet(fullRun.failedChecks, candidateRun.failedChecks)) fail("a130-fixture-inconclusive", "paired A-130-L arms failed the same checks; review the task/oracle without changing product selection");
+    if (fullRun.score < 8) fail("a130-baseline-inconclusive", "an A-130-L full baseline failed, so the pair cannot identify an adaptive product defect");
+    if (candidateRun.score < 8) {
+      const attribution = candidateRun.attribution;
+      if (!attribution || attribution.kind !== "delivery-evidence-gap" || !Array.isArray(attribution.itemIds) || attribution.itemIds.length === 0) fail("a130-causality-inconclusive", "a candidate-only failure needs a governed delivery-evidence attribution before it can be a product defect");
+      attributedFailures.push(attribution.itemIds.slice().sort());
+    }
+  }
+  if (attributedFailures.length > 0) {
+    const reproducible = attributedFailures.some((ids, index) => attributedFailures.some((other, otherIndex) => otherIndex > index && canonicalJson(ids) === canonicalJson(other)));
+    if (!reproducible) fail("a130-causality-inconclusive", "an attributed adaptive failure was not reproduced in a second balanced pair");
+    fail("a130-adaptive-evidence-defect", "a governed delivery-evidence gap reproducibly caused candidate-only quality failure");
+  }
+  if (median(candidate.map((run) => run.promptBytes)) > median(full.map((run) => run.promptBytes)) * 0.7 || median(candidate.map((run) => run.inputTokens)) > median(full.map((run) => run.inputTokens)) || median(candidate.map((run) => run.commandCount)) > median(full.map((run) => run.commandCount)) || median(candidate.map((run) => run.wallSeconds)) > median(full.map((run) => run.wallSeconds)) * 1.1) fail("a130-efficiency-gate-failed", "A-130-L median efficiency gates failed");
+  return { status: "passed", pairs: 4, runs: 8 };
+}