@piagent/platform 1.6.1 → 1.7.1

package/evals/long-horizon-v1/runner.mjs

@@ -5,6 +5,9 @@ import os from "node:os";
 import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { collectBenchmarkCandidate } from "../../packages/piagent-core/benchmark/benchmark-candidate.js";
+import { checkpointDirectory, checkpointDigest, readCheckpoint, writeCheckpoint, writeCheckpointBytes } from "../../packages/piagent-core/benchmark/benchmark-checkpoint.js";
+import { acquireBenchmarkRunLock } from "../../packages/piagent-core/benchmark/benchmark-run-lock.js";
 
 import { buildContextEfficiencyReport } from "../../packages/piagent-core/extensions/context-engine.js";
 import { recordCompletionAudit, recordTaskStartCheckpoint } from "../../packages/piagent-core/extensions/task-runtime-audit.js";
@@ -12,7 +15,7 @@ import { inspectTaskContinuationBudget, reserveTaskContinuation } from "../../pa
 import { buildHandoffProjection, readHandoffProjection, writeHandoffProjection } from "../../packages/piagent-core/runtime/recovery/handoff-projection.ts";
 import { inspectTaskResumeState } from "../../packages/piagent-core/runtime/recovery/resume-state.ts";
 import { createBoundTaskAuthority } from "../../packages/piagent-core/runtime/policy/task-authority-runtime.ts";
-import { bindSessionTask, workingTreeSnapshot, writeTaskContract } from "../../packages/piagent-core/extensions/task-state.js";
+import { activeSessionTask, bindSessionTask, workingTreeSnapshot, writeTaskContract } from "../../packages/piagent-core/extensions/task-state.js";
 import { readTaskJournal } from "../../packages/piagent-core/extensions/task-journal.js";
 import { workingTreeEvidenceDigest } from "../../packages/piagent-core/extensions/working-tree-digest.js";
 
@@ -25,7 +28,7 @@ const option = (name) => {
   return index >= 0 ? argumentsList[index + 1] : undefined;
 };
 const calibrationFast = argumentsList.includes("--calibration-fast");
-const outputPath = path.resolve(option("--output") ?? path.join(process.cwd(), "long-horizon-report.json"));
+let outputPath = path.resolve(option("--output") ?? path.join(process.cwd(), "long-horizon-report.json"));
 const totalUnits = calibrationFast ? 9 : lane.totalUnits;
 const crashAfterUnit = calibrationFast ? 3 : lane.hardCrashAfterUnit;
 const handoffAfterUnit = calibrationFast ? 6 : lane.handoffAfterUnit;
@@ -33,18 +36,52 @@ const compactionUnits = calibrationFast ? [2, 4, 6, 8] : lane.compactionUnits;
 const tickMilliseconds = calibrationFast ? Number(option("--tick-ms") ?? 2) : lane.tickMilliseconds;
 const evidenceClass = calibrationFast ? "calibration-fast" : "provider-free-long-horizon";
 if (!calibrationFast && option("--tick-ms") !== undefined) throw new Error("wall-clock evidence cannot override tick duration");
+if (!Number.isFinite(tickMilliseconds) || tickMilliseconds < 0) throw new Error("invalid tick duration");
+if (argumentsList.includes("--state-directory") && !option("--state-directory")) throw new Error("--state-directory requires a path");
+fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+outputPath = path.join(fs.realpathSync.native(path.dirname(outputPath)), path.basename(outputPath));
 
