@piagent/platform 1.2.16 → 1.3.0-ie.8

package/scripts/private-holdout-readiness.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { benchmarkAssuranceEvidenceValidationErrors } from "../packages/piagent-core/benchmark/benchmark-assurance.js";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const usage = "Usage: node scripts/private-holdout-readiness.mjs --evidence /secure/path/assurance.json";
+
+function digestFile(relativePath) {
+  return crypto.createHash("sha256").update(fs.readFileSync(path.join(root, relativePath))).digest("hex");
+}
+
+function refuse(message) {
+  process.stderr.write(`REFUSED: ${message}\n`);
+  process.exit(1);
+}
+
+let evidencePath = null;
+for (let index = 2; index < process.argv.length; index += 1) {
+  const value = process.argv[index];
+  if (value === "--help" || value === "-h") {
+    process.stdout.write(`${usage}\n`);
+    process.exit(0);
+  }
+  if (value === "--evidence" && process.argv[index + 1]) {
+    evidencePath = process.argv[index + 1];
+    index += 1;
+    continue;
+  }
+  refuse("unknown or incomplete argument");
+}
+if (!evidencePath) refuse("--evidence is required");
+
+let buffer;
+let evidence;
+try {
+  buffer = fs.readFileSync(evidencePath);
+  evidence = JSON.parse(buffer.toString("utf8"));
+} catch {
+  refuse("assurance evidence is unreadable or invalid JSON");
+}
+const errors = benchmarkAssuranceEvidenceValidationErrors(evidence);
+if (errors.length > 0) refuse(errors.join("; "));
+if (evidence.schemaVersion !== 2) refuse("legacy assurance evidence is historical-only and cannot establish E3 readiness");
+
+const bindings = {
+  accessPolicyDigest: digestFile("evals/private-holdout-v1/access-policy.v1.json"),
+  humanRubricDigest: digestFile("evals/private-holdout-v1/human-rubric.v1.json"),
+  taxonomyDigest: digestFile("evals/real-task-taxonomy.v1.json"),
+  publicExposureDigest: digestFile("evals/private-holdout-v1/public-exposure.v1.json")
+};
+for (const [field, expected] of Object.entries(bindings)) {
+  const actual = field in evidence ? evidence[field] : evidence.disjointness?.[field];
+  if (actual !== expected) refuse(`${field} does not match the current public boundary`);
+}
+const now = Date.now();
+if (now < Date.parse(evidence.accessControl.issuedAt) || now >= Date.parse(evidence.accessControl.expiresAt)) refuse("access receipt is not currently valid");
+
+const receipt = {
+  schemaVersion: 1,
+  protocolVersion: "e3-custody-v1",
+  ready: true,
+  evidenceManifestDigest: crypto.createHash("sha256").update(buffer).digest("hex"),
+  claimTier: evidence.claimTier,
+  visibility: evidence.visibility,
+  access: {
+    candidateAuthorAccessDenied: true,
+    operatorExecuteOnly: true,
+    reviewerBlindedAndIndependent: true,
+    issuedAt: evidence.accessControl.issuedAt,
+    expiresAt: evidence.accessControl.expiresAt,
+    accessLogDigest: evidence.accessControl.accessLogDigest
+  },
+  disjointness: {
+    familyDisjoint: true,
+    repositoryDisjoint: true,
+    scenarioCount: evidence.disjointness.scenarioCount,
+    familyCount: evidence.disjointness.familyCount,
+    repositoryCount: evidence.disjointness.repositoryCount,
+    reportDigest: evidence.disjointness.reportDigest
+  },
+  humanCalibration: {
+    sampleSize: evidence.calibration.sampleSize,
+    reviewerCount: evidence.calibration.reviewerCount,
+    disagreementCount: evidence.calibration.disagreementCount,
+    resolvedDisagreementCount: evidence.calibration.resolvedDisagreementCount,
+    unresolvedDisagreementCount: evidence.calibration.unresolvedDisagreementCount,
+    agreement: evidence.calibration.agreement,
+    disagreementLogDigest: evidence.calibration.disagreementLogDigest
+  },
+  claimBoundary: "Readiness receipt only; an exact frozen candidate and the remaining FS5-FS7 gates are still required."
+};
+process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);

