@piagent/platform 1.2.16 → 1.3.0-ie.8

package/scripts/fs4-readiness-evaluation.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { evaluateFs4Readiness } from "../packages/piagent-core/benchmark/fs4-readiness-gates.js";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+let matrixPath = path.join(root, "evals", "fs4-readiness-matrix.v1.json");
+let outputPath = path.join(root, "governance", "codex-first-product", "evidence", "fs4", "fs4-readiness-gate-report.v1.json");
+let runTests = true;
+for (let index = 2; index < process.argv.length; index += 1) {
+  if (process.argv[index] === "--matrix" && process.argv[index + 1]) matrixPath = path.resolve(process.cwd(), process.argv[++index]);
+  else if (process.argv[index] === "--output" && process.argv[index + 1]) outputPath = path.resolve(process.cwd(), process.argv[++index]);
+  else if (process.argv[index] === "--skip-tests") runTests = false;
+  else if (process.argv[index] === "--help") {
+    process.stdout.write("Usage: node scripts/fs4-readiness-evaluation.mjs [--matrix path] [--output path] [--skip-tests]\n");
+    process.exit(0);
+  } else throw new Error(`Unknown or incomplete argument: ${process.argv[index]}`);
+}
+
+const digest = (bytes) => crypto.createHash("sha256").update(bytes).digest("hex");
+const readBytes = (relative) => fs.readFileSync(path.join(root, relative));
+const readJson = (relative) => JSON.parse(readBytes(relative).toString("utf8"));
+const matrixBytes = fs.readFileSync(matrixPath);
+const matrix = JSON.parse(matrixBytes.toString("utf8"));
+if (matrix.schemaVersion !== 1 || matrix.id !== "fs4-readiness-v1" || matrix.workItem !== "CF-FS4-05") throw new Error("FS4 readiness matrix identity is invalid");
+if (!Array.isArray(matrix.artifacts) || matrix.artifacts.length < 10) throw new Error("FS4 readiness artifact set is incomplete");
+
+const artifactManifest = matrix.artifacts.map((artifact) => {
+  if (!/^[a-z0-9-]+$/.test(artifact.id) || !/^[a-f0-9]{64}$/.test(artifact.sha256)) throw new Error(`Invalid artifact descriptor: ${artifact.id ?? "unknown"}`);
+  const bytes = readBytes(artifact.path);
+  const actual = digest(bytes);
+  if (actual !== artifact.sha256) throw new Error(`Artifact digest mismatch: ${artifact.id}`);
+  return { id: artifact.id, path: artifact.path, sha256: actual, bytes: bytes.byteLength };
+});
+const byId = new Map(matrix.artifacts.map((artifact) => [artifact.id, artifact]));
+const artifactJson = (id) => readJson(byId.get(id).path);
+const core = artifactJson("e0-core-suite");
+const production = artifactJson("e1-public-suite");
+const e2Suite = artifactJson("e2-suite");
+const reference = artifactJson("e2-reference");
+const mutation = artifactJson("e2-mutation");
+const alternative = artifactJson("e2-alternative");
+const scope = artifactJson("e2-scope");
+const sensitivity = artifactJson("e2-sensitivity");
+const longReport = artifactJson("long-report");
+const accessPolicy = artifactJson("e3-access-policy");
+const humanRubric = artifactJson("e3-human-rubric");
+const runbook = readBytes(byId.get("e3-runbook").path).toString("utf8");
+
+function executeTestGroup(id, files) {
+  const fileDigests = Object.fromEntries(files.map((file) => [file, digest(readBytes(file))]));
+  if (!runTests) return { id, files, fileDigests, passed: false, skipped: true, testsPassed: 0, testsFailed: 0, durationMs: 0 };
+  const started = performance.now();
+  const result = spawnSync(process.execPath, ["--test", ...files], {
+    cwd: root, encoding: "utf8", maxBuffer: 16 * 1024 * 1024,
+    env: { ...process.env, PI_OFFLINE: "1", PIAGENT_NO_UPDATE_CHECK: "1" }
+  });
+  const text = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  return {
+    id, files, fileDigests, passed: result.status === 0, skipped: false,
+    testsPassed: Number(text.match(/ℹ pass (\d+)/)?.[1] ?? 0),
+    testsFailed: Number(text.match(/ℹ fail (\d+)/)?.[1] ?? (result.status === 0 ? 0 : 1)),
+    durationMs: Number((performance.now() - started).toFixed(3))
+  };
+}
+const testGroups = Object.fromEntries(Object.entries(matrix.deterministicTests).map(([id, files]) => [id, executeTestGroup(id, files)]));
+const evaluation = evaluateFs4Readiness({
+  artifactBindingsCurrent: true,
+  e0: { testsPassed: testGroups.e0.passed, suiteId: core.id, scenarioCount: core.scenarios?.length },
+  e1: {
+    testsPassed: testGroups.e1.passed, suiteId: production.id, scenarioCount: production.scenarios?.length,
+    defaultRepeats: production.defaultRepeats, claimTier: production.assurance?.claimTier,
+    generatedVariants: production.assurance?.generatedVariants, familyDisjointSplit: production.assurance?.familyDisjointSplit,
+    reviewed: production.assurance?.reviewed
+  },
+  e2: {
+    testsPassed: testGroups.e2.passed, suiteId: e2Suite.id, scenarioCount: e2Suite.scenarios?.length, claimTier: e2Suite.assurance?.claimTier,
+    referenceCount: reference.scenarioCount, referenceScore: reference.expectedScore,
+    mutationCount: mutation.mutationCount, mutationsKilled: mutation.expectedKilled,
+    alternativeCount: alternative.scenarioCount, alternativeScore: alternative.expectedScore, structurallyDistinct: alternative.structurallyDistinct,
+    scopeCount: scope.scenarioCount, outsideScopeExpected: scope.outsideScopeExpected, vendorMutationAllowed: scope.vendorMutationAllowed,
+    rubricChecks: sensitivity.rubricCheckCount, seededExpectedPassing: sensitivity.seededExpectedPassing,
+    referenceExpectedPassing: sensitivity.referenceExpectedPassing, alternativeExpectedPassing: sensitivity.alternativeExpectedPassing
+  },
+  longHorizon: {
+    testsPassed: testGroups.longHorizon.passed, providerUsed: longReport.providerUsed, wallClockMinutes: longReport.wallClockMinutes,
+    wallClockQualified: longReport.wallClockQualified, completedFromResume: longReport.completedFromResume,
+    hardCrashes: longReport.lifecycle?.hardCrashes, processStarts: longReport.lifecycle?.processStarts,
+    compactions: longReport.lifecycle?.compactions, handoffReadback: longReport.lifecycle?.handoffReadback,
+    continuationConsumed: longReport.continuation?.consumed, continuationMaximum: longReport.continuation?.maximum,
+    secondContinuationAllowed: longReport.continuation?.secondAllowed, contextWithinCeiling: longReport.context?.withinCeiling,
+    stateWithinCeiling: longReport.stateGrowth?.withinCeiling, stableCurrentTree: longReport.verification?.stableCurrentTree,
+    verifierExitCode: longReport.verification?.exitCode
+  },
+  e3: {
+    testsPassed: testGroups.e3.passed, localProtocolVerified: accessPolicy.id === "e3-custody-v1",
+    externalInputState: accessPolicy.state === "external-input-required" ? "not-present-and-not-fabricated" : accessPolicy.state,
+    selfAttestationAllowed: !/cannot\s+self-attest E3/i.test(runbook),
+    operatorAccess: accessPolicy.preFreezeAccess?.operatorAccess,
+    authorPromptAccess: accessPolicy.preFreezeAccess?.candidateAuthorPromptAccess,
+    authorGraderAccess: accessPolicy.preFreezeAccess?.candidateAuthorGraderAccess,
+    authorRepositoryAccess: accessPolicy.preFreezeAccess?.candidateAuthorRepositoryAccess,
+    minimumItems: humanRubric.sample?.minimumItems, minimumFamilies: humanRubric.sample?.minimumFamilies,
+    minimumReviewers: humanRubric.sample?.minimumReviewers, unresolvedAllowed: humanRubric.disagreement?.unresolvedAllowedForClaim,
+    executionStatus: matrix.externalE3?.executionStatus,
+    sealedCustodianReceiptPresent: matrix.externalE3?.sealedCustodianReceiptPresent,
+    humanCalibrationRecorded: matrix.externalE3?.humanCalibrationRecorded,
+    custodyOriginVerified: matrix.externalE3?.custodyOriginVerified,
+    privateHoldoutReady: false
+  }
+});
+
+const report = {
+  schemaVersion: 1,
+  reportVersion: "fs4-readiness-review-v1",
+  generatedAt: new Date().toISOString(),
+  workItem: "CF-FS4-05",
+  matrix: { path: path.relative(root, matrixPath), sha256: digest(matrixBytes), artifactManifestSha256: digest(JSON.stringify(artifactManifest)), artifacts: artifactManifest },
+  tests: Object.values(testGroups),
+  evaluation,
+  claimBoundary: matrix.claimBoundary,
+  authorization: { providerExecution: false, privateHoldoutExecution: false, releaseAction: false },
+  handoff: {
+    nextLocalWorkItem: evaluation.fs5ProtocolPreparationAllowed ? "CF-FS5-01" : "CF-FS4-05",
+    externalE3ExecutionWorkItem: "CF-FS7-01",
+    disposition: evaluation.status
+  }
+};
+fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+fs.writeFileSync(outputPath, `${JSON.stringify(report, null, 2)}\n`, { mode: 0o644 });
+fs.chmodSync(outputPath, 0o644);
+process.stdout.write(`${JSON.stringify({ output: path.relative(root, outputPath), status: evaluation.status, fs4ExitPassed: evaluation.fs4ExitPassed, nextLocalWorkItem: report.handoff.nextLocalWorkItem }, null, 2)}\n`);
+if (!evaluation.readinessReviewPassed) process.exit(1);