-const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "piagent-long-horizon-"));
+const durable = Boolean(option("--state-directory"));
+const temporaryRoot = durable
+  ? checkpointDirectory(path.dirname(path.resolve(option("--state-directory"))), path.basename(path.resolve(option("--state-directory"))))
+  : fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), "piagent-long-horizon-")));
+const releaseCoordinator = acquireBenchmarkRunLock(temporaryRoot, "long-horizon-coordinator");
+const workerRoot = path.join(temporaryRoot, "project/.pi/piagent-state/long-horizon");
+if (fs.existsSync(workerRoot)) {
+  const release = acquireBenchmarkRunLock(workerRoot, "long-horizon-worker-preflight"); release();
+}
+const coordinatorPath = path.join(temporaryRoot, "coordinator.json");
+const sourceDigest = collectBenchmarkCandidate(repositoryRoot).provenance.contentDigest;
+const coordinatorBinding = checkpointDigest({ sourceDigest, node: process.version, platform: process.platform,
+  arch: process.arch, lane, calibrationFast, tickMilliseconds, s0Binding: option("--binding") ?? null });
+let coordinator = readCheckpoint(coordinatorPath, coordinatorBinding);
+if (!coordinator) {
+  if (fs.readdirSync(temporaryRoot).some((name) => name !== ".benchmark-run.lock")) throw new Error("unbound long-horizon state directory is not empty");
+  coordinator = { phase: "initializing", startedAt: new Date().toISOString(), observations: {} };
+  writeCheckpoint(coordinatorPath, coordinatorBinding, coordinator);
+}
+function checkpointCoordinator(patch) {
+  coordinator = { ...coordinator, ...patch };
+  writeCheckpoint(coordinatorPath, coordinatorBinding, coordinator);
+}
+if (coordinator.phase === "complete") {
+  writeCheckpointBytes(outputPath, `${JSON.stringify(coordinator.report, null, 2)}\n`);
+  releaseCoordinator();
+  process.stdout.write(`${JSON.stringify(coordinator.report)}\n`);
+  process.exit(0);
+}
 const workspace = path.join(temporaryRoot, "project");
-const startedAtMs = Date.now();
-const startedAt = new Date(startedAtMs).toISOString();
+const startedAt = coordinator.startedAt;
+const startedAtMs = Date.parse(startedAt);
 const fixture = path.resolve(laneRoot, lane.fixture);
+if (coordinator.phase === "initializing") {
 fs.cpSync(fixture, workspace, { recursive: true });
-spawnSync("git", ["init", "-q", workspace], { stdio: "inherit" });
-spawnSync("git", ["-C", workspace, "config", "user.email", "long-horizon@example.invalid"], { stdio: "inherit" });
-spawnSync("git", ["-C", workspace, "config", "user.name", "Piagent Long Horizon"], { stdio: "inherit" });
-spawnSync("git", ["-C", workspace, "add", "."], { stdio: "inherit" });
-spawnSync("git", ["-C", workspace, "commit", "-qm", "fixture"], { stdio: "inherit" });
+for (const args of [["init", "-q", workspace], ["-C", workspace, "config", "user.email", "long-horizon@example.invalid"],
+  ["-C", workspace, "config", "user.name", "Piagent Long Horizon"], ["-C", workspace, "add", "."],
+  ["-C", workspace, "commit", "--allow-empty", "-qm", "fixture"]]) {
+  assert.equal(spawnSync("git", args, { stdio: "inherit" }).status, 0, "fixture Git initialization failed");
+}
+}
 
 const taskId = "long-horizon-90";
 const taskRunId = "long-horizon-90-run-1";
@@ -53,8 +90,10 @@ const sessionName = "LONG-HORIZON-90 repository audit";
 const createdAt = startedAt;
 const portableVerifier = path.join(workspace, ".pi", "piagent-state", "long-horizon", "verify.mjs");
 fs.mkdirSync(path.dirname(portableVerifier), { recursive: true, mode: 0o700 });