package/scripts/product-usability-pilot.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const defaultOutput = path.join(root, "plans", "codex-first-product", "evidence", "p6-usability-pilot", "report.json");
+const outputIndex = process.argv.indexOf("--output");
+const output = outputIndex >= 0 && process.argv[outputIndex + 1]
+  ? path.resolve(process.cwd(), process.argv[outputIndex + 1])
+  : defaultOutput;
+
+const fixtures = [
+  {
+    id: "scripted-new-install-operator",
+    tasks: ["install-preview", "doctor", "onboard-readiness"],
+    tests: ["tests/install-global.test.mjs", "tests/product-doctor.test.mjs"]
+  },
+  {
+    id: "scripted-upgrade-operator",
+    tasks: ["update-preview", "rollback-preview", "preserve-settings"],
+    tests: ["tests/update-global.test.mjs", "tests/global-update.test.mjs"]
+  },
+  {
+    id: "scripted-daily-operator",
+    tasks: ["read-only-preflight", "tiny-source-status", "receipt", "usage-report", "feature-off"],
+    tests: ["tests/operator-product-ux.test.mjs", "tests/solver-shadow.test.mjs", "tests/helper-lifecycle.test.mjs"]
+  },
+  {
+    id: "scripted-recovery-operator",
+    tasks: ["understand-verifier-failure", "resume-task", "inspect-handoff"],
+    tests: ["tests/recovery-chaos.test.mjs", "tests/resume-state.test.mjs", "tests/handoff-projection.test.mjs"]
+  },
+  {
+    id: "scripted-release-maintainer",
+    tasks: ["confirmation-policy", "distribution-check", "release-identity-check"],
+    tests: ["tests/policy-core.test.mjs", "tests/mcp-approval-gate.test.mjs", "tests/package-distribution.test.mjs", "tests/release-identity.test.mjs"]
+  }
+];
+
+function run(fixture) {
+  const started = performance.now();
+  const result = spawnSync(process.execPath, ["--test", ...fixture.tests], {
+    cwd: root,
+    encoding: "utf8",
+    env: { ...process.env, PIAGENT_NO_UPDATE_CHECK: "1", PI_OFFLINE: "1" },
+    maxBuffer: 8 * 1024 * 1024
+  });
+  const durationMs = Math.round((performance.now() - started) * 1000) / 1000;
+  const summary = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  return {
+    id: fixture.id,
+    participantType: "scripted-fixture-not-human",
+    tasks: fixture.tasks,
+    testFiles: fixture.tests,
+    passed: result.status === 0,
+    durationMs,
+    testSummary: {
+      pass: Number(summary.match(/ℹ pass (\d+)/)?.[1] ?? 0),
+      fail: Number(summary.match(/ℹ fail (\d+)/)?.[1] ?? (result.status === 0 ? 0 : 1))
+    },
+    failure: result.status === 0 ? null : summary.slice(-2000)
+  };
+}
+
+const results = fixtures.map(run);
+const passed = results.filter((item) => item.passed).length;
+const sortedDurations = results.map((item) => item.durationMs).sort((a, b) => a - b);
+const report = {
+  schemaVersion: 1,
+  reportVersion: "product-usability-pilot-v1",
+  generatedAt: new Date().toISOString(),
+  execution: "local-offline-read-only-fixtures",
+  participantDisclosure: {
+    scriptedFixtures: results.length,
+    independentHumanParticipants: 0,
+    requiredIndependentHumanParticipants: 5,
+    externalHumanPilotRequired: true,
+    note: "Scripted fixtures validate deterministic journeys but cannot measure human comprehension or human task time."
+  },
+  results,
+  localGate: {
+    status: passed === results.length ? "passed" : "failed",
+    fixturesPassed: `${passed}/${results.length}`,
+    medianFixtureDurationMs: sortedDurations[Math.floor(sortedDurations.length / 2)] ?? null,
+    hostBoundaryStringCovered: true,
+    confirmationPolicyCovered: true,
+    distributionAndReleaseIdentityCovered: true,
+    noHighSeverityLocalBlocker: passed === results.length
+  },
+  humanExitGate: {
+    status: "pending-external-human-pilot",
+    medianInstallOnboardMinutes: null,
+    medianFirstVerifiedTaskMinutes: null,
+    hostVersusSandboxComprehension: null,
+    destructiveExternalConfirmationComprehension: null,
+    highSeverityUsabilityBlockers: null
+  },
+  releaseAuthorization: {
+    publishAuthorized: false,
+    tagAuthorized: false,
+    pushAuthorized: false,
+    providerConfigurationAuthorized: false
+  }
+};
+
+fs.mkdirSync(path.dirname(output), { recursive: true, mode: 0o700 });
+fs.writeFileSync(output, `${JSON.stringify(report, null, 2)}\n`, { mode: 0o600 });
+console.log(JSON.stringify({ output: path.relative(root, output), localGate: report.localGate, humanExitGate: report.humanExitGate }, null, 2));
+if (passed !== results.length) process.exit(1);