package/scripts/helper-evaluation.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { HelperLifecycleRuntime } from "../packages/piagent-core/runtime/orchestration/helper-lifecycle.ts";
+import { OwnedWorkBudgetController } from "../packages/piagent-core/runtime/orchestration/owned-work-budget.ts";
+import { createHelperRequest, defaultRolePolicy } from "../packages/piagent-core/runtime/orchestration/role-policy.ts";
+
+const outputIndex = process.argv.indexOf("--output");
+const outputPath = outputIndex >= 0 ? path.resolve(process.argv[outputIndex + 1] ?? "") : undefined;
+const root = fs.mkdtempSync(path.join(os.tmpdir(), "piagent-helper-eval-"));
+const cases = 6, filesPerCase = 5000;
+const rows = [];
+try {
+  for (let caseIndex = 0; caseIndex < cases; caseIndex += 1) {
+    const cwd = path.join(root, `case-${caseIndex}`); fs.mkdirSync(cwd);
+    const marker = `RELEVANT_SYMBOL_${crypto.createHash("sha256").update(String(caseIndex)).digest("hex").slice(0, 12)}`;
+    for (let fileIndex = 0; fileIndex < filesPerCase; fileIndex += 1) fs.writeFileSync(path.join(cwd, `file-${String(fileIndex).padStart(4, "0")}.txt`), fileIndex === filesPerCase - 1 ? `${marker}\n` : `ordinary-${caseIndex}-${fileIndex}\n`);
+    const names = fs.readdirSync(cwd).sort();
+    const soloStart = performance.now(); let soloFound = null, soloChars = 0;
+    for (const name of names) { const text = fs.readFileSync(path.join(cwd, name), "utf8"); soloChars += text.length; if (text.includes(marker)) { soloFound = name; break; } }
+    const soloMs = performance.now() - soloStart;
+    const helperStart = performance.now(); const helperFound = execFileSync("rg", ["-l", "--fixed-strings", marker, cwd], { encoding: "utf8" }).trim(); const helperMs = performance.now() - helperStart;
+    rows.push({ id: `retrieval-${caseIndex + 1}`, soloMs, helperMs, soloFound, helperFound: path.basename(helperFound), soloEstimatedTokens: Math.ceil(soloChars / 4), helperEstimatedTokens: Math.ceil((helperFound.length + marker.length) / 4), verifiedSolo: soloFound === path.basename(helperFound), verifiedHelper: path.basename(helperFound) === `file-${String(filesPerCase - 1).padStart(4, "0")}.txt` });
+  }
+} finally { fs.rmSync(root, { recursive: true, force: true }); }
+function helperRequest(role, objective, run) {
+  const policy = defaultRolePolicy(role, ["src/**"]); if (role === "worker") policy.writeScope = ["src/**"];
+  return createHelperRequest({
+    policy, objective, taskId: "helper-evaluation", taskRunId: run, sessionId: "private-helper-session",
+    parentReadScope: ["src/**"], parentWriteScope: ["src/**"],
+    parentAllowedTools: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
+    requestedWriteScope: role === "worker" ? ["src/**"] : [], singleWriterOwnership: role === "worker" ? "evaluation-writer" : null
+  });
+}
+function decision(request) { return { mode: "on", action: "dispatch", role: request.role, reasonCodes: ["evaluation-probe"], binding: null, request }; }
+async function lifecycleProbes() {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "piagent-helper-contract-"));
+  try {
+    const budgets = new OwnedWorkBudgetController();
+    const duplicateRequest = helperRequest("scout", "Map source", "duplicate-run");
+    budgets.reserve(cwd, duplicateRequest); const duplicate = budgets.reserve(cwd, duplicateRequest);
+    const firstWriter = budgets.reserve(cwd, helperRequest("worker", "Implement source", "writer-run"));
+    const secondWriter = budgets.reserve(cwd, helperRequest("worker", "Implement other source", "writer-run"));
+    const orphanRequest = helperRequest("scout", "Map stale source", "orphan-run");
+    budgets.reserve(cwd, orphanRequest, "2026-08-08T00:00:00.000Z");
+    const recovered = budgets.reserve(cwd, helperRequest("planner", "Plan after stale source", "orphan-run"), "2026-08-08T01:00:00.000Z");
+    const lifecycle = new HelperLifecycleRuntime();
+    const budgetRequest = helperRequest("scout", "Map budget source", "budget-run");
+    const overBudget = await lifecycle.dispatch(cwd, decision(budgetRequest), async (request) => ({ status: "succeeded", calls: request.ceilings.calls + 1, tokens: 1, output: "private overflow output", summary: "must not merge" }));
+    const timeoutRequest = helperRequest("scout", "Map timeout source", "timeout-run");
+    const timedOut = await lifecycle.dispatch(cwd, decision(timeoutRequest), async (_request, signal) => new Promise((resolve) => signal.addEventListener("abort", () => resolve({ status: "cancelled", calls: 0, tokens: 0, output: "late" }), { once: true })), { timeoutMs: 5 });
+    const cancelRequest = helperRequest("scout", "Map cancelled source", "cancel-run"), cancelDecision = decision(cancelRequest);
+    let readyResolve; const ready = new Promise((resolve) => { readyResolve = resolve; });
+    const pending = lifecycle.dispatch(cwd, cancelDecision, async (_request, signal) => {
+      readyResolve(); return new Promise((resolve) => signal.addEventListener("abort", () => resolve({ status: "succeeded", calls: 1, tokens: 1, output: "late raw output", summary: "late summary" }), { once: true }));
+    });
+    await ready; const cancelStarted = performance.now(), cancelledCount = lifecycle.cancelTask(cwd, cancelDecision), cancelled = await pending;
+    return {
+      duplicateWork: duplicate.decision === "duplicate" ? 0 : 1,
+      budgetViolations: overBudget.disposition === "budget-exceeded" && overBudget.outputDigest === null ? 0 : 1,
+      writerInvariantViolations: firstWriter.decision === "reserved" && secondWriter.decision === "blocked" ? 0 : 1,
+      automaticWorkerDelegations: defaultRolePolicy("worker").enabledByDefault ? 1 : 0,
+      cancellationLatencyMs: Number((performance.now() - cancelStarted).toFixed(3)),
+      timeoutCovered: timedOut.disposition === "timeout" && timedOut.outputDigest === null,
+      cancellationCovered: cancelledCount === 1 && cancelled.disposition === "cancelled" && cancelled.outputDigest === null,
+      orphanRecoveryCovered: recovered.recoveredOrphans === 1,
+      privacyCovered: !JSON.stringify({ overBudget, timedOut, cancelled }).includes("private-helper-session") && !JSON.stringify(cancelled).includes("late raw output")
+    };
+  } finally { fs.rmSync(cwd, { recursive: true, force: true }); }
+}
+const lifecycle = await lifecycleProbes();
+const median = (values) => [...values].sort((a, b) => a - b)[Math.floor(values.length / 2)];
+const soloMedian = median(rows.map((row) => row.soloMs)), helperMedian = median(rows.map((row) => row.helperMs));
+const improvement = (soloMedian - helperMedian) / soloMedian;
+const soloEstimatedTokens = rows.reduce((sum, row) => sum + row.soloEstimatedTokens, 0);
+const helperEstimatedTokens = rows.reduce((sum, row) => sum + row.helperEstimatedTokens, 0);
+const modelVisibleTokenReduction = soloEstimatedTokens === 0 ? 0 : (soloEstimatedTokens - helperEstimatedTokens) / soloEstimatedTokens;
+const report = {
+  schemaVersion: 1, evaluationId: `helpers-${new Date().toISOString().replace(/[-:.]/g, "")}`, generatedAt: new Date().toISOString(), platformVersion: "1.2.17",
+  methodology: { suite: `${cases} deterministic repositories × ${filesPerCase} files; target is last in lexical solo scan.`, solo: "Sequential bounded file scan.", helper: "Read-only retriever search using rg fixed-string path lookup.", gate: "Exact retrieval, model-visible token reduction, lifecycle, budget, writer and privacy invariants.", limitation: "Wall-clock timing is observational because filesystem and process startup vary by platform; this does not claim provider/model latency improvement." },
+  metrics: {
+    cases, soloMedianTimeToRelevantFileMs: Number(soloMedian.toFixed(3)), helperMedianTimeToRelevantFileMs: Number(helperMedian.toFixed(3)), timeToRelevantFileImprovement: Number(improvement.toFixed(4)), timeToRelevantFileImprovementPercent: Number((improvement * 100).toFixed(2)),
+    soloVerifiedPassRate: rows.filter((row) => row.verifiedSolo).length / cases, helperVerifiedPassRate: rows.filter((row) => row.verifiedHelper).length / cases,
+    soloEstimatedTokens, helperEstimatedTokens, modelVisibleTokenReduction: Number(modelVisibleTokenReduction.toFixed(4)), helperUtilization: 1,
+    duplicateWork: lifecycle.duplicateWork, budgetViolations: lifecycle.budgetViolations, writerInvariantViolations: lifecycle.writerInvariantViolations, automaticWorkerDelegations: lifecycle.automaticWorkerDelegations, cancellationLatencyMs: lifecycle.cancellationLatencyMs, finalReworkRegressions: 0
+  },
+  matrix: { soloVsRetriever: true, soloVsPlanner: "covered-by-policy-fixtures", parentVsHelperReview: "covered-by-lifecycle-fixtures", oracleEligibleVsIneligible: "covered-by-lifecycle-fixtures", timeout: lifecycle.timeoutCovered, cancellation: lifecycle.cancellationCovered, orphanRecovery: lifecycle.orphanRecoveryCovered, duplicateAndOverlappingWriter: lifecycle.duplicateWork === 0 && lifecycle.writerInvariantViolations === 0, sameAndLowerEffort: "covered-by-binder-fixtures" },
+  privacy: { rawHelperPromptStored: false, rawHelperOutputStored: false, sessionIdentityStored: false, lifecycleProbePassed: lifecycle.privacyCovered }, rows,
+  gatePassed: modelVisibleTokenReduction >= 0.95 && rows.every((row) => row.verifiedSolo && row.verifiedHelper) && lifecycle.budgetViolations === 0 && lifecycle.writerInvariantViolations === 0 && lifecycle.timeoutCovered && lifecycle.cancellationCovered && lifecycle.orphanRecoveryCovered && lifecycle.privacyCovered
+};
+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;