-fs.copyFileSync(path.join(laneRoot, "verify.mjs"), portableVerifier);
-fs.chmodSync(portableVerifier, 0o600);
+if (coordinator.phase === "initializing") {
+  fs.copyFileSync(path.join(laneRoot, "verify.mjs"), portableVerifier);
+  fs.chmodSync(portableVerifier, 0o600);
+}
 let task = {
   schemaVersion: 2,
   taskRunId,
@@ -106,10 +145,16 @@ let task = {
   createdAt,
   updatedAt: createdAt
 };
-task.authoritySnapshot = createBoundTaskAuthority({ taskId, taskRunId, createdAt });
-task = writeTaskContract(workspace, task);
-bindSessionTask(workspace, sessionId, sessionName, task);
-recordTaskStartCheckpoint({ cwd: workspace, ui: { notify() {} } }, task, "discovery", "automatic");
+if (coordinator.phase === "initializing") {
+  task.authoritySnapshot = createBoundTaskAuthority({ taskId, taskRunId, createdAt });
+  task = writeTaskContract(workspace, task);
+  bindSessionTask(workspace, sessionId, sessionName, task);
+  recordTaskStartCheckpoint({ cwd: workspace, ui: { notify() {} } }, task, "discovery", "automatic");
+  checkpointCoordinator({ phase: "crash" });
+} else {
+  task = activeSessionTask(workspace, sessionId);
+  assert.equal(task?.taskRunId, taskRunId, "durable task binding changed");
+}
 
 const runtimeBase = {
   laneId: lane.id,
@@ -119,7 +164,8 @@ const runtimeBase = {
   totalUnits,
   logicalDurationMinutes: lane.logicalDurationMinutes,
   compactionUnits,
-  tickMilliseconds
+  tickMilliseconds,
+  coordinatorBinding
 };
 const workerPath = path.join(laneRoot, "worker.mjs");
 const statePath = path.join(workspace, ".pi", "piagent-state", "long-horizon", "state.json");
@@ -129,23 +175,17 @@ function state() {
   catch (error) { if (error?.code === "ENOENT") return { currentUnit: 0 }; throw error; }
 }
 
-function startWorker(stopAfterUnit) {
-  const runtime = Buffer.from(JSON.stringify({ ...runtimeBase, stopAfterUnit })).toString("base64url");
-  const child = spawn(process.execPath, [workerPath, workspace, runtime], { stdio: ["ignore", "pipe", "pipe"] });
+function startWorker(stopAfterUnit, crashBoundary) {
+  const runtime = Buffer.from(JSON.stringify({ ...runtimeBase, stopAfterUnit, crashBoundary })).toString("base64url");
+  const child = spawn(process.execPath, [workerPath, workspace, runtime], { stdio: ["ignore", "pipe", "pipe", "ipc"] });
   let stdout = "", stderr = "";
   child.stdout.on("data", (chunk) => { stdout += chunk; });
   child.stderr.on("data", (chunk) => { stderr += chunk; });
-  return { child, result: new Promise((resolve) => child.once("exit", (code, signal) => resolve({ code, signal, stdout, stderr }))) };
-}
-
-async function waitForUnit(unit) {
-  const remaining = Math.max(1, unit - Number(state().currentUnit ?? 0));
-  const deadline = Date.now() + Math.max(30_000, tickMilliseconds * (remaining + 2));
-  while (Date.now() < deadline) {
-    if (state().currentUnit >= unit) return;
-    await new Promise((resolve) => setTimeout(resolve, Math.min(100, Math.max(5, tickMilliseconds / 20))));
-  }
-  throw new Error(`timed out waiting for long-horizon unit ${unit}`);
+  const result = new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve({ code, signal, stdout, stderr }));
+  });
+  return { child, result };
 }
 
 function updatePendingTask(completed, active) {
@@ -182,15 +222,25 @@ function persistHandoff(reason) {
   return readHandoffProjection(workspace, taskRunId);
 }
 
-const first = startWorker(undefined);
-await waitForUnit(crashAfterUnit);
-first.child.kill("SIGKILL");
-const firstResult = await first.result;
-assert.equal(firstResult.signal, "SIGKILL", firstResult.stderr);
-assert.equal(state().currentUnit, crashAfterUnit);
+if (coordinator.phase === "crash") {
+  const first = startWorker(undefined, crashAfterUnit);
+  const atBoundary = new Promise((resolve) => first.child.once("message", resolve));
+  const observed = await Promise.race([atBoundary, first.result.then((result) => { throw new Error(`worker stopped before crash boundary: ${result.stderr}`); })]);
+  assert.deepEqual(observed, { type: "crash-boundary", unit: crashAfterUnit });
+  first.child.kill("SIGKILL");
+  const firstResult = await first.result;
+  assert.equal(firstResult.signal, "SIGKILL", firstResult.stderr);
+  assert.equal(state().currentUnit, crashAfterUnit);
+  checkpointCoordinator({ phase: "crash-recovery", observations: { hardCrash: { signal: firstResult.signal, unit: crashAfterUnit } } });
+}
+let firstContinuation = coordinator.observations.firstContinuation;
+let secondContinuation = coordinator.observations.secondContinuation;
+let crashHandoff = coordinator.observations.crashHandoff;
+let plannedHandoff = coordinator.observations.plannedHandoff;
+if (coordinator.phase === "crash-recovery") {
 updatePendingTask("discovery", "validation");
 const crashDigest = workingTreeEvidenceDigest(workingTreeSnapshot(workspace));
-const firstContinuation = reserveTaskContinuation(workspace, task, {
+const reservation = reserveTaskContinuation(workspace, task, {
   capabilityId: "CAP-12",
   classification: "infrastructure-retry",
   action: "retry",
@@ -198,8 +248,12 @@ const firstContinuation = reserveTaskContinuation(workspace, task, {
   reasonCodes: ["process-killed"],
   recordedAt: new Date().toISOString()
 });
-assert.equal(firstContinuation.allowed, true);
-const secondContinuation = reserveTaskContinuation(workspace, task, {
+assert.ok(reservation.allowed || reservation.reason === "repeated-progress-signature");
+// Re-reading the same consumed reservation does not authorize another turn.
+// The original allow observation is reconstructed only from that exact journal
+// signature, never from an exhausted-but-unrelated budget.
+firstContinuation = { ...reservation, allowed: true };
+secondContinuation = reserveTaskContinuation(workspace, task, {
   capabilityId: "CAP-12",
   classification: "infrastructure-retry",
   action: "retry",
@@ -209,23 +263,32 @@ const secondContinuation = reserveTaskContinuation(workspace, task, {
 });
 assert.equal(secondContinuation.allowed, false);
 assert.equal(secondContinuation.reason, "global-budget-exhausted");
-const crashHandoff = persistHandoff("hard process death at a durable checkpoint");
+crashHandoff = persistHandoff("hard process death at a durable checkpoint");
 assert.equal(crashHandoff?.identity.taskRunId, taskRunId);
 const crashResume = inspectTaskResumeState(workspace, task, sessionId);
 assert.equal(crashResume.enforcementSafe, true, crashResume.reason);
+checkpointCoordinator({ phase: "handoff", observations: { ...coordinator.observations, firstContinuation, secondContinuation, crashHandoff } });
+}
 
+if (coordinator.phase === "handoff") {
 const second = startWorker(handoffAfterUnit);
 const secondResult = await second.result;
 assert.equal(secondResult.code, 75, secondResult.stderr);
 assert.equal(state().currentUnit, handoffAfterUnit);
 updatePendingTask("validation", "synthesis");
-const plannedHandoff = persistHandoff("planned process handoff after validation stage");
+plannedHandoff = persistHandoff("planned process handoff after validation stage");
 assert.equal(plannedHandoff?.identity.taskRunId, taskRunId);
+checkpointCoordinator({ phase: "finish", observations: { ...coordinator.observations, plannedHandoff } });
+}
 
+if (coordinator.phase === "finish") {
 const third = startWorker(undefined);
 const thirdResult = await third.result;
 assert.equal(thirdResult.code, 0, thirdResult.stderr);
 assert.equal(state().currentUnit, totalUnits);
+checkpointCoordinator({ phase: "verify", completedAt: new Date().toISOString() });
+}
+assert.equal(coordinator.phase, "verify", "unknown coordinator phase");
 const beforeVerify = workingTreeEvidenceDigest(workingTreeSnapshot(workspace));
 const verifier = spawnSync(process.execPath, [portableVerifier, workspace, String(totalUnits)], { encoding: "utf8" });
 assert.equal(verifier.status, 0, verifier.stderr);
@@ -233,7 +296,7 @@ const afterVerify = workingTreeEvidenceDigest(workingTreeSnapshot(workspace));
 assert.equal(afterVerify, beforeVerify);
 const finalSnapshot = workingTreeSnapshot(workspace);
 const finalFiles = Object.keys(finalSnapshot).sort();
-const completedAt = new Date().toISOString();
+const completedAt = coordinator.completedAt;
 task = writeTaskContract(workspace, {
   ...task,
   workPlan: task.workPlan.map((step) => ({ ...step, status: "done" })),
@@ -270,11 +333,12 @@ const peakDurableStateBytes = Math.max(finalState.peakDurableStateBytes, finalDu
 const peakContextSample = stateSamples.reduce((peak, sample) => sample.contextProxyTokens > peak.contextProxyTokens ? sample : peak, stateSamples[0]);
 const endedAtMs = Date.now();
 const wallClockMilliseconds = endedAtMs - startedAtMs;
-const completedFromResume = finalState.processStarts === 3
+const completedFromResume = finalState.processStarts >= 3
   && finalState.resumedUnits.includes(crashAfterUnit)
   && finalState.resumedUnits.includes(handoffAfterUnit)
-  && terminalResume.decision === "terminal";
-const wallClockQualified = wallClockMilliseconds >= lane.minimumWallClockMinutes * 60_000;
+  && terminalResume.decision === "terminal"
+  && coordinator.observations.hardCrash.signal === "SIGKILL";
+const wallClockQualified = finalState.activeMilliseconds >= lane.minimumWallClockMinutes * 60_000;
 const report = {
   schemaVersion: 1,
   laneId: lane.id,
@@ -284,6 +348,7 @@ const report = {
   completedAt,
   logicalDurationMinutes: lane.logicalDurationMinutes,
   wallClockMilliseconds,
+  activeMilliseconds: finalState.activeMilliseconds,
   wallClockMinutes: Number((wallClockMilliseconds / 60_000).toFixed(4)),
   minimumWallClockMinutes: lane.minimumWallClockMinutes,
   wallClockQualified,
@@ -350,6 +415,9 @@ assert.equal(report.continuation.maximum, 1);
 assert.equal(report.verification.stableCurrentTree, true);
 if (!calibrationFast) assert.equal(report.wallClockQualified, true, `wall clock ${report.wallClockMinutes}m is below ${lane.minimumWallClockMinutes}m`);
 fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-fs.writeFileSync(outputPath, `${JSON.stringify(report, null, 2)}\n`, { mode: 0o600 });
-fs.rmSync(temporaryRoot, { recursive: true, force: true });
+assert.equal(collectBenchmarkCandidate(repositoryRoot).provenance.contentDigest, sourceDigest, "candidate changed during long-horizon execution");
+checkpointCoordinator({ phase: "complete", report });
+writeCheckpointBytes(outputPath, `${JSON.stringify(report, null, 2)}\n`);
+releaseCoordinator();
+if (!durable) fs.rmSync(temporaryRoot, { recursive: true, force: true });
 process.stdout.write(`${JSON.stringify(report)}\n`);

package/evals/long-horizon-v1/worker.mjs

@@ -2,9 +2,11 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 
-import { appendContextTelemetry, estimateContextTokens } from "../../packages/piagent-core/extensions/context-engine.js";
+import { appendContextTelemetry, contextEnginePaths, estimateContextTokens } from "../../packages/piagent-core/extensions/context-engine.js";
+import { checkpointDigest, readCheckpoint, writeCheckpoint, writeCheckpointBytes } from "../../packages/piagent-core/benchmark/benchmark-checkpoint.js";
+import { acquireBenchmarkRunLock } from "../../packages/piagent-core/benchmark/benchmark-run-lock.js";
 import { ensurePrivateStateDirectory, resolveLocalStatePath } from "../../packages/piagent-core/extensions/local-state-path.js";
-import { appendTaskJournalEvent } from "../../packages/piagent-core/extensions/task-journal.js";
+import { appendTaskJournalEventAtMost } from "../../packages/piagent-core/extensions/task-journal.js";
 import { workingTreeSnapshot } from "../../packages/piagent-core/extensions/task-state.js";
 import { workingTreeEvidenceDigest } from "../../packages/piagent-core/extensions/working-tree-digest.js";
 
@@ -13,6 +15,10 @@ if (!workspaceArgument || !runtimeArgument) throw new Error("worker requires wor
 const workspace = path.resolve(workspaceArgument);
 const runtime = JSON.parse(Buffer.from(runtimeArgument, "base64url").toString("utf8"));
 const privateRoot = ensurePrivateStateDirectory(workspace, path.join(workspace, ".pi", "piagent-state", "long-horizon"), "Long-horizon state");
+const releaseWorker = acquireBenchmarkRunLock(privateRoot, runtime.taskRunId);
+// An orphan must stop before another coordinator starts it. IPC disconnect is
+// an observed loss of the parent, not a timeout-based guess about its liveness.
+if (process.connected) process.once("disconnect", () => process.exit(76));
 const statePath = resolveLocalStatePath(workspace, path.join(privateRoot, "state.json"), { label: "Long-horizon state" });
 const workingSetPath = resolveLocalStatePath(workspace, path.join(privateRoot, "working-set.json"), { label: "Long-horizon working set" });
 const telemetryPath = resolveLocalStatePath(workspace, path.join(privateRoot, "telemetry.jsonl"), { label: "Long-horizon telemetry" });
@@ -28,7 +34,7 @@ function processAlive(pid) {
 
 function removeDeadWriterTemps(directory) {
   for (const name of fs.readdirSync(directory)) {
-    const match = name.match(/\.(\d+)\.tmp$/);
+    const match = name.match(/\.(\d+)(?:\.[a-f0-9-]{36})?\.tmp$/);
     if (!match || processAlive(Number.parseInt(match[1], 10))) continue;
     const target = path.join(directory, name);
     try { if (fs.lstatSync(target).isFile()) fs.rmSync(target); } catch (error) { if (error?.code !== "ENOENT") throw error; }
@@ -44,10 +50,7 @@ function readJson(file, fallback) {
 }
 
 function writeAtomic(file, value, mode = 0o600) {
-  const temporary = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { mode });
-  fs.renameSync(temporary, file);
-  fs.chmodSync(file, mode);
+  writeCheckpointBytes(file, `${JSON.stringify(value)}\n`, mode);
 }
 
 function projectSources() {
@@ -77,18 +80,17 @@ function treeBytes(root) {
   return bytes;
 }
 
-function appendTelemetry(value) {
-  fs.appendFileSync(telemetryPath, `${JSON.stringify(value)}\n`, { mode: 0o600 });
-  fs.chmodSync(telemetryPath, 0o600);
-}
-
 function sleep(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
 const sources = projectSources();
 if (sources.length < runtime.totalUnits) throw new Error(`fixture has only ${sources.length} source files for ${runtime.totalUnits} units`);
-let state = readJson(statePath, {
+const { stopAfterUnit, crashBoundary, ...stableRuntime } = runtime;
+const binding = { runtime: stableRuntime, sources: sources.map((file) => [file, crypto.createHash("sha256").update(fs.readFileSync(path.join(workspace, file))).digest("hex")]) };
+const checkpointPath = path.join(privateRoot, "checkpoint.json");
+const checkpoint = readCheckpoint(checkpointPath, checkpointDigest(binding));
+let state = checkpoint?.state ?? readJson(statePath, {
   schemaVersion: 1,
   laneId: runtime.laneId,
   taskId: runtime.taskId,
@@ -98,14 +100,65 @@ let state = readJson(statePath, {
   compactions: 0,
   peakContextProxyTokens: 0,
   peakDurableStateBytes: 0,
+  activeMilliseconds: 0,
   resumedUnits: []
 });
 if (state.laneId !== runtime.laneId || state.taskId !== runtime.taskId || state.taskRunId !== runtime.taskRunId) throw new Error("long-horizon state identity mismatch");
+if (!checkpoint && state.currentUnit !== 0) throw new Error("legacy long-horizon progress has no atomic checkpoint");
+let workingSet = checkpoint?.workingSet ?? [];
+const telemetry = checkpoint?.telemetry ?? [];
+const contextEvents = checkpoint?.contextEvents ?? [];
+if (telemetry.length !== state.currentUnit || telemetry.some((entry, index) => entry.unit !== index + 1)) throw new Error("invalid long-horizon checkpoint sequence");
+for (let unit = 1; unit <= state.currentUnit; unit += 1) {
+  const actual = readJson(path.join(unitRoot, `${String(unit).padStart(3, "0")}.json`));
+  const [sourcePath, sourceDigest] = binding.sources[unit - 1];
+  if (actual?.unit !== unit || actual.sourcePath !== sourcePath || actual.sourceDigest !== sourceDigest) throw new Error("completed long-horizon artifact changed");
+}
+
+function projectCheckpoint() {
+  writeAtomic(statePath, state);
+  writeAtomic(workingSetPath, workingSet);
+  writeCheckpointBytes(telemetryPath, telemetry.map((entry) => `${JSON.stringify(entry)}\n`).join(""));
+  const contextPath = resolveLocalStatePath(workspace, contextEnginePaths(workspace).telemetry);
+  ensurePrivateStateDirectory(workspace, path.dirname(contextPath));
+  // These events belong only to this owned provider-free fixture. The atomic
+  // checkpoint is authoritative; partial/uncommitted projections are rebuilt.
+  writeCheckpointBytes(contextPath, contextEvents.map((entry) => `${JSON.stringify(entry)}\n`).join(""));
+  // Replay the committed prefix to repair a checkpoint-before-projection crash,
+  // but never append the same unit again. The raw append API does not dedupe.
+  for (const entry of telemetry) {
+    const data = { unit: entry.unit, logicalMinute: entry.unit, sourceDigest: binding.sources[entry.unit - 1][1], currentWorkingTreeDigest: entry.currentWorkingTreeDigest };
+    const { record } = appendTaskJournalEventAtMost(workspace, {
+      eventType: "long-horizon-progress", taskId: runtime.taskId, taskRunId: runtime.taskRunId,
+      sessionId: runtime.sessionId, idempotencyKey: `long-horizon:${entry.unit}`, data
+    }, { maximum: runtime.totalUnits, recordedAt: entry.recordedAt });
+    // A conflicting key or exhausted budget must not silently erase evidence.
+    if (!record || record.taskId !== runtime.taskId || record.sessionId !== runtime.sessionId
+      || record.recordedAt !== entry.recordedAt || JSON.stringify(record.data) !== JSON.stringify(data)) {
+      throw new Error(`long-horizon journal projection mismatch at unit ${entry.unit}`);
+    }
+  }
+}
+
+function commitCheckpoint() {
+  writeCheckpoint(checkpointPath, checkpointDigest(binding), { state, workingSet, telemetry, contextEvents });
+  projectCheckpoint();
+}
+
 const startingUnit = state.currentUnit;
 state.processStarts += 1;
 if (startingUnit > 0) state.resumedUnits.push(startingUnit);
-writeAtomic(statePath, state);
-let workingSet = readJson(workingSetPath, []);
+commitCheckpoint();
+
+async function boundary(unit) {
+  if (unit === crashBoundary) {
+    process.send?.({ type: "crash-boundary", unit });
+    await new Promise(() => { setInterval(() => {}, 1_000); });
+  }
+  if (unit === stopAfterUnit && unit < runtime.totalUnits) process.exit(75);
+}
+await boundary(startingUnit);
+let activeSince = performance.now();
 
 for (let unit = startingUnit + 1; unit <= runtime.totalUnits; unit += 1) {
   const sourcePath = sources[(unit - 1) % sources.length];
@@ -119,19 +172,10 @@ for (let unit = startingUnit + 1; unit <= runtime.totalUnits; unit += 1) {
   if (runtime.compactionUnits.includes(unit)) {
     workingSet = [{ unit, compactedThrough: unit, retainedDigest: crypto.createHash("sha256").update(JSON.stringify(workingSet)).digest("hex") }];
     state.compactions += 1;
-    appendContextTelemetry(workspace, { event: "session_compact", taskRunId: runtime.taskRunId, unit, reason: "long-horizon-boundary", fromExtension: true });
+    contextEvents.push(appendContextTelemetry(workspace, { event: "session_compact", taskRunId: runtime.taskRunId, unit, reason: "long-horizon-boundary", fromExtension: true }));
   }
-  writeAtomic(workingSetPath, workingSet);
   const currentWorkingTreeDigest = workingTreeEvidenceDigest(workingTreeSnapshot(workspace));
-  appendTaskJournalEvent(workspace, {
-    eventType: "long-horizon-progress",
-    taskId: runtime.taskId,
-    taskRunId: runtime.taskRunId,
-    sessionId: runtime.sessionId,
-    idempotencyKey: `long-horizon:${unit}`,
-    data: { unit, logicalMinute: unit, sourceDigest, currentWorkingTreeDigest }
-  }, { recordedAt: new Date().toISOString() });
-  appendContextTelemetry(workspace, {
+  contextEvents.push(appendContextTelemetry(workspace, {
     event: "agent_prompt",
     taskRunId: runtime.taskRunId,
     unit,
@@ -140,13 +184,14 @@ for (let unit = startingUnit + 1; unit <= runtime.totalUnits; unit += 1) {
     toolSchemaTokens: 872,
     contextProxyTokens: beforeCompactionTokens,
     source: "deterministic-provider-free-proxy"
-  });
+  }));
   const durableStateBytes = treeBytes(path.join(workspace, ".pi", "piagent-state"));
   state.currentUnit = unit;
   state.peakDurableStateBytes = Math.max(state.peakDurableStateBytes, durableStateBytes);
   state.lastWorkingTreeDigest = currentWorkingTreeDigest;
   state.updatedAt = new Date().toISOString();
-  appendTelemetry({
+  state.activeMilliseconds += performance.now() - activeSince;
+  telemetry.push({
     schemaVersion: 1,
     recordedAt: state.updatedAt,
     processId: process.pid,
@@ -158,8 +203,9 @@ for (let unit = startingUnit + 1; unit <= runtime.totalUnits; unit += 1) {
     compactions: state.compactions,
     currentWorkingTreeDigest
   });
-  writeAtomic(statePath, state);
-  if (unit === runtime.stopAfterUnit && unit < runtime.totalUnits) process.exit(75);
+  commitCheckpoint();
+  activeSince = performance.now();
+  await boundary(unit);
   if (unit < runtime.totalUnits) await sleep(runtime.tickMilliseconds);
 }
 
@@ -174,4 +220,5 @@ writeAtomic(path.join(artifactRoot, "report.json"), {
   logicalDurationMinutes: runtime.logicalDurationMinutes,
   aggregateDigest: aggregate.digest("hex")
 }, 0o644);
+releaseWorker();
 process.exit(0);

package/evals/private-holdout-v1/CURRENT_BOUNDARY.md

@@ -0,0 +1,53 @@
+# Current public exposure boundary
+
+Use `public-exposure.v2.json` for a new custody review. The v1 file and
+`CUSTODIAN_RUNBOOK.md` are retained historical inputs, not a complete current
+exposure inventory. All role separation, private-data restrictions, reference
+and mutation checks, blinded review and independent attestation requirements
+in that runbook remain mandatory. Its step 1 must now bind the v2 exposure file.
+
+The earlier file omitted the public `deep-logic-v1` and `production-v2` suites.
+V2 now includes all seven current public suites (93 scenarios), including
+`production-v3`, all 13 contract-family versions and nine public development
+trees, including test programs and author-written calibration examples. The
+predecessor digest preserves prior exposure. These counts are inventory counts,
+not executed or passing sessions.
+
+Before custody review, check the complete public source tree, including its
+development tests. The runtime npm package intentionally omits those tests and
+cannot establish inventory freshness alone; use the exact frozen source bundle
+or checkout, without substituting a current checkout for a different candidate:
+
+```text
+node scripts/public-evaluation-exposure.mjs --check
+```
+
+The maintainer may regenerate the inventory with `--write` after public source
+changes. Generation grants no authority: a changed digest requires a new
+independent lineage comparison and custody receipt. Do not edit an existing
+custody receipt to substitute the new digest. The current readiness CLI and
+FS4 evaluator refuse stale or incomplete inventories. Old v1-bound receipts
+remain historical metadata, not current readiness.
+
+Tree digests cover pairs of repository-relative filename and file SHA-256.
+Flatten every regular file in the tree first, using slash-separated relative
+paths. Globally sort those paths by UTF-16 code units (not locale or directory
+traversal order), serialize the ordered pair array as compact JSON without a
+trailing newline, then hash its UTF-8 bytes. Do not normalize filenames.
+Changing a fixture without changing its suite manifest, adding a
+public test or altering a contract library invalidates the inventory. Symlinked
+and oversized inputs are refused. These are local filesystem checks, not a
+security sandbox against another actor with the same OS privileges; freeze
+and independently verify the exact candidate artifact in the controlled
+environment before and after private execution.
+
+The inventory is not a complete record of author knowledge. Independently
+account for previous diagnostic replays, retained campaigns and any material
+outside these public roots. Compare actual lineage and acceptance mechanisms,
+not just names or hashes. Never bring private prompts, graders, repositories,
+reviewer identities or raw scores into the author environment. Only the closed
+assurance receipt and independent custody attestation may cross that boundary.
+
+`ready: true` still grants no provider execution, generalization or release
+claim. Independent custody and the remaining exact-candidate release gates
+remain separate requirements.

package/evals/private-holdout-v1/README.md

@@ -4,14 +4,17 @@ This directory contains only the public, provider-free boundary for `CF-FS4-04`.
 It does not contain a holdout suite, private repository, prompt, grader, oracle,
 reference solution, reviewer identity, raw score sheet, or private locator.
 
-The operational handoff is documented in `CUSTODIAN_RUNBOOK.md`. The readiness
+The current operational handoff starts with `CURRENT_BOUNDARY.md`, which
+supersedes the old exposure-file binding without changing the retained v1
+history. The remaining custody procedure is in `CUSTODIAN_RUNBOOK.md`. The readiness
 CLI checks the closed receipt, while the independent FS4-05 auditor must verify
 its custody origin outside this repository; authors cannot self-attest E3.
 
 The external custodian must:
 
 1. compare every private task-family lineage and repository lineage with
-   `public-exposure.v1.json` inside the controlled environment;
+   the current `public-exposure.v2.json`, its predecessor and the declared public
+   development trees inside the controlled environment;
 2. keep candidate authors outside the custodian, reviewer, and adjudicator roles;
 3. expose an execute-only interface to the benchmark operator after an exact RC
    is frozen;