package/scripts/rc-readiness-evaluation.mjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import { execFileSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { evaluateExecPolicyCore } from "../packages/piagent-core/extensions/policy-core.js";
+import { evaluateRcLocalGates } from "../packages/piagent-core/benchmark/rc-readiness-gates.js";
+import { evaluateFsReleaseTransition } from "../packages/piagent-core/benchmark/fs-release-transition.js";
+import { solveTaskFeatures } from "../packages/piagent-core/runtime/solver/solver-policy.ts";
+import { extractTaskFeatures } from "../packages/piagent-core/runtime/solver/task-features.ts";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const matrixPath = path.join(root, "evals", "rc-evaluation-matrix.v1.json");
+const matrix = JSON.parse(fs.readFileSync(matrixPath, "utf8"));
+const transitionBytes = fs.readFileSync(path.join(root, matrix.transitionContract.path));
+const transition = JSON.parse(transitionBytes);
+if (digestBytes(transitionBytes) !== matrix.transitionContract.sha256) throw new Error("FS release transition digest mismatch");
+const transitionGate = evaluateFsReleaseTransition(transition);
+if (transitionGate.status !== "passed") throw new Error(`FS release transition invalid: ${transitionGate.errors.join("; ")}`);
+const outputIndex = process.argv.indexOf("--output");
+const output = outputIndex >= 0 && process.argv[outputIndex + 1]
+  ? path.resolve(process.cwd(), process.argv[outputIndex + 1])
+  : path.join(root, "plans", "codex-first-product", "evidence", "p7-local-readiness", "report.json");
+
+function digestBytes(value) { return crypto.createHash("sha256").update(value).digest("hex"); }
+function digestFile(relative) { return digestBytes(fs.readFileSync(path.join(root, relative))); }
+function candidateDigest() {
+  const files = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], { cwd: root })
+    .toString("utf8").split("\0").filter(Boolean).sort();
+  const hash = crypto.createHash("sha256");
+  for (const relative of files) {
+    const absolute = path.join(root, relative); const stat = fs.lstatSync(absolute);
+    hash.update(relative).update("\0");
+    hash.update(stat.isSymbolicLink() ? fs.readlinkSync(absolute) : fs.readFileSync(absolute));
+    hash.update("\0");
+  }
+  return { digest: hash.digest("hex"), files: files.length };
+}
+function runTests(id, files) {
+  const started = performance.now();
+  const result = spawnSync(process.execPath, ["--test", ...files], {
+    cwd: root, encoding: "utf8", maxBuffer: 16 * 1024 * 1024,
+    env: { ...process.env, PIAGENT_NO_UPDATE_CHECK: "1", PI_OFFLINE: "1" }
+  });
+  const text = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  return {
+    id, command: `node --test ${files.join(" ")}`, passed: result.status === 0,
+    durationMs: Number((performance.now() - started).toFixed(3)),
+    testsPassed: Number(text.match(/ℹ pass (\d+)/)?.[1] ?? 0),
+    testsFailed: Number(text.match(/ℹ fail (\d+)/)?.[1] ?? (result.status === 0 ? 0 : 1))
+  };
+}
+function p95(values) { return values.sort((a, b) => a - b)[Math.max(0, Math.ceil(values.length * 0.95) - 1)] ?? null; }
+function benchmarkPolicy() {
+  const policy = JSON.parse(fs.readFileSync(path.join(root, "packages/piagent-core/policies/base-policy.json"), "utf8"));
+  const commands = ["npm test", "git push origin feature", "cat .env", "rm -rf /", "git add .", "docker volume prune", "bash -lc 'cat src/a.ts'", "terraform apply"];
+  const samples = [];
+  for (let repeat = 0; repeat < 500; repeat += 1) for (const command of commands) {
+    const started = performance.now(); evaluateExecPolicyCore(command, { policy, mode: "enforce" }); samples.push(performance.now() - started);
+  }
+  return { samples: samples.length, p95Ms: Number(p95(samples).toFixed(6)), ceilingMs: 20 };
+}
+function benchmarkRoutes() {
+  const corpus = JSON.parse(fs.readFileSync(path.join(root, "benchmarks/solver-v1/route-corpus.json"), "utf8"));
+  const samples = [];
+  for (let repeat = 0; repeat < 40; repeat += 1) for (const item of corpus.adversarialCases) {
+    const started = performance.now();
+    solveTaskFeatures(extractTaskFeatures({ ...corpus.defaults, ...item.overrides, request: item.request }));
+    samples.push(performance.now() - started);
+  }
+  return { samples: samples.length, p95Ms: Number(p95(samples).toFixed(6)), ceilingMs: 50 };
+}
+function loadEvidenceInput(item) {
+  const bytes = fs.readFileSync(path.join(root, item.path));
+  const sha256 = digestBytes(bytes);
+  if (item.sha256 !== sha256) throw new Error(`Evidence digest mismatch for ${item.id}: ${item.path}`);
+  return {
+    manifest: { id: item.id, path: item.path, sha256, bytes: bytes.byteLength },
+    report: JSON.parse(bytes.toString("utf8"))
+  };
+}
+function privacyScan(reports) {
+  const forbiddenKeys = new Set(["rawPrompt", "rawRequest", "promptText", "sourceText", "childOutput", "credential", "oauthToken", "apiKey", "authorization"]);
+  const findings = [];
+  function walk(value, location) {
+    if (Array.isArray(value)) return value.forEach((item, index) => walk(item, `${location}[${index}]`));
+    if (!value || typeof value !== "object") {
+      if (typeof value === "string" && /(?:sk-proj-|ghp_[A-Za-z0-9]{20,}|Bearer\s+[A-Za-z0-9._-]{20,})/.test(value)) findings.push(`${location}:secret-pattern`);
+      return;
+    }
+    for (const [key, item] of Object.entries(value)) {
+      if (forbiddenKeys.has(key) && item !== null && item !== false && item !== "") findings.push(`${location}.${key}:raw-field`);
+      walk(item, `${location}.${key}`);
+    }
+  }
+  reports.forEach((report, index) => walk(report, `report${index + 1}`));
+  return { reportsScanned: reports.length, findings, passed: findings.length === 0 };
+}
+
+const testGroups = [
+  runTests("quality-routing", ["tests/benchmark-core.test.mjs", "tests/solver-route-corpus.test.mjs", "tests/solver-shadow-pilot.test.mjs", "tests/operator-product-ux.test.mjs", "tests/rc-evaluation-matrix.test.mjs", "tests/rc-readiness-gates.test.mjs"]),
+  runTests("safety-privacy", ["tests/golden-enforcement.test.mjs", "tests/guard-shell-analysis.test.mjs", "tests/policy-shell-differential.test.mjs", "tests/redaction-core.test.mjs", "tests/mcp-approval-gate.test.mjs", "tests/role-policy-binder.test.mjs", "tests/subagent-policy.test.mjs"]),
+  runTests("reliability", ["tests/recovery-chaos.test.mjs", "tests/resume-state.test.mjs", "tests/trajectory-runtime.test.mjs", "tests/owned-work-budget.test.mjs", "tests/state-retention.test.mjs", "tests/local-state-failure-modes.test.mjs"]),
+  runTests("install-migration-rollback", ["tests/install-global.test.mjs", "tests/update-global.test.mjs", "tests/global-update.test.mjs", "tests/migrate-project-state.test.mjs", "tests/uninstall-global.test.mjs", "tests/package-distribution.test.mjs", "tests/package-install-rollback.test.mjs", "tests/release-identity.test.mjs"])
+];
+const loadedEvidence = matrix.evidenceInputs.map(loadEvidenceInput);
+const evidenceFiles = loadedEvidence.map((item) => item.manifest);
+const evidenceManifest = {
+  digest: digestBytes(JSON.stringify(evidenceFiles)),
+  files: evidenceFiles
+};
+const evidence = loadedEvidence.map((item) => item.report);
+const [baseline, solverPilot, phaseTools, recovery, helpers, usability] = evidence;
+const privacy = privacyScan(evidence);
+const policyPerformance = benchmarkPolicy();
+const routePerformance = benchmarkRoutes();
+const modelResult = spawnSync(process.execPath, [path.join(root, "scripts/model-catalog.mjs"), "--json"], { cwd: root, encoding: "utf8" });
+let modelCatalog = { availability: "unavailable", models: [], warnings: ["catalog command failed"] };
+try { if (modelResult.status === 0) modelCatalog = JSON.parse(modelResult.stdout); } catch {}
+const candidate = candidateDigest();
+const currentPlatform = `${process.platform}-${process.arch}`;
+const allLocalTestsPassed = testGroups.every((group) => group.passed);
+const localPerformancePassed = policyPerformance.p95Ms < policyPerformance.ceilingMs && routePerformance.p95Ms < routePerformance.ceilingMs;
+const localGate = evaluateRcLocalGates({
+  allLocalTestsPassed,
+  localPerformancePassed,
+  privacyPassed: privacy.passed,
+  routeCoverage: solverPilot.metrics.eligibleDecisionCoverage,
+  routeRegret: solverPilot.metrics.routeRegret,
+  safetyRouteFalseNegatives: solverPilot.metrics.safetyRouteFalseNegatives,
+  helperBudgetViolations: helpers.metrics.budgetViolations,
+  writerInvariantViolations: helpers.metrics.writerInvariantViolations,
+  recoveryGatePassed: recovery.gatePassed,
+  phaseToolGatePassed: phaseTools.gatePassed,
+  hostBoundaryCovered: usability.localGate.hostBoundaryStringCovered
+});
+const matrixDigest = digestFile("evals/rc-evaluation-matrix.v1.json");
+const evaluationInputDigest = digestBytes(JSON.stringify({ matrix: matrixDigest, transition: matrix.transitionContract.sha256, candidate: candidate.digest, evidence: evidenceManifest.digest }));
+
+const report = {
+  schemaVersion: 1,
+  reportVersion: "rc-local-readiness-v1",
+  generatedAt: new Date().toISOString(),
+  matrix: {
+    version: matrix.matrixVersion,
+    digest: matrixDigest,
+    evaluationInputDigest,
+    repository: { head: execFileSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).trim(), candidateContentDigest: candidate.digest, candidateFiles: candidate.files, cleanReleaseCommit: null },
+    evidenceManifest,
+    versions: matrix.versions,
+    scenarioRevisions: matrix.scenarioRevisions.map((item) => ({ ...item, digest: digestFile(item.path) })),
+    profiles: matrix.profiles.map((name) => ({ name, digest: digestFile(`adapters/${name}/profile.json`) })),
+    modelCatalog: { source: modelCatalog.source ?? "authenticated-catalog", availability: modelCatalog.availability, modelCount: modelCatalog.models?.length ?? 0, digest: digestBytes(JSON.stringify((modelCatalog.models ?? []).map((item) => ({ provider: item.provider, modelId: item.modelId })).sort((a, b) => `${a.provider}/${a.modelId}`.localeCompare(`${b.provider}/${b.modelId}`)))), credentialMaterialRead: false },
+    model: matrix.model,
+    featureModes: matrix.featureModes,
+    verifiers: matrix.verifiers,
+    platforms: matrix.platforms.map((item) => ({ ...item, locallyObserved: item.id === currentPlatform })),
+    grading: matrix.grading,
+    transitionContract: { ...matrix.transitionContract, status: transitionGate.status },
+    exclusions: ["no clean release commit", "no 1.3.0 RC package", "no independent human pilot", "no maintainer/internal/opt-in cohorts", "linux-x64 not executed on this darwin-arm64 host", "no new authenticated paired model benchmark", "no publish/tag/push/provider configuration"]
+  },
+  tests: testGroups,
+  gates: {
+    qualityRouting: {
+      status: "pending-controlled-candidate-benchmark",
+      localDeterministicPassed: testGroups[0].passed && localGate.checks["route-coverage"] && localGate.checks["route-regret"] && localGate.checks["safety-route-false-negatives"],
+      baselineQualityGate: baseline.comparison?.qualityGate === true,
+      baselineTokenClaimAllowed: baseline.comparison?.tokenClaimAllowed === true,
+      routeCoverage: solverPilot.metrics.eligibleDecisionCoverage,
+      routeRegret: solverPilot.metrics.routeRegret,
+      safetyRouteFalseNegatives: solverPilot.metrics.safetyRouteFalseNegatives,
+      currentCandidateExactQualityComparison: null
+    },
+    safetyPrivacy: {
+      status: testGroups[1].passed && localGate.checks["privacy-scan"] && localGate.checks["safety-route-false-negatives"] && localGate.checks["helper-budget-violations"] && localGate.checks["writer-invariant-violations"] && localGate.checks["host-boundary-coverage"] ? "passed-local" : "failed-local",
+      goldenAndAdversarialPassed: testGroups[1].passed,
+      telemetryPrivacy: privacy,
+      hostBoundaryCovered: usability.localGate.hostBoundaryStringCovered,
+      helperBudgetViolations: helpers.metrics.budgetViolations,
+      writerInvariantViolations: helpers.metrics.writerInvariantViolations
+    },
+    reliabilityPerformance: {
+      status: testGroups[2].passed && localGate.checks["performance-ceilings"] && localGate.checks["recovery-gate"] && localGate.checks["phase-tool-gate"] ? "passed-local-current-platform" : "failed-local",
+      interruptionAndResumePassed: testGroups[2].passed,
+      recoveryGate: recovery.gatePassed,
+      phaseToolGate: phaseTools.gatePassed === true,
+      policyPerformance,
+      routePerformance,
+      boundedStateGrowthCoveredByTests: true,
+      linuxX64Observed: currentPlatform === "linux-x64"
+    },
+    installMigrationRollback: {
+      status: testGroups[3].passed ? "passed-disposable-fixtures-rc-package-pending" : "failed-local",
+      fixtureTestsPassed: testGroups[3].passed,
+      rcPackageBuilt: false,
+      stableTagIdentity: null,
+      actualPublishedRollbackRehearsal: false
+    },
+    usability: {
+      status: usability.humanExitGate.status,
+      scriptedFixtures: usability.localGate.fixturesPassed,
+      independentHumans: usability.participantDisclosure.independentHumanParticipants,
+      humanTiming: null,
+      humanComprehension: null
+    }
+  },
+  defaultDecision: {
+    status: "frozen-local-safe-defaults-pending-ga-evidence",
+    solver: { value: "shadow", candidate: "assist", reason: "117-decision shadow evidence exists; Cohorts A-C and candidate benchmark do not." },
+    phaseTools: { value: "shadow", candidate: "on", reason: "Deterministic local gate exists; controlled cross-project cohorts do not." },
+    recovery: { value: "on", candidate: "on", reason: "Bounded recovery and feature-off chaos gates pass; operator can set off." },
+    helpers: { value: "recommend", candidate: "recommend", reason: "Local retrieval improves, but no provider-backed beta evidence authorizes automatic dispatch." },
+    parentRouting: { value: "off", candidate: "off", reason: "Parent remains user-pinned." },
+    executionBackend: { value: "host", candidate: "host", reason: "No isolation adapter is installed; host execution is not a sandbox." },
+    automaticWorkerDelegation: "off"
+  },
+  cohorts: {
+    maintainers: { required: "20-30 controlled tasks", observed: 0 },
+    internalProjects: { required: "100 attempts / 5 profiles", observed: 0 },
+    optInBeta: { required: "200 terminal / 30 high-risk / 30 recovery", observed: 0 }
+  },
+  readiness: {
+    localSafeGate: localGate.status,
+    rcAssembly: transitionGate.rcAssemblyAllowed ? "allowed-local-not-built" : "blocked",
+    beta: "blocked-pending-exact-rc-migration-gate",
+    localGateChecks: localGate.checks,
+    failedLocalGateChecks: localGate.failedChecks,
+    localGateThresholds: localGate.thresholds,
+    gaRelease: "blocked",
+    blockers: ["clean approved release commit missing", "1.3.0 RC package missing", "exact-RC three-pair Migration gate missing", "controlled cohorts A-C not run", "independent five-person usability pilot not run", "linux-x64 candidate run missing", "authenticated candidate benchmark comparison missing", "explicit operator release approval missing"]
+  },
+  authorization: { rcAssembly: true, providerExecution: false, cohortExecution: false, releaseCommit: false, tag: false, publish: false, push: false, docsPromotion: false, providerConfiguration: false }
+};
+
+fs.mkdirSync(path.dirname(output), { recursive: true, mode: 0o700 });
+fs.writeFileSync(output, `${JSON.stringify(report, null, 2)}\n`, { mode: 0o600 });
+console.log(JSON.stringify({ output: path.relative(root, output), localSafeGate: report.readiness.localSafeGate, gaRelease: report.readiness.gaRelease, blockers: report.readiness.blockers }, null, 2));
+if (report.readiness.localSafeGate !== "passed") process.exit(1);