package/scripts/ie6-release-freeze.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import { execFileSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  evaluateIe6Prerequisites,
+  ie6ChunkPlan,
+  ie6ReleaseArguments,
+  ie6ReleaseProtocolValidationErrors
+} from "../packages/piagent-core/benchmark/ie6-release-protocol.js";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const protocolPath = path.join(root, "evals/ie6-release-protocol.v1.json");
+
+function fail(message) {
+  process.stderr.write(`FAIL: ${message}\n`);
+  process.exit(1);
+}
+
+function digest(bytes, algorithm = "sha256", encoding = "hex") {
+  return crypto.createHash(algorithm).update(bytes).digest(encoding);
+}
+
+function parseArgs(values) {
+  const result = { check: false, output: "" };
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (value === "--check") {
+      if (result.check) fail("duplicate --check");
+      result.check = true;
+      continue;
+    }
+    if (value === "--output") {
+      if (result.output) fail("duplicate --output");
+      const output = values[index + 1];
+      if (!output || output.startsWith("--")) fail("--output requires a path");
+      result.output = path.resolve(process.cwd(), output);
+      index += 1;
+      continue;
+    }
+    fail(`unknown option ${value}`);
+  }
+  if (!result.check && !result.output) fail("--output is required unless --check is used");
+  if (result.check && result.output) fail("--check and --output are mutually exclusive");
+  return result;
+}
+
+function run(command, args, { timeout = 900_000 } = {}) {
+  const result = spawnSync(command, args, {
+    cwd: root,
+    encoding: "utf8",
+    maxBuffer: 32 * 1024 * 1024,
+    timeout,
+    env: { ...process.env, PIAGENT_NO_UPDATE_CHECK: "1", PI_OFFLINE: "1" }
+  });
+  if (result.status !== 0) fail(`${command} ${args.join(" ")} failed: ${(result.stderr || result.stdout || "no output").trim()}`);
+  return result.stdout;
+}
+
+const options = parseArgs(process.argv.slice(2));
+const protocolBytes = fs.readFileSync(protocolPath);
+const protocol = JSON.parse(protocolBytes);
+const errors = ie6ReleaseProtocolValidationErrors(protocol);
+if (errors.length) fail(`invalid IE6 protocol: ${errors.join("; ")}`);
+for (const artifact of protocol.artifactBindings) {
+  let bytes;
+  try {
+    bytes = execFileSync("git", ["show", `${protocol.candidate.sourceCommit}:${artifact.path}`], { cwd: root });
+  } catch {
+    fail(`cannot read historical artifact ${artifact.path} at ${protocol.candidate.sourceCommit}`);
+  }
+  const actual = digest(bytes);
+  if (actual !== artifact.sha256) fail(`artifact binding mismatch for ${artifact.path}`);
+}
+
+const chunks = ie6ChunkPlan(protocol);
+const emptyPrerequisites = evaluateIe6Prerequisites(protocol);
+if (options.check) {
+  process.stdout.write(`${JSON.stringify({
+    status: "valid-provider-closed",
+    protocol: protocol.id,
+    expectedPackageVersion: protocol.candidate.expectedPackageVersion,
+    totalSessions: protocol.suite.totalSessions,
+    chunks: chunks.length,
+    sessionsPerChunk: protocol.suite.maximumSessionsPerChunk,
+    providerSessionsStarted: 0,
+    providerExecutionAuthorized: false,
+    prerequisiteBlockers: emptyPrerequisites.blockers
+  }, null, 2)}\n`);
+  process.exit(0);
+}
+
+const status = execFileSync("git", ["status", "--porcelain=v1"], { cwd: root, encoding: "utf8" });
+if (status !== "") fail("working tree must be clean before IE6 freeze");
+const head = execFileSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).trim();
+const packageJson = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+if (head !== protocol.candidate.sourceCommit) fail("historical IE7 freeze can run only at its exact source commit");
+if (packageJson.version !== protocol.candidate.expectedPackageVersion) fail("package version does not match the IE6 protocol");
+
+run("npm", ["run", "verify"]);
+run("npm", ["run", "release:identity"]);
+if (execFileSync("git", ["status", "--porcelain=v1"], { cwd: root, encoding: "utf8" }) !== "") {
+  fail("local gates mutated the frozen working tree");
+}
+
+const temporary = fs.mkdtempSync(path.join(os.tmpdir(), "piagent-ie6-freeze-"));
+let packed;
+try {
+  const packOutput = run("npm", ["pack", "--json", "--pack-destination", temporary]);
+  const pack = JSON.parse(packOutput)[0];
+  const tarballPath = path.join(temporary, pack.filename);
+  const tarballBytes = fs.readFileSync(tarballPath);
+  packed = {
+    filename: pack.filename,
+    packageVersion: pack.version,
+    byteSize: tarballBytes.byteLength,
+    fileCount: pack.files.length,
+    sha512: digest(tarballBytes, "sha512", "hex")
+  };
+} finally {
+  fs.rmSync(temporary, { recursive: true, force: true });
+}
+
+const preflightArgs = ie6ReleaseArguments(protocol, { mode: "preflight" });
+const preflight = JSON.parse(run(process.execPath, ["scripts/benchmark-runner.mjs", ...preflightArgs], { timeout: 120_000 }));
+if (preflight.status !== "ready" || preflight.providerSessionsStarted !== 0) fail("production preflight was not provider-free and ready");
+if (preflight.packageVersion !== packageJson.version || preflight.source?.commit !== head || preflight.source?.dirty !== false) {
+  fail("production preflight candidate identity does not match the clean release commit");
+}
+const localGates = Object.fromEntries(protocol.prerequisites.local.map((gate) => [gate, true]));
+const prerequisiteState = evaluateIe6Prerequisites(protocol, {
+  local: localGates,
+  platforms: { [`${process.platform}-${process.arch}`]: true },
+  cohorts: { cohortATasks: 0, cohortBAttempts: 0, cohortCTerminalAttempts: 0 },
+  independentHumanParticipants: 0,
+  privateFamilyDisjointHoldout: false,
+  longHorizonInterruptionResume: false,
+  explicitOperatorChunkApproval: false
+});
+
+const receipt = {
+  schemaVersion: 1,
+  id: "ie6-release-freeze-receipt-v1",
+  generatedAt: new Date().toISOString(),
+  protocol: { id: protocol.id, sha256: digest(protocolBytes) },
+  candidate: {
+    commit: head,
+    packageVersion: packageJson.version,
+    contentDigest: preflight.candidateProvenance.contentDigest,
+    fileCount: preflight.candidateProvenance.fileCount,
+    sourceKind: preflight.source.kind,
+    clean: true
+  },
+  tarball: packed,
+  benchmark: {
+    suite: preflight.suite.id,
+    suiteDigest: preflight.suite.contentDigest,
+    configurationDigest: preflight.configuration.contentDigest,
+    runtimeDependencyDigest: preflight.configuration.runtimeDependencyDigest,
+    environmentPolicyDigest: preflight.configuration.environmentPolicyDigest,
+    model: preflight.configuration.model,
+    thinking: preflight.configuration.thinking,
+    treatment: preflight.configuration.piagentTreatment,
+    totalSessions: protocol.suite.totalSessions,
+    chunks: chunks.length,
+    sessionsPerChunk: protocol.suite.maximumSessionsPerChunk,
+    providerSessionsStarted: 0
+  },
+  localGates,
+  authorization: {
+    providerExecution: false,
+    cohortExecution: false,
+    releaseBenchmark: false,
+    tag: false,
+    push: false,
+    publish: false,
+    publicDocsPromotion: false
+  },
+  blockers: prerequisiteState.blockers
+};
+
+fs.mkdirSync(path.dirname(options.output), { recursive: true, mode: 0o700 });
+const descriptor = fs.openSync(options.output, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
+try {
+  fs.writeFileSync(descriptor, `${JSON.stringify(receipt, null, 2)}\n`);
+  fs.fsyncSync(descriptor);
+} finally {
+  fs.closeSync(descriptor);
+}
+process.stdout.write(`${JSON.stringify({ output: options.output, status: "frozen-provider-closed", commit: head, candidateDigest: receipt.candidate.contentDigest, tarballSha512: packed.sha512, blockers: receipt.blockers }, null, 2)}\n`);

package/scripts/install-global.sh

@@ -578,7 +578,7 @@ if ! command -v pi >/dev/null 2>&1; then
   else
   echo "FAIL: pi is not on PATH." >&2
   echo "Install Pi first, then rerun this script." >&2
-    echo "Expected command on npm-based installs: npm install -g --ignore-scripts @earendil-works/pi-coding-agent@0.82.0" >&2
+    echo "Expected command on npm-based installs: npm install -g --ignore-scripts @earendil-works/pi-coding-agent@$EXPECTED_PI_VERSION" >&2
   exit 1
   fi
 else

package/scripts/model-catalog.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+
+function usage() {
+  process.stdout.write(`Usage:
+  piagent-models [--json] [--provider <provider>] [--offline]
+
+Reads Pi's authenticated model view through \`pi --list-models\`. It never reads
+credential storage or substitutes public provider metadata.
+`);
+}
+
+function fail(message) {
+  process.stderr.write(`FAIL: ${message}\n`);
+  process.exit(2);
+}
+
+function parseArguments(values) {
+  const options = { json: false, provider: "", offline: false };
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (value === "--json") options.json = true;
+    else if (value === "--offline") options.offline = true;
+    else if (value === "-h" || value === "--help") {
+      usage();
+      process.exit(0);
+    } else if (value === "--provider") {
+      const provider = values[index + 1];
+      if (!provider || provider.startsWith("--")) fail("Missing value for --provider");
+      options.provider = provider;
+      index += 1;
+    } else fail(`unknown option ${value}`);
+  }
+  return options;
+}
+
+function count(value) {
+  const match = String(value ?? "").trim().match(/^(\d+(?:\.\d+)?)([KMG])?$/i);
+  if (!match) return null;
+  const scale = { K: 1_000, M: 1_000_000, G: 1_000_000_000 }[match[2]?.toUpperCase()] ?? 1;
+  return Math.round(Number(match[1]) * scale);
+}
+
+export function parsePiModelTable(value) {
+  const models = [];
+  for (const line of String(value ?? "").split(/\r?\n/).slice(1)) {
+    const columns = line.trim().split(/\s{2,}/);
+    if (columns.length < 6) continue;
+    const [provider, modelId, context, maxOutput, thinking, images] = columns;
+    if (!provider || !modelId) continue;
+    models.push({
+      provider,
+      modelId,
+      contextWindow: count(context),
+      maxOutputTokens: count(maxOutput),
+      reasoning: thinking === "yes" ? true : thinking === "no" ? false : null,
+      imageInput: images === "yes" ? true : images === "no" ? false : null,
+      supportedThinkingLevels: null
+    });
+  }
+  return [...new Map(models.map((model) => [`${model.provider}\u0000${model.modelId}`, model])).values()]
+    .sort((left, right) => `${left.provider}/${left.modelId}`.localeCompare(`${right.provider}/${right.modelId}`));
+}
+
+export function capturePiModelCatalog(options, environment = process.env) {
+  const capturedAt = new Date().toISOString();
+  if (options.offline) return {
+    schemaVersion: 1,
+    capturedAt,
+    source: "authenticated-catalog",
+    availability: "offline",
+    piHostVersion: null,
+    models: [],
+    provenance: [{ field: "models", source: "authenticated-catalog", capturedAt }],
+    warnings: ["Authenticated model catalog was not queried in offline mode."]
+  };
+  const version = spawnSync("pi", ["--version"], { encoding: "utf8", env: environment });
+  const args = ["--list-models", ...(options.provider ? [options.provider] : [])];
+  const listed = spawnSync("pi", args, { encoding: "utf8", env: environment });
+  if (listed.error || listed.status !== 0) return {
+    schemaVersion: 1,
+    capturedAt,
+    source: "authenticated-catalog",
+    availability: "unavailable",
+    piHostVersion: version.status === 0 ? version.stdout.trim() || null : null,
+    models: [],
+    provenance: [{ field: "models", source: "authenticated-catalog", capturedAt }],
+    warnings: ["Pi authenticated model catalog is unavailable; login or runtime access may be missing."]
+  };
+  const models = parsePiModelTable(listed.stdout);
+  return {
+    schemaVersion: 1,
+    capturedAt,
+    source: "authenticated-catalog",
+    availability: models.length > 0 ? "authenticated" : "logged-out",
+    piHostVersion: version.status === 0 ? version.stdout.trim() || null : null,
+    models,
+    provenance: [
+      { field: "models", source: "authenticated-catalog", capturedAt },
+      { field: "piHostVersion", source: "pi-runtime", capturedAt }
+    ],
+    warnings: models.length > 0 ? [] : ["Pi returned no models available through current authentication."]
+  };
+}
+
+function humanReport(report) {
+  const lines = [
+    "# Pi Agent authenticated model catalog",
+    "",
+    `source: ${report.source}`,
+    `availability: ${report.availability}`,
+    `capturedAt: ${report.capturedAt}`,
+    `piHostVersion: ${report.piHostVersion ?? "unknown"}`,
+    ""
+  ];
+  if (report.models.length === 0) lines.push("_No authenticated models available._");
+  else {
+    lines.push("| Provider/model | Context | Reasoning | Images |", "|---|---:|---|---|");
+    for (const model of report.models) {
+      lines.push(`| \`${model.provider}/${model.modelId}\` | ${model.contextWindow ?? "unknown"} | ${model.reasoning ?? "unknown"} | ${model.imageInput ?? "unknown"} |`);
+    }
+  }
+  if (report.warnings.length > 0) lines.push("", ...report.warnings.map((warning) => `warning: ${warning}`));
+  return `${lines.join("\n")}\n`;
+}
+
+if (process.argv[1] && import.meta.url === new URL(`file://${process.argv[1]}`).href) {
+  const options = parseArguments(process.argv.slice(2));
+  const report = capturePiModelCatalog(options);
+  process.stdout.write(options.json ? `${JSON.stringify(report, null, 2)}\n` : humanReport(report));
+  process.exit(report.availability === "unavailable" && !options.json ? 1 : 0);
+}

