@piagent/platform 1.6.1 → 1.8.0

package/scripts/public-evaluation-exposure.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { fileURLToPath } from "node:url";
+
+export const EXPOSURE_PATH = "evals/private-holdout-v1/public-exposure.v2.json";
+const PREVIOUS_PATH = "evals/private-holdout-v1/public-exposure.v1.json";
+const TAXONOMY_PATH = "evals/real-task-taxonomy.v1.json";
+const PUBLIC_TREES = [
+  "adapters", "benchmarks", "evals/architecture-conformance-v1", "evals/golden",
+  "evals/harness-next", "evals/long-horizon-v1", "evals/runtime-conformance-v1",
+  "evals/scenarios", "tests"
+];
+const sha256 = (bytes) => crypto.createHash("sha256").update(bytes).digest("hex");
+const MAX_FILES = 10_000, MAX_FILE_BYTES = 4 * 1024 * 1024, MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const DEFAULT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function reader(root) {
+  let total = 0, count = 0;
+  const cache = new Map();
+  function checked(relative) {
+    let current = root;
+    for (const part of relative.split("/")) {
+      if (!part || part === "." || part === ".." || part.includes("\\")) throw new Error("Invalid public exposure path");
+      current = path.join(current, part);
+      if (fs.lstatSync(current).isSymbolicLink()) throw new Error("Public exposure inputs must not be symlinks");
+    }
+    return current;
+  }
+  function bytes(relative) {
+    if (cache.has(relative)) return cache.get(relative);
+    const target = checked(relative), descriptor = fs.openSync(target, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    let value;
+    try {
+      const stat = fs.fstatSync(descriptor);
+      if (!stat.isFile() || stat.size > MAX_FILE_BYTES) throw new Error("Public exposure input is not a bounded regular file");
+      value = fs.readFileSync(descriptor);
+    } finally { fs.closeSync(descriptor); }
+    total += value.length;
+    if (value.length > MAX_FILE_BYTES || ++count > MAX_FILES || total > MAX_TOTAL_BYTES) throw new Error("Public exposure inventory exceeds its limits");
+    cache.set(relative, value);
+    return value;
+  }
+  function files(relative) {
+    const target = checked(relative);
+    if (!fs.statSync(target).isDirectory()) throw new Error("Public exposure tree is not a directory");
+    const result = [];
+    for (const name of fs.readdirSync(target).sort()) {
+      const child = `${relative}/${name}`, stat = fs.lstatSync(checked(child));
+      if (stat.isDirectory()) result.push(...files(child));
+      else if (stat.isFile()) { bytes(child); result.push(child); }
+      else throw new Error("Public exposure tree contains a non-regular input");
+    }
+    return result;
+  }
+  return { bytes, files, json: (relative) => JSON.parse(bytes(relative).toString("utf8")) };
+}
+
+// Inventory public files only. Never load a private suite or execute an oracle.
+// The predecessor is retained rather than silently erasing earlier exposure.
+export function buildPublicExposure(root = DEFAULT_ROOT) {
+  const read = reader(root), allFiles = new Map();
+  const visibleTrees = PUBLIC_TREES.map((relative) => {
+    const entries = read.files(relative).sort().map((file) => {
+      const bytes = read.bytes(file), digest = sha256(bytes);
+      allFiles.set(file, bytes);
+      return [file, digest];
+    });
+    return { path: relative, fileCount: entries.length, sha256: sha256(JSON.stringify(entries)) };
+  });
+  const visibleSuites = [...allFiles.keys()].filter((file) => /^benchmarks\/[^/]+\/suite\.json$/.test(file)).map((file) => {
+    const suite = read.json(file);
+    if (!/^[a-z0-9-]+$/.test(suite.id ?? "") || file !== `benchmarks/${suite.id}/suite.json`
+      || !Array.isArray(suite.scenarios) || suite.scenarios.length === 0) throw new Error("Invalid public suite identity");
+    const scenarioIds = suite.scenarios.map((scenario) => scenario.id);
+    if (scenarioIds.some((id) => !/^[a-z0-9-]+$/.test(id ?? "")) || new Set(scenarioIds).size !== scenarioIds.length) throw new Error("Invalid public scenario identities");
+    return { id: suite.id, path: file, manifestSha256: sha256(read.bytes(file)), scenarioIds };
+  });
+  const contractLibraries = [...allFiles.keys()].filter((file) => /^adapters\/[^/]+\/contract-families\.json$/.test(file)).map((file) => {
+    const library = read.json(file);
+    if (library.schemaVersion !== 1 || !Array.isArray(library.families)) throw new Error("Invalid public contract library");
+    const families = library.families.map(({ id, version }) => {
+      if (!/^[a-z0-9-]+$/.test(id ?? "") || !Number.isSafeInteger(version) || version < 1) throw new Error("Invalid public contract family identity");
+      return { id, version };
+    });
+    if (new Set(families.map(({ id, version }) => `${id}@${version}`)).size !== families.length) throw new Error("Duplicate public contract family identity");
+    return { path: file, sha256: sha256(read.bytes(file)), families };
+  });
+  return {
+    schemaVersion: 2,
+    id: "author-visible-evaluation-exposure-v2",
+    previousExposure: { path: PREVIOUS_PATH, sha256: sha256(read.bytes(PREVIOUS_PATH)) },
+    taxonomy: { path: TAXONOMY_PATH, sha256: sha256(read.bytes(TAXONOMY_PATH)) },
+    visibleSuites,
+    contractLibraries,
+    visibleTrees,
+    custodianComparisonRules: {
+      familyKey: "Compare private task and acceptance-mechanism lineage against every listed suite, contract family, public tree and predecessor exposure; renamed, generated or structurally varied descendants are not disjoint.",
+      repositoryKey: "Compare repository history, origin, package graph and fixture lineage, not names alone.",
+      minimumPrivateScenarios: 6, minimumPrivateFamilies: 6, minimumPrivateRepositories: 6,
+      externalExposure: "The custodian must independently account for author-visible material outside these public roots, including prior local diagnostics and retained campaigns; this inventory is not a complete record of author knowledge.",
+      publicOutput: "Export only the closed schema-v2 assurance receipt and independent custody attestation."
+    },
+    claimBoundary: "Current public-input inventory only, not independent evaluation, approval, generalization or release evidence. Public-tree digests bind [relative path, file SHA-256] pairs globally sorted by the slash-separated path's UTF-16 code units, serialized as compact JSON and hashed as UTF-8; no private artifacts are loaded."
+  };
+}
+
+export function verifyPublicExposure(root = DEFAULT_ROOT) {
+  const read = reader(root), bytes = read.bytes(EXPOSURE_PATH), actual = JSON.parse(bytes.toString("utf8"));
+  if (!isDeepStrictEqual(actual, buildPublicExposure(root))) throw new Error("Current public exposure inventory is stale or incomplete; regenerate and obtain a new independent custody receipt");
+  return { path: EXPOSURE_PATH, sha256: sha256(bytes), suiteCount: actual.visibleSuites.length,
+    scenarioCount: actual.visibleSuites.reduce((sum, suite) => sum + suite.scenarioIds.length, 0),
+    contractFamilyVersionCount: actual.contractLibraries.reduce((sum, library) => sum + library.families.length, 0),
+    publicTreeCount: actual.visibleTrees.length };
+}
+
+// Node resolves module URLs through filesystem aliases. Compare actual files,
+// otherwise /var versus /private/var (or a global-bin symlink) can skip the CLI.
+const invokedDirectly = process.argv[1] && fs.existsSync(process.argv[1])
+  && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+if (invokedDirectly) {
+  if (process.argv.length === 3 && ["--help", "-h"].includes(process.argv[2])) {
+    process.stdout.write("Usage: node scripts/public-evaluation-exposure.mjs --check|--write\nRequires the complete public source tree, including development tests. Generation does not grant custody or provider authority.\n");
+    process.exit(0);
+  }
+  try {
+    if (process.argv.length !== 3 || !["--check", "--write"].includes(process.argv[2])) throw new Error("Usage: node scripts/public-evaluation-exposure.mjs --check|--write");
+    if (process.argv[2] === "--write") {
+      const destination = path.join(DEFAULT_ROOT, EXPOSURE_PATH);
+      if (fs.existsSync(destination) && fs.lstatSync(destination).isSymbolicLink()) throw new Error("Refusing a symlinked public exposure destination");
+      fs.writeFileSync(destination, `${JSON.stringify(buildPublicExposure(), null, 2)}\n`);
+    }
+    process.stdout.write(`${JSON.stringify(verifyPublicExposure())}\n`);
+  } catch {
+    process.stderr.write("REFUSED: current public exposure inventory is unavailable, stale or incomplete; inspect public inputs and regenerate before independent custody review\n");
+    process.exitCode = 1;
+  }
+}

package/scripts/select-independent-verification.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { compileContractSelection } from "../packages/piagent-core/extensions/acceptance-contract-selection.js";
+import { prepareHostContractApproval } from "../packages/piagent-core/extensions/acceptance-host-configuration.js";
+
+const help = `Usage: piagent select-verification --project PATH --task FILE --recipe FILE [--library FILE] [--output NEW_FILE]
+
+Compile reusable contract families against exact task criterion text/obligation.
+Default library: adapters/node-typescript/contract-families.json
+Recipe schema: schemas/contract-selection-recipe.schema.json
+This only previews a plan. It never reads candidate source, executes project code,
+starts a worker, calls a model or creates verification authority.
+The task JSON is a selection input, not evidence. Review the selected semantics,
+parameters, expanded checks and unselected criteria before approve-verification.
+--output creates a new private plan file only when every requested selection is
+unambiguous. It never overwrites a file. Unknown selection exits with status 2.
+`;
+
+function read(file, maximum) {
+  const fd = fs.openSync(path.resolve(file), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  try {
+    const before = fs.fstatSync(fd);
+    if (!before.isFile() || before.nlink !== 1 || before.size < 1 || before.size > maximum) throw new Error("Invalid selection input file");
+    const bytes = fs.readFileSync(fd), after = fs.fstatSync(fd);
+    if (bytes.length !== before.size || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
+      throw new Error("Selection input changed while reading");
+    }
+    const text = bytes.toString("utf8");
+    if (!Buffer.from(text).equals(bytes)) throw new Error("Selection input must be UTF-8");
+    return text;
+  } finally { fs.closeSync(fd); }
+}
+
+try {
+  const args = process.argv.slice(2), options = {};
+  if (args.length === 1 && ["--help", "-h"].includes(args[0])) { process.stdout.write(help); process.exit(0); }
+  for (let index = 0; index < args.length; index += 2) {
+    const flag = args[index], value = args[index + 1];
+    if (!["--project", "--task", "--recipe", "--library", "--output"].includes(flag)
+      || Object.hasOwn(options, flag) || !value || value.startsWith("--")) throw new Error("Unknown, repeated or incomplete option");
+    options[flag] = value;
+  }
+  if (!options["--project"] || !options["--task"] || !options["--recipe"]) throw new Error("--project, --task and --recipe are required");
+  const installedRoot = path.resolve(import.meta.dirname, ".."), projectRoot = fs.realpathSync.native(options["--project"]);
+  const result = compileContractSelection({
+    libraryText: read(options["--library"] ?? path.join(installedRoot, "adapters/node-typescript/contract-families.json"), 2 * 1024 * 1024),
+    taskText: read(options["--task"], 2 * 1024 * 1024), recipeText: read(options["--recipe"], 512 * 1024)
+  });
+  if (!result.plan) { process.stdout.write(`${JSON.stringify(result, null, 2)}\n`); process.exitCode = 2; }
+  else {
+    // Same validation as explicit approval; preview still creates no authority.
+    prepareHostContractApproval({ projectRoot, installedRoot, ...result.plan });
+    let output;
+    if (options["--output"]) {
+      output = path.resolve(options["--output"]);
+      const fd = fs.openSync(output, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);
+      try { fs.writeFileSync(fd, `${JSON.stringify(result.plan, null, 2)}\n`); fs.fsyncSync(fd); } finally { fs.closeSync(fd); }
+    }
+    process.stdout.write(`${JSON.stringify({ ...result, ...(output ? { output } : {}) }, null, 2)}\n`);
+  }
+} catch (error) { process.stderr.write(`Contract selection failed: ${error.message}\n`); process.exitCode = 1; }

package/scripts/setup.sh

@@ -36,7 +36,7 @@ Options:
   --model-scope <full|codex|claude>   model families to enable
                                   Configure Pi enabledModels for selector/cycling (default: full)
   --default-model <provider/model[:thinking]>
-                                  Configure default provider/model/thinking (default: openai-codex/gpt-5.6-sol:high)
+                                  Configure default provider/model/thinking (default: openai-codex/gpt-6-sol:high)
   --no-model-scope               Skip global model-scope configuration
   --install-pi / --no-install-pi Install/skip Pi CLI with npm if `pi` is missing (default: install)
   --force-profile                Replace existing project .pi/piagent-profile.json
@@ -78,7 +78,7 @@ WITH_WEB_ACCESS=true
 WITH_HERDR=true
 CONFIGURE_MODEL_SCOPE=true
 MODEL_SCOPE_PRESET="full"
-DEFAULT_MODEL="openai-codex/gpt-5.6-sol:high"
+DEFAULT_MODEL="openai-codex/gpt-6-sol:high"
 AUTO_INSTALL_PI=true
 FORCE_PROFILE=false
 FORCE_SETTINGS=false

package/scripts/typescript-loader.mjs

@@ -1,7 +1,141 @@
+import crypto from "node:crypto";
 import fs from "node:fs/promises";
+import os from "node:os";
 import { stripTypeScriptTypes } from "node:module";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const BENCHMARK_BOOTSTRAP_METADATA = "PIAGENT_BENCHMARK_BOOTSTRAP_METADATA";
+const RUNTIME_DEPENDENCY_KEYS = [
+  "schemaVersion", "node", "platform", "packages", "resolutionRoot", "resolutionTree", "isolation", "digest"
+];
+const PACKAGE_NAME = /^(?:@[A-Za-z0-9][A-Za-z0-9._~-]*\/)?[A-Za-z0-9][A-Za-z0-9._~-]*$/;
+
+let cachedRuntimeBinding = { encoded: null, value: null };
+
+function record(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function exactKeys(value, keys) {
+  return record(value) && Object.keys(value).length === keys.length
+    && Object.keys(value).every((key) => keys.includes(key));
+}
+
+function inside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+
+function dependencyName(specifier) {
+  if (typeof specifier !== "string" || !specifier || specifier.startsWith(".") || specifier.startsWith("/")
+    || specifier.startsWith("#") || specifier.includes("\\") || /^[A-Za-z][A-Za-z+.-]*:/.test(specifier)) return null;
+  const segments = specifier.split("/");
+  const name = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+  return PACKAGE_NAME.test(name) ? name : null;
+}
+
+function runtimeDependencyError(reason) {
+  const error = new Error(`Benchmark runtime dependency binding rejected: ${reason}`);
+  error.code = "BENCHMARK_RUNTIME_DEPENDENCY_BINDING_REJECTED";
+  return error;
+}
+
+function parseRuntimeBinding(encoded) {
+  let metadata;
+  try { metadata = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8")); }
+  catch { throw runtimeDependencyError("metadata-malformed"); }
+  const value = metadata?.runtimeDependencies;
+  if (metadata?.schemaVersion !== 1 || typeof metadata.snapshotRoot !== "string" || !path.isAbsolute(metadata.snapshotRoot)
+    || !exactKeys(value, RUNTIME_DEPENDENCY_KEYS) || value.schemaVersion !== 2 || value.node !== process.version
+    || value.platform !== `${os.platform()}-${os.arch()}` || !record(value.packages)
+    || typeof value.resolutionRoot !== "string" || !path.isAbsolute(value.resolutionRoot)
+    || path.basename(value.resolutionRoot) !== "node_modules" || typeof value.isolation !== "string"
+    || !/^[a-f0-9]{64}$/.test(String(value.digest ?? ""))
+    || !(value.resolutionTree === null || record(value.resolutionTree))) {
+    throw runtimeDependencyError("metadata-unsupported");
+  }
+  for (const [name, version] of Object.entries(value.packages)) {
+    if (!PACKAGE_NAME.test(name) || !(version === null || typeof version === "string" && version.length > 0)) {
+      throw runtimeDependencyError("package-binding-unsupported");
+    }
+  }
+  const identity = {
+    schemaVersion: value.schemaVersion,
+    node: value.node,
+    platform: value.platform,
+    packages: value.packages,
+    resolutionRoot: value.resolutionRoot,
+    resolutionTree: value.resolutionTree,
+    isolation: value.isolation
+  };
+  const digest = crypto.createHash("sha256").update(JSON.stringify(identity)).digest("hex");
+  if (digest !== value.digest) throw runtimeDependencyError("metadata-digest-mismatch");
+  return { snapshotRoot: metadata.snapshotRoot, ...identity };
+}
+
+async function runtimeBinding() {
+  const encoded = process.env[BENCHMARK_BOOTSTRAP_METADATA];
+  if (!encoded) return null;
+  if (cachedRuntimeBinding.encoded === encoded) return cachedRuntimeBinding.value;
+  const parsed = parseRuntimeBinding(encoded);
+  let snapshotRoot;
+  let resolutionRoot;
+  try {
+    [snapshotRoot, resolutionRoot] = await Promise.all([
+      fs.realpath(parsed.snapshotRoot),
+      fs.realpath(parsed.resolutionRoot)
+    ]);
+  } catch {
+    throw runtimeDependencyError("bound-root-unavailable");
+  }
+  const value = { ...parsed, snapshotRoot, resolutionRoot };
+  cachedRuntimeBinding = { encoded, value };
+  return value;
+}
+
+// The immutable benchmark candidate intentionally has no node_modules tree.
+// Its bootstrap metadata binds the host dependency versions and the one root
+// from which they may resolve. Redirect only a package declared by that
+// binding, only for an importer inside the candidate, and then prove that the
+// selected export remains inside the exact bound package root. This is much
+// narrower than NODE_PATH and leaves normal dashboard/test resolution alone.
+export async function resolve(specifier, context, nextResolve) {
+  const name = dependencyName(specifier);
+  if (!name || !process.env[BENCHMARK_BOOTSTRAP_METADATA]) return nextResolve(specifier, context);
+  const binding = await runtimeBinding();
+  if (!context.parentURL?.startsWith("file:")) return nextResolve(specifier, context);
+  let parent;
+  try { parent = await fs.realpath(fileURLToPath(context.parentURL)); }
+  catch { return nextResolve(specifier, context); }
+  if (!inside(binding.snapshotRoot, parent)) return nextResolve(specifier, context);
+  if (!Object.hasOwn(binding.packages, name)) throw runtimeDependencyError(`package-not-declared:${name}`);
+  const expectedVersion = binding.packages[name];
+  if (typeof expectedVersion !== "string") throw runtimeDependencyError(`package-unavailable:${name}`);
+
+  let packageRoot;
+  let manifest;
+  try {
+    packageRoot = await fs.realpath(path.join(binding.resolutionRoot, ...name.split("/")));
+    manifest = JSON.parse(await fs.readFile(path.join(packageRoot, "package.json"), "utf8"));
+  } catch {
+    throw runtimeDependencyError(`package-unreadable:${name}`);
+  }
+  if (!inside(binding.resolutionRoot, packageRoot) || manifest?.name !== name || manifest?.version !== expectedVersion) {
+    throw runtimeDependencyError(`package-identity-mismatch:${name}`);
+  }
+
+  const resolution = await nextResolve(specifier, {
+    ...context,
+    parentURL: pathToFileURL(path.join(path.dirname(binding.resolutionRoot), ".piagent-benchmark-runtime-resolver.mjs")).href
+  });
+  if (!resolution?.url?.startsWith("file:")) throw runtimeDependencyError(`package-export-invalid:${name}`);
+  let target;
+  try { target = await fs.realpath(fileURLToPath(resolution.url)); }
+  catch { throw runtimeDependencyError(`package-export-unreadable:${name}`); }
+  if (!inside(packageRoot, target)) throw runtimeDependencyError(`package-export-escaped:${name}`);
+  return resolution;
+}
 
 // Repository TypeScript must remain erasable: the integrity lock hashes the
 // source bytes and `strip` fails closed if a future change needs codegen.

package/scripts/update-global.mjs

@@ -402,6 +402,12 @@ function main() {
   const manifest = readJson(path.join(platformRoot, "package.json"));
   if (!manifest?.version) fail(`cannot read the helper package at ${platformRoot}`);
   const currentHelper = manifest.version;
+  if (!options.check && !options.dryRun && !runningFromGlobalInstall()) {
+    fail(`this command updates the npm-global helper, but it is running from ${platformRoot}.\n`
+      + "From a checkout, update with git and install from it:\n"
+      + `  git -C ${platformRoot} pull\n`
+      + `  bash ${path.join(platformRoot, "scripts/install-global.sh")} --local`);
+  }
   const currentHost = installedHostVersion();
 
   const targetHelper = options.version ?? npmView(HELPER_PACKAGE, "version");
@@ -439,13 +445,6 @@ function main() {
     return;
   }
 
-  if (!options.dryRun && !runningFromGlobalInstall()) {
-    fail(`this command updates the npm-global helper, but it is running from ${platformRoot}.\n`
-      + "From a checkout, update with git and install from it:\n"
-      + `  git -C ${platformRoot} pull\n`
-      + `  bash ${path.join(platformRoot, "scripts/install-global.sh")} --local`);
-  }
-
   let activePlatformRoot = platformRoot;
   const npmTarget = resolveNpmInstallTarget(options, hostNeedsChange || helperNeedsChange);
   if (npmTarget.bin) prependPath(npmTarget.bin);

package/scripts/verify-local.sh

@@ -3,14 +3,17 @@ set -euo pipefail
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 OFFLINE=false
+KEEP_GOING=false
+failed_commands=()
 
 usage() {
   cat <<'USAGE'
 Usage:
-  scripts/verify-local.sh [--offline]
+  scripts/verify-local.sh [--offline] [--keep-going]
 
 Options:
   --offline   Skip checks that require a local Pi login/model catalog.
+  --keep-going  Run all build/test groups after a group fails; retain a failing final exit.
 USAGE
 }
 
@@ -20,6 +23,10 @@ while [[ $# -gt 0 ]]; do
       OFFLINE=true
       shift
       ;;
+    --keep-going)
+      KEEP_GOING=true
+      shift
+      ;;
     -h|--help)
       usage
       exit 0
@@ -402,6 +409,7 @@ required_files=(
   "$ROOT/tests/piagent-webui-session-runtime-spike.test.mjs"
   "$ROOT/tests/piagent-webui-gateway.test.mjs"
   "$ROOT/tests/piagent-webui-session-metadata.test.mjs"
+  "$ROOT/tests/piagent-webui-session-runtime-factory.test.mjs"
   "$ROOT/tests/piagent-webui-session-lease-runtime.test.mjs"
   "$ROOT/tests/piagent-webui-session-command-admission.test.mjs"
   "$ROOT/tests/piagent-webui-gateway-transport.test.mjs"
@@ -488,6 +496,10 @@ required_files=(
   "$ROOT/evals/private-holdout-v1/access-policy.v1.json"
   "$ROOT/evals/private-holdout-v1/human-rubric.v1.json"
   "$ROOT/evals/private-holdout-v1/public-exposure.v1.json"
+  "$ROOT/evals/private-holdout-v1/public-exposure.v2.json"
+  "$ROOT/evals/private-holdout-v1/CURRENT_BOUNDARY.md"
+  "$ROOT/scripts/public-evaluation-exposure.mjs"
+  "$ROOT/tests/public-evaluation-exposure.test.mjs"
   "$ROOT/evals/private-holdout-v1/README.md"
   "$ROOT/evals/private-holdout-v1/CUSTODIAN_RUNBOOK.md"
   "$ROOT/evals/fs4-readiness-matrix.v1.json"
@@ -507,6 +519,10 @@ required_files=(
   "$ROOT/benchmarks/production-v1/suite.json"
   "$ROOT/benchmarks/production-v1/grade.mjs"
   "$ROOT/benchmarks/production-v1/variant.mjs"
+  "$ROOT/benchmarks/production-v2/suite.json"
+  "$ROOT/benchmarks/production-v2/grade.mjs"
+  "$ROOT/benchmarks/production-v2/variant.mjs"
+  "$ROOT/benchmarks/production-v2/spend-control.v1.json"
   "$ROOT/tests/capability-sources.test.mjs"
   "$ROOT/packages/piagent-core/capabilities/capability-sources.js"
   "$ROOT/packages/piagent-core/extensions/guard-shell-analysis.ts"
@@ -625,9 +641,9 @@ if (!rootPkg.pi.subagents?.agents?.length) {
   throw new Error("root package.json missing pi.subagents.agents");
 }
 const expectedPeers = {
-  "@earendil-works/pi-ai": "0.84.1",
-  "@earendil-works/pi-coding-agent": "0.84.1",
-  typebox: "1.3.7"
+  "@earendil-works/pi-ai": "0.87.1",
+  "@earendil-works/pi-coding-agent": "0.87.1",
+  typebox: "1.3.27"
 };
 for (const [name, version] of Object.entries(expectedPeers)) {
   if (rootPkg.peerDependencies?.[name] !== version) throw new Error(`root package peer ${name} must be pinned to ${version}`);
@@ -677,8 +693,13 @@ run_quietly() {
   if ! output="$(cd "$ROOT" && "$@" 2>&1)"; then
     printf '%s\n' "$output" >&2
     echo "$label failed; the output above is why" >&2
-    exit 1
+    failed_commands+=("$label")
+    if [[ "$KEEP_GOING" != true ]]; then
+      exit 1
+    fi
+    return 0
   fi
+  echo "PASS: $label"
 }
 
 require_documented "auth.json" "$ROOT/docs" "$ROOT/packages/piagent-core" "$ROOT/templates"
@@ -854,55 +875,9 @@ if [[ -n "$non_text_sources" ]]; then
   exit 1
 fi
 
-public_wording_pattern="$(
-  node --input-type=module <<'NODE'
-const terms = [
-  ["platform-", "mig", "ration"].join(""),
-  ["codex-", "mig", "ration"].join(""),
-  ["codex-", "par", "ity"].join(""),
-  ["benchmark-", "par", "ity"].join(""),
-  ["harness-", "mig", "ration"].join(""),
-  ["agent-", "stuff"].join(""),
-  ["mit", "suhiko"].join(""),
-  ["Cod", "ex CLI"].join(""),
-  ["Claude", " CLI"].join(""),
-  ["Claude", " Code"].join(""),
-  ["claude", " mcp"].join(""),
-  ["codex", " mcp"].join(""),
-  ["Cod", "ex-inspired"].join(""),
-  ["Cod", "ex-grade"].join(""),
-  ["Pi vs ", "Codex"].join(""),
-  ["vs ", "Claude"].join(""),
-  ["reference ", "repo"].join(""),
-  ["repo ", "tham ", "khảo"].join(""),
-  ["nguồn ", "tham ", "khảo"].join(""),
-  ["tham ", "khảo"].join("")
-];
-const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-console.log(terms.map(escapeRegex).join("|"));
-NODE
-)"
-
-# Every surface an outsider reads: the published docs, the site, and the strings
-# the runtime prints back at an operator. The site is checked at its source,
-# since `build-docs-site.mjs --check` separately proves the committed pages match
-# it; the builder itself is listed too, because navigation labels and page titles
-# live there rather than in a content fragment.
-if grep -R -E -i \
-  "$public_wording_pattern" \
-  "$ROOT/README.md" \
-  "$ROOT/docs" \
-  "$ROOT/docs-site/content" \
-  "$ROOT/scripts/build-docs-site.mjs" \
-  "$ROOT/packages/piagent-core/README.md" \
-  "$ROOT/packages/piagent-core/prompts" \
-  "$ROOT/packages/piagent-core/mcp" \
-  "$ROOT/packages/piagent-core/extensions" \
-  "$ROOT/packages/piagent-core/runtime" \
-  "$ROOT/templates/project/AGENTS.md" >/dev/null; then
-  echo "Public docs contain non-neutral platform wording"
-  exit 1
-fi
+# Preserve exact source names only in reviewed research records; product and
+# operator surfaces retain the complete neutrality policy.
+node "$ROOT/scripts/check-public-wording.mjs"
 
 node --check "$ROOT/packages/piagent-core/extensions/piagent-guard.ts" >/dev/null
 node --check "$ROOT/packages/piagent-core/extensions/context-engine.js" >/dev/null
@@ -944,7 +919,9 @@ node "$ROOT/scripts/check-doc-languages.mjs" >/dev/null
 node "$ROOT/scripts/verify-translation-pairing.mjs" >/dev/null
 node "$ROOT/scripts/check-third-party-neutrality.mjs" >/dev/null
 run_quietly "npm run build --workspace @piagent/webui" npm run build --workspace @piagent/webui
-run_quietly "npm test" npm test
+# Integration files each own a real SDK and may run bounded worker processes.
+# Limit competing files without changing selection, assertions or deadlines.
+run_quietly "node --test --test-concurrency=2 tests/*.test.mjs" env PIAGENT_NO_UPDATE_CHECK=1 node --test --test-concurrency=2 "$ROOT"/tests/*.test.mjs
 run_quietly "npm run test:webui:e2e" npm run test:webui:e2e
 if [[ -x "$ROOT/node_modules/.bin/tsc" ]]; then
   run_quietly "npm run typecheck" npm run typecheck
@@ -968,7 +945,7 @@ if [[ "$OFFLINE" == true || "${PIAGENT_VERIFY_OFFLINE:-}" == "1" || "${CI:-}" ==
 else
   bash "$ROOT/scripts/pi-model-catalog.sh" --json >/dev/null
 fi
-bash "$ROOT/scripts/configure-model-scope.sh" --dry-run --preset full --default-model openai-codex/gpt-5.6-sol:high >/dev/null
+bash "$ROOT/scripts/configure-model-scope.sh" --dry-run --preset full --default-model openai-codex/gpt-6-sol:high >/dev/null
 node "$ROOT/scripts/mcp-manage.mjs" --list >/dev/null
 node "$ROOT/scripts/mcp-manage.mjs" --dry-run --preset popular --scope project --project "$ROOT" >/dev/null
 node --input-type=module - "$ROOT" <<'NODE'
@@ -1035,4 +1012,8 @@ bash "$ROOT/scripts/profile-doctor.sh" "$ROOT" "$ROOT/adapters/python/profile.js
 bash "$ROOT/scripts/profile-doctor.sh" "$ROOT" "$ROOT/adapters/web-frontend/profile.json" >/dev/null
 bash "$ROOT/scripts/team-doctor.sh" "$ROOT" --strict-share >/dev/null
 
+if [[ ${#failed_commands[@]} -gt 0 ]]; then
+  printf 'FAIL: %s\n' "${failed_commands[@]}" >&2
+  exit 1
+fi
 echo "PASS: piagent-platform scaffold is complete"

package/scripts/verify-release-identity.mjs

@@ -58,7 +58,7 @@ const packageLock = readJson("package-lock.json");
 const capabilityLock = readJson(".pi/piagent-profile.lock.json");
 const version = rootPackage.version;
 const expectedTag = `v${version}`;
-const supportedPiHost = "0.84.1";
+const supportedPiHost = "0.87.1";
 
 // The package is published now, so the old private-forever rule is gone. What
 // still has to hold is that a scoped package cannot reach the registry as
@@ -75,9 +75,11 @@ if (!version?.includes("-") && rootPackage.publishConfig?.tag !== undefined) fai
 if (rootPackage.repository?.url !== "git+https://github.com/Vt-mmm/piagent.git") fail("root package repository URL is not canonical");
 if (corePackage.repository?.url !== rootPackage.repository.url) fail("core package repository URL does not match the root package");
 const runtimeDependencies = rootPackage.dependencies ?? {};
-if (JSON.stringify(runtimeDependencies) !== JSON.stringify({ ws: "8.21.3" })) {
-  fail("root package runtime dependencies must contain only the pinned local Gateway WebSocket transport");
+if (JSON.stringify(runtimeDependencies) !== JSON.stringify({ "@babel/parser": "7.29.8", ws: "8.21.3" })) {
+  fail("root package runtime dependencies must contain only the pinned syntax parser and local Gateway WebSocket transport");
 }
+if (JSON.stringify(packageLock.packages?.[""]?.dependencies) !== JSON.stringify(runtimeDependencies)) fail("package-lock runtime dependencies do not match package.json");
+if (packageLock.packages?.["node_modules/@babel/parser"]?.version !== runtimeDependencies["@babel/parser"]) fail("syntax parser lock version does not match the runtime pin");
 if (packageLock.name !== rootPackage.name || packageLock.packages?.[""]?.name !== rootPackage.name) fail("package-lock root identity does not match package.json");
 if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version ?? "")) fail("package.json version is not a supported release version");
 if (corePackage.version !== version) fail("root and core package versions do not match");

package/templates/global/settings.json

@@ -1,7 +1,7 @@
 {
   "defaultProjectTrust": "ask",
   "defaultProvider": "openai-codex",
-  "defaultModel": "gpt-5.6-sol",
+  "defaultModel": "gpt-6-sol",
   "defaultThinkingLevel": "high",
   "showCacheMissNotices": true,
   "enabledModels": [
@@ -12,6 +12,10 @@
     "openai-codex/gpt-5.6-luna:medium",
     "openai-codex/gpt-5.6-terra:high",
     "openai-codex/gpt-5.6-sol:high",
+    "openai-codex/gpt-6-luna:medium",
+    "openai-codex/gpt-6-sol:medium",
+    "openai-codex/gpt-6-sol:high",
+    "openai-codex/gpt-6-astra:xhigh",
     "openai-codex/*",
     "anthropic/claude-haiku-4-5:low",
     "anthropic/claude-sonnet-4-5:high",