@piagent/platform 1.6.1 → 1.7.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/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.86.1",
+  "@earendil-works/pi-coding-agent": "0.86.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
@@ -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.86.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");