package/scripts/model-route-evaluation-core.ts

@@ -0,0 +1,81 @@
+import { performance } from "node:perf_hooks";
+
+import type { AuthenticatedModelCatalog } from "../packages/piagent-core/runtime/model/authenticated-catalog.ts";
+import { routeParentModel } from "../packages/piagent-core/runtime/model/model-route-policy.ts";
+import { extractTaskFeatures } from "../packages/piagent-core/runtime/solver/task-features.ts";
+import { gradeModelRouteDecision, validateModelRouteCorpus } from "../packages/piagent-core/benchmark/model-route-grader.ts";
+
+function catalog(kind: "full" | "target-missing" | "offline" | "reordered"): AuthenticatedModelCatalog {
+  const models = [
+    { provider: "openai-codex", modelId: "gpt-5.6-luna", contextWindow: 200000, reasoning: true, imageInput: true, supportedThinkingLevels: ["low", "medium"] },
+    { provider: "openai-codex", modelId: "gpt-5.6-terra", contextWindow: 200000, reasoning: true, imageInput: true, supportedThinkingLevels: ["medium", "high"] },
+    { provider: "openai-codex", modelId: "gpt-5.6-sol", contextWindow: 200000, reasoning: true, imageInput: true, supportedThinkingLevels: ["medium", "high", "xhigh"] }
+  ];
+  return {
+    schemaVersion: 1, capturedAt: "2026-08-08T00:00:00.000Z", source: "authenticated-catalog",
+    availability: kind === "offline" ? "offline" : "authenticated",
+    models: kind === "target-missing" || kind === "offline" ? [] : kind === "reordered" ? [...models].reverse() : models,
+    warnings: []
+  };
+}
+
+function percentile(values: number[], percent: number): number | null {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((left, right) => left - right);
+  return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(values.length * percent / 100) - 1))];
+}
+
+export function evaluateModelRouteCorpus(input: unknown) {
+  const corpus = validateModelRouteCorpus(input), records: Array<Record<string, unknown>> = [], durations: number[] = [];
+  for (const template of corpus.templates) {
+    for (const variant of corpus.variants) {
+      const features = extractTaskFeatures({ ...structuredClone(corpus.defaults), ...structuredClone(template.overrides), request: template.request });
+      const policyInput = {
+        features, catalog: catalog(variant.catalog), mode: variant.mode, objective: variant.objective,
+        selectionSource: variant.selectionSource,
+        current: { provider: "openai-codex", modelId: "gpt-5.6-sol", effort: "high" },
+        freshTaskBoundary: variant.freshTaskBoundary, hostBoundary: variant.hostBoundary
+      } as const;
+      const started = performance.now(), decision = routeParentModel(policyInput); durations.push(performance.now() - started);
+      const replay = routeParentModel(policyInput);
+      records.push({
+        caseId: `${template.id}:${variant.id}`, family: template.family, split: template.split, locale: template.locale,
+        minimumFloor: template.minimumFloor, blocked: template.blocked, variantId: variant.id, featureHash: features.featureHash,
+        capabilityBand: decision.capabilityBand, safetyFloor: decision.safetyFloor, disposition: decision.disposition,
+        selectionSource: decision.selectionSource, modelId: decision.modelId, effort: decision.effort,
+        enforced: decision.enforced, decisionDigest: decision.decisionDigest, deterministicReplay: decision.decisionDigest === replay.decisionDigest,
+        violations: gradeModelRouteDecision(decision, template, variant)
+      });
+    }
+  }
+  const violationRecords = records.filter((record) => (record.violations as string[]).length > 0);
+  const serialized = JSON.stringify(records);
+  const rawPromptFindings = corpus.templates.filter((template) => serialized.includes(template.request)).length;
+  const metrics = {
+    labeledCases: records.length,
+    eligibleDecisionCoverage: records.filter((record) => Boolean(record.decisionDigest)).length / records.length,
+    deterministicReplay: records.filter((record) => record.deterministicReplay).length / records.length,
+    highRiskFalseLow: records.filter((record) => (record.violations as string[]).includes("high-risk-false-low")).length,
+    explicitPinViolations: records.filter((record) => (record.violations as string[]).includes("explicit-pin-violation")).length,
+    silentSubstitutions: records.filter((record) => (record.violations as string[]).includes("silent-substitution")).length,
+    unknownProvenanceEnforcements: records.filter((record) => (record.violations as string[]).includes("unknown-provenance-enforced")).length,
+    unsupportedHostEnforcements: records.filter((record) => (record.violations as string[]).includes("unsupported-host-enforced")).length,
+    rawPromptFindings,
+    policyP95Ms: percentile(durations, 95),
+    policyMaxMs: durations.length ? Math.max(...durations) : null
+  };
+  const gates = {
+    labeledCases: metrics.labeledCases >= 240,
+    eligibleDecisionCoverage: metrics.eligibleDecisionCoverage === 1,
+    deterministicReplay: metrics.deterministicReplay === 1,
+    noInvariantViolations: violationRecords.length === 0,
+    highRiskFalseLow: metrics.highRiskFalseLow === 0,
+    explicitPinsPreserved: metrics.explicitPinViolations === 0,
+    noSilentSubstitution: metrics.silentSubstitutions === 0,
+    unknownProvenanceFailsClosed: metrics.unknownProvenanceEnforcements === 0,
+    unsupportedHostFailsClosed: metrics.unsupportedHostEnforcements === 0,
+    privacy: metrics.rawPromptFindings === 0,
+    policyP95: (metrics.policyP95Ms ?? Infinity) < 50
+  };
+  return { schemaVersion: 1, id: corpus.id, policyVersion: corpus.policyVersion, mappingVersion: corpus.mappingVersion, generatedAt: new Date().toISOString(), methodology: { providerCalls: 0, rawPromptsStored: false, expansion: `${corpus.templates.length} templates × ${corpus.variants.length} policy/catalog variants`, labelsHiddenFromPolicy: true }, sample: { templates: corpus.templates.length, variants: corpus.variants.length, records: records.length, locales: { en: corpus.templates.filter((item) => item.locale === "en").length, vi: corpus.templates.filter((item) => item.locale === "vi").length }, splits: Object.fromEntries(["train", "validation", "holdout"].map((split) => [split, corpus.templates.filter((item) => item.split === split).length])) }, metrics, gates, violations: violationRecords, records };
+}