package/scripts/recovery-evaluation.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+import { classifyVerificationFailure } from "../packages/piagent-core/extensions/verification-intelligence.js";
+import { selectRecoveryDecision } from "../packages/piagent-core/runtime/recovery/recovery-policy.ts";
+
+const outputIndex = process.argv.indexOf("--output");
+const outputPath = outputIndex >= 0 ? path.resolve(process.argv[outputIndex + 1] ?? "") : undefined;
+const cases = [
+  {
+    id: "syntax-repair",
+    source: "export const value = ;\n",
+    repaired: "export const value = 2;\n",
+    files: { "test.mjs": "import assert from 'node:assert/strict'; import { value } from './source.mjs'; assert.equal(value, 2);\n" },
+    expectedCategory: "test-assertion"
+  },
+  {
+    id: "assertion-repair",
+    source: "export function value() { return 1; }\n",
+    repaired: "export function value() { return 2; }\n",
+    files: { "test.mjs": "import assert from 'node:assert/strict'; import { value } from './source.mjs'; assert.equal(value(), 2);\n" },
+    expectedCategory: "test-assertion"
+  },
+  {
+    id: "format-repair",
+    source: "export const value = 2;   \n",
+    repaired: "export const value = 2;\n",
+    files: { "test.mjs": "import fs from 'node:fs'; const source = fs.readFileSync(new URL('./source.mjs', import.meta.url), 'utf8'); if (/ +\\n/.test(source)) { console.error('eslint error: formatting violation'); process.exit(1); }\n" },
+    expectedCategory: "test-assertion"
+  },
+  {
+    id: "dependency-repair",
+    source: "export { value } from './missing.mjs';\n",
+    repaired: "export { value } from './value.mjs';\n",
+    files: {
+      "value.mjs": "export const value = 2;\n",
+      "test.mjs": "import assert from 'node:assert/strict'; import { value } from './source.mjs'; assert.equal(value, 2);\n"
+    },
+    expectedCategory: "dependency-config"
+  }
+];
+
+function verify(cwd) {
+  const result = spawnSync(process.execPath, ["--test", "test.mjs"], { cwd, encoding: "utf8", timeout: 10_000 });
+  return { exitCode: result.status ?? 1, output: `${result.stdout ?? ""}\n${result.stderr ?? ""}` };
+}
+
+const results = [];
+for (const [index, fixture] of cases.entries()) {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "piagent-recovery-eval-"));
+  try {
+    fs.writeFileSync(path.join(cwd, "source.mjs"), fixture.source);
+    for (const [name, content] of Object.entries(fixture.files)) fs.writeFileSync(path.join(cwd, name), content);
+    const before = verify(cwd);
+    const classification = classifyVerificationFailure(before.output, before.exitCode);
+    const policyInput = {
+      featureEnabled: true,
+      task: { taskId: fixture.id, taskRunId: `${fixture.id}-run-1`, attempt: 1, maxAttempts: 3, changeMode: "source-change" },
+      classification,
+      currentPhase: "verify",
+      exactVerifierAvailable: true,
+      currentTreeMatchesEvidence: true,
+      dependencyMutationAuthorized: classification.category === "dependency-config",
+      history: []
+    };
+    const enabled = selectRecoveryDecision(policyInput);
+    const disabled = selectRecoveryDecision({ ...policyInput, featureEnabled: false });
+    let reworkPasses = 0;
+    if (enabled.action === "repair" && enabled.sourceMutationAllowed) {
+      fs.writeFileSync(path.join(cwd, "source.mjs"), fixture.repaired);
+      reworkPasses += 1;
+    }
+    const after = verify(cwd);
+    results.push({
+      id: fixture.id,
+      expectedCategory: fixture.expectedCategory,
+      observedCategory: classification.category,
+      evidenceDigest: classification.evidenceDigest,
+      enabledAction: enabled.action,
+      enabledSourceMutationAllowed: enabled.sourceMutationAllowed,
+      disabledAction: disabled.action,
+      beforeExitCode: before.exitCode,
+      afterExitCode: after.exitCode,
+      firstRepairSucceeded: reworkPasses === 1 && after.exitCode === 0,
+      candidateReworkPasses: reworkPasses,
+      manualBaselineReworkPasses: 1,
+      outputStored: false,
+      sourceStored: false,
+      sequence: index + 1
+    });
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+}
+
+const candidateRework = results.reduce((sum, item) => sum + item.candidateReworkPasses, 0);
+const baselineRework = results.reduce((sum, item) => sum + item.manualBaselineReworkPasses, 0);
+const report = {
+  schemaVersion: 1,
+  evaluationId: `recovery-${new Date().toISOString().replace(/[-:.]/g, "")}`,
+  generatedAt: new Date().toISOString(),
+  platformVersion: "1.2.17",
+  policyVersion: "recovery-v1",
+  methodology: {
+    sample: "Four controlled source-owned failures with deterministic one-line repairs and real Node verifier processes.",
+    baseline: "Feature-off selects ordinary handoff; one equivalent manual repair pass is required per fixture.",
+    candidate: "Feature-on policy selects one authorized repair pass, then reruns the exact verifier once.",
+    limitation: "Controlled local fixtures measure recovery policy/outcome mechanics, not model quality on arbitrary repositories."
+  },
+  sampleSize: results.length,
+  classificationPrecision: results.filter((item) => item.expectedCategory === item.observedCategory).length / results.length,
+  featureOffAutomaticFirstRepairSuccess: 0,
+  candidateFirstRepairSuccess: results.filter((item) => item.firstRepairSucceeded).length / results.length,
+  candidateTotalReworkPasses: candidateRework,
+  manualBaselineTotalReworkPasses: baselineRework,
+  increasedTotalRework: candidateRework > baselineRework,
+  rawOutputStored: false,
+  sourceStored: false,
+  results,
+  gatePassed: results.every((item) => item.expectedCategory === item.observedCategory && item.enabledAction === "repair" && item.enabledSourceMutationAllowed && item.disabledAction === "handoff" && item.firstRepairSucceeded)
+    && candidateRework <= baselineRework
+};
+
+if (outputPath) {
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(outputPath, `${JSON.stringify(report, null, 2)}\n`, { mode: 0o600 });
+}
+process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+if (!report.gatePassed) process.exitCode = 1;