@piagent/platform 1.6.0 → 1.6.1

package/packages/piagent-webui/server/core-inspection-provider.ts

@@ -236,6 +236,7 @@ export class CoreInspectionProvider implements WebUiReadModelProvider {
   }
   async transcript(beforeCursor: string | null, limit: number): Promise<unknown> {
     const snapshot = await this.snapshot() as any;
+    const activeTask = this.#input.task?.() as any;
     return projectTranscript({ identity: { projectRef: snapshot.identity.projectRef, runtimeInstanceId: snapshot.identity.runtimeInstanceId,
       sessionRef: snapshot.identity.sessionRef, taskId: snapshot.identity.taskId, taskRunId: snapshot.identity.taskRunId, agentOperationId: null, toolCallId: null },
       revision: { runtimeRevision: snapshot.revision.runtimeRevision, taskRevision: snapshot.revision.taskRevision,
@@ -243,7 +244,7 @@ export class CoreInspectionProvider implements WebUiReadModelProvider {
         indexRevision: snapshot.revision.indexRevision, approvalRevision: snapshot.revision.approvalRevision,
         sessionOptionRevision: snapshot.revision.sessionOptionRevision, queueRevision: snapshot.revision.queueRevision },
       eventCursor: snapshot.revision.eventCursor, entries: this.#input.sessionEntries?.() ?? [], beforeCursor, limit,
-      generatedAt: snapshot.generatedAt });
+      generatedAt: snapshot.generatedAt, taskOutcome: typeof activeTask?.trace?.outcome === "string" ? activeTask.trace.outcome : null });
   }
   async queue(): Promise<unknown> {
     if (!this.#input.queueProjection) throw new ReadModelNotFound();

package/packages/piagent-webui/server/transcript-projection.ts

@@ -32,6 +32,7 @@ export type TranscriptProjectionInput = {
   beforeCursor?: string | null;
   limit?: number;
   generatedAt?: string;
+  taskOutcome?: string | null;
 };
 
 function hash(value: string): string { return createHash("sha256").update(value).digest("hex"); }
@@ -159,6 +160,89 @@ function item(entry: any, identity: TranscriptIdentity): TranscriptItem | null {
     agentOperationId: null, turnIndex: null, content, ...(userProjection.attachments.length ? { attachments: userProjection.attachments } : {}),
     toolCalls: projectedToolCalls };
 }
+
+type ProjectedTranscriptItem = { entry: any; item: TranscriptItem; cursor: string };
+
+function linkTranscriptTurns(values: ProjectedTranscriptItem[]): ProjectedTranscriptItem[] {
+  let userMessageRef: string | null = null;
+  const toolCallOwners = new Map<string, string>();
+  return values.map((value) => {
+    let parentMessageRef: string | null = null;
+    if (value.item.role === "user") userMessageRef = value.item.messageRef;
+    else if (value.item.role === "tool-result") {
+      parentMessageRef = toolCallOwners.get(value.item.toolCalls[0]?.toolCallRef ?? "") ?? userMessageRef;
+    } else parentMessageRef = userMessageRef;
+    const linked = { ...value, item: { ...value.item, parentMessageRef } };
+    if (linked.item.role === "assistant") {
+      for (const toolCall of linked.item.toolCalls) toolCallOwners.set(toolCall.toolCallRef, linked.item.messageRef);
+    }
+    return linked;
+  });
+}
+
+function suppressOpenTaskHandoff(values: ProjectedTranscriptItem[], taskOutcome: string | null | undefined): ProjectedTranscriptItem[] {
+  if (taskOutcome !== "pending") return values;
+  let latestUser = -1;
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    if (values[index]?.item.role === "user") { latestUser = index; break; }
+  }
+  if (latestUser < 0) return values;
+  return values.map((value, index) => {
+    if (index <= latestUser || value.item.role !== "assistant" || value.item.toolCalls.length > 0
+      || !["available", "redacted"].includes(value.item.content.state)) return value;
+    return { ...value, item: { ...value.item, content: unavailableContent("assistant-task-pending") } };
+  });
+}
+
+function durableAssistant(item: TranscriptItem): boolean {
+  return item.role === "assistant" && item.toolCalls.length === 0
+    && (item.content.state === "available" || item.content.state === "redacted")
+    && hasVisibleText(item.content.text ?? "");
+}
+
+function compactOversizedTurn(
+  values: ProjectedTranscriptItem[], start: number, end: number, limit: number
+): ProjectedTranscriptItem[] {
+  if (limit === 1) return [values[start]!];
+  const selected = new Set<number>([start]);
+  for (let index = end - 1; index > start; index -= 1) {
+    if (durableAssistant(values[index]!.item)) { selected.add(index); break; }
+  }
+  for (let index = end - 1; index > start && selected.size < limit; index -= 1) selected.add(index);
+  return [...selected].sort((left, right) => left - right).map((index) => values[index]!);
+}
+
+function boundedTurnPage(
+  values: ProjectedTranscriptItem[], end: number, limit: number
+): { selected: ProjectedTranscriptItem[]; start: number; compacted: boolean } {
+  if (end <= 0) return { selected: [], start: 0, compacted: false };
+  const users: number[] = [];
+  for (let index = 0; index < end; index += 1) if (values[index]?.item.role === "user") users.push(index);
+  if (users.length === 0) {
+    const start = Math.max(0, end - limit);
+    return { selected: values.slice(start, end), start, compacted: false };
+  }
+
+  const selected: ProjectedTranscriptItem[] = [];
+  let remaining = limit, turnEnd = end, start = end;
+  for (let userIndex = users.length - 1; userIndex >= 0 && remaining > 0; userIndex -= 1) {
+    const turnStart = users[userIndex]!;
+    const turnSize = turnEnd - turnStart;
+    if (turnSize > remaining) {
+      if (selected.length === 0) {
+        const compacted = compactOversizedTurn(values, turnStart, turnEnd, remaining);
+        return { selected: compacted, start: turnStart, compacted: true };
+      }
+      break;
+    }
+    selected.unshift(...values.slice(turnStart, turnEnd));
+    start = turnStart;
+    remaining -= turnSize;
+    turnEnd = turnStart;
+  }
+  return { selected, start, compacted: false };
+}
+
 function unavailable(input: TranscriptProjectionInput, reasonCode: string, limit: number): TranscriptDocument {
   return { schemaVersion: 1, version: "piagent-webui-transcript-v1", generatedAt: input.generatedAt ?? new Date().toISOString(),
     identity: structuredClone(input.identity), revision: structuredClone(input.revision), eventCursor: input.eventCursor,
@@ -168,17 +252,19 @@ function unavailable(input: TranscriptProjectionInput, reasonCode: string, limit
 export function projectTranscript(input: TranscriptProjectionInput): TranscriptDocument {
   const limit = Math.max(1, Math.min(MAX_ITEMS, Number.isInteger(input.limit) ? Number(input.limit) : 50));
   if (!Array.isArray(input.entries) || input.entries.length > MAX_ENTRIES) return unavailable(input, "transcript-history-unavailable", limit);
-  const projected = input.entries.map((entry) => ({ entry, item: item(entry, input.identity) })).filter((value): value is { entry: any; item: TranscriptItem } => Boolean(value.item));
-  const cursors = projected.map(({ entry }) => opaque("transcript", [input.identity.sessionRef, entry.id]));
+  const projected = suppressOpenTaskHandoff(linkTranscriptTurns(input.entries.map((entry) => ({ entry, item: item(entry, input.identity),
+    cursor: opaque("transcript", [input.identity.sessionRef, (entry as any)?.id]) }))
+    .filter((value): value is ProjectedTranscriptItem => Boolean(value.item))), input.taskOutcome);
+  const cursors = projected.map((value) => value.cursor);
   let end = projected.length;
   if (input.beforeCursor) {
     const cursorIndex = cursors.indexOf(input.beforeCursor);
     if (cursorIndex < 0) return unavailable(input, "transcript-cursor-gap", limit);
     end = cursorIndex;
   }
-  const start = Math.max(0, end - limit), selected = projected.slice(start, end).map((value) => value.item), hasOlder = start > 0;
+  const page = boundedTurnPage(projected, end, limit), selected = page.selected.map((value) => value.item), hasOlder = page.start > 0;
   return { schemaVersion: 1, version: "piagent-webui-transcript-v1", generatedAt: input.generatedAt ?? new Date().toISOString(),
     identity: structuredClone(input.identity), revision: structuredClone(input.revision), eventCursor: input.eventCursor,
-    state: "ready", items: selected, page: { beforeCursor: input.beforeCursor ?? null, nextBeforeCursor: hasOlder ? cursors[start] : null,
-      hasOlder, limit, truncated: projected.length !== input.entries.filter((entry: any) => entry?.type === "message").length }, reasonCode: null };
+    state: "ready", items: selected, page: { beforeCursor: input.beforeCursor ?? null, nextBeforeCursor: hasOlder ? cursors[page.start] : null,
+      hasOlder, limit, truncated: page.compacted || projected.length !== input.entries.filter((entry: any) => entry?.type === "message").length }, reasonCode: null };
 }

package/schemas/codex-relative-efficiency-v1.schema.json

@@ -0,0 +1,155 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/Vt-mmm/piagent/schemas/codex-relative-efficiency-v1.schema.json",
+  "title": "Piagent Codex-relative efficiency evidence v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "policy", "required", "claim", "billedOrSubscriptionCost", "costBoundary", "checks", "failures", "passed", "families", "totalTokenTraffic", "apiEquivalentCost", "subagents"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "policy": { "$ref": "#/$defs/policy" },
+    "required": { "type": "boolean" },
+    "claim": { "type": "string", "minLength": 1 },
+    "billedOrSubscriptionCost": { "const": false },
+    "costBoundary": { "type": "string", "minLength": 1 },
+    "checks": {
+      "type": "object",
+      "minProperties": 1,
+      "additionalProperties": { "type": "boolean" }
+    },
+    "failures": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
+    "passed": { "type": "boolean" },
+    "families": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/family" } },
+    "totalTokenTraffic": { "$ref": "#/$defs/aggregateTokens" },
+    "apiEquivalentCost": { "$ref": "#/$defs/aggregateCost" },
+    "subagents": { "$ref": "#/$defs/subagents" }
+  },
+  "$defs": {
+    "nullableNonNegativeNumber": { "type": ["number", "null"], "minimum": 0 },
+    "nullablePositiveNumber": { "type": ["number", "null"], "exclusiveMinimum": 0 },
+    "confidence": {
+      "type": ["object", "null"],
+      "additionalProperties": false,
+      "required": ["lower", "upper", "sampleUnit", "scenarioCount"],
+      "properties": {
+        "lower": { "type": "number", "exclusiveMinimum": 0 },
+        "upper": { "type": "number", "exclusiveMinimum": 0 },
+        "sampleUnit": { "const": "scenario-family" },
+        "scenarioCount": { "type": "integer", "minimum": 2 }
+      }
+    },
+    "policy": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["schemaVersion", "id", "baselineSurface", "candidateSurface", "estimand", "outcomeConditioning", "attemptPolicy", "maximumTotalTokenTrafficRatio", "maximumTotalTokenTrafficRatioUpper95", "maximumApiEquivalentCostRatio", "maximumApiEquivalentCostRatioUpper95", "maximumSubagentSessionsPerAttempt", "maximumSubagentTrafficShare"],
+      "properties": {
+        "schemaVersion": { "const": 1 },
+        "id": { "const": "codex-relative-efficiency-v1" },
+        "baselineSurface": { "const": "codex-cli" },
+        "candidateSurface": { "const": "piagent" },
+        "estimand": { "const": "fixed-workload-family-geometric-mean" },
+        "outcomeConditioning": { "const": "none" },
+        "attemptPolicy": { "const": "accepted-plus-exact-provider-started-failed-attempts" },
+        "maximumTotalTokenTrafficRatio": { "type": "number", "exclusiveMinimum": 0, "maximum": 0.7 },
+        "maximumTotalTokenTrafficRatioUpper95": { "type": "number", "exclusiveMinimum": 0, "maximum": 0.7 },
+        "maximumApiEquivalentCostRatio": { "type": "number", "exclusiveMinimum": 0, "maximum": 0.7 },
+        "maximumApiEquivalentCostRatioUpper95": { "type": "number", "exclusiveMinimum": 0, "maximum": 0.7 },
+        "maximumSubagentSessionsPerAttempt": { "type": "integer", "minimum": 0, "maximum": 1 },
+        "maximumSubagentTrafficShare": { "type": "number", "minimum": 0, "maximum": 0.05 }
+      }
+    },
+    "family": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["scenarioId", "expectedAttempts", "pairedAttempts", "exact", "issues", "baselineTokenTraffic", "candidateTokenTraffic", "totalTokenTrafficRatio", "baselineApiEquivalentCostUsd", "candidateApiEquivalentCostUsd", "apiEquivalentCostRatio", "candidateSubagentSessions", "candidateSubagentTraffic", "maximumSubagentSessionsPerAttempt", "candidateAttempts", "subagentEvidenceComplete"],
+      "properties": {
+        "scenarioId": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+        "expectedAttempts": { "type": ["integer", "null"], "minimum": 1 },
+        "pairedAttempts": { "type": "integer", "minimum": 0 },
+        "exact": { "type": "boolean" },
+        "issues": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
+        "baselineTokenTraffic": { "type": "number", "minimum": 0 },
+        "candidateTokenTraffic": { "type": "number", "minimum": 0 },
+        "totalTokenTrafficRatio": { "$ref": "#/$defs/nullablePositiveNumber" },
+        "baselineApiEquivalentCostUsd": { "type": "number", "minimum": 0 },
+        "candidateApiEquivalentCostUsd": { "type": "number", "minimum": 0 },
+        "apiEquivalentCostRatio": { "$ref": "#/$defs/nullablePositiveNumber" },
+        "candidateSubagentSessions": { "type": "integer", "minimum": 0 },
+        "candidateSubagentTraffic": { "type": "integer", "minimum": 0 },
+        "maximumSubagentSessionsPerAttempt": { "type": "integer", "minimum": 0 },
+        "candidateAttempts": { "type": "integer", "minimum": 0 },
+        "subagentEvidenceComplete": { "type": "boolean" }
+      }
+    },
+    "aggregateBase": {
+      "type": "object",
+      "required": ["complete", "expectedScenarioFamilies", "completeScenarioFamilies", "ratio", "ratioConfidence95", "ratioConfidence95Raw", "aggregateRatio", "deltaPercent"],
+      "properties": {
+        "complete": { "type": "boolean" },
+        "expectedScenarioFamilies": { "type": "integer", "minimum": 1 },
+        "completeScenarioFamilies": { "type": "integer", "minimum": 0 },
+        "ratio": { "$ref": "#/$defs/nullablePositiveNumber" },
+        "ratioConfidence95": { "$ref": "#/$defs/confidence" },
+        "ratioConfidence95Raw": { "$ref": "#/$defs/confidence" },
+        "aggregateRatio": { "$ref": "#/$defs/nullableNonNegativeNumber" },
+        "deltaPercent": { "type": ["number", "null"] }
+      }
+    },
+    "aggregateTokens": {
+      "allOf": [
+        { "$ref": "#/$defs/aggregateBase" },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["complete", "expectedScenarioFamilies", "completeScenarioFamilies", "ratio", "ratioConfidence95", "ratioConfidence95Raw", "aggregateBaselineTokens", "aggregateCandidateTokens", "aggregateRatio", "deltaPercent"],
+          "properties": {
+            "complete": true,
+            "expectedScenarioFamilies": true,
+            "completeScenarioFamilies": true,
+            "ratio": true,
+            "ratioConfidence95": true,
+            "ratioConfidence95Raw": true,
+            "aggregateRatio": true,
+            "deltaPercent": true,
+            "aggregateBaselineTokens": { "type": "number", "minimum": 0 },
+            "aggregateCandidateTokens": { "type": "number", "minimum": 0 }
+          }
+        }
+      ]
+    },
+    "aggregateCost": {
+      "allOf": [
+        { "$ref": "#/$defs/aggregateBase" },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["complete", "expectedScenarioFamilies", "completeScenarioFamilies", "ratio", "ratioConfidence95", "ratioConfidence95Raw", "aggregateBaselineUsd", "aggregateCandidateUsd", "aggregateRatio", "deltaPercent"],
+          "properties": {
+            "complete": true,
+            "expectedScenarioFamilies": true,
+            "completeScenarioFamilies": true,
+            "ratio": true,
+            "ratioConfidence95": true,
+            "ratioConfidence95Raw": true,
+            "aggregateRatio": true,
+            "deltaPercent": true,
+            "aggregateBaselineUsd": { "type": "number", "minimum": 0 },
+            "aggregateCandidateUsd": { "type": "number", "minimum": 0 }
+          }
+        }
+      ]
+    },
+    "subagents": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["candidateAttempts", "sessions", "tokenTraffic", "trafficShare", "maximumObservedSessionsPerAttempt"],
+      "properties": {
+        "candidateAttempts": { "type": "integer", "minimum": 0 },
+        "sessions": { "type": "integer", "minimum": 0 },
+        "tokenTraffic": { "type": "integer", "minimum": 0 },
+        "trafficShare": { "$ref": "#/$defs/nullableNonNegativeNumber" },
+        "maximumObservedSessionsPerAttempt": { "type": "integer", "minimum": 0 }
+      }
+    }
+  }
+}

package/schemas/piagent-webui/runtime-event-v2.schema.json

@@ -2962,11 +2962,21 @@
           },
           "then": {
             "type": "object",
-            "properties": {
-              "isError": { "const": false },
-              "exitCode": { "anyOf": [{ "const": 0 }, { "type": "null" }] },
-              "reasonCode": { "type": "null" }
-            }
+            "oneOf": [
+              {
+                "properties": {
+                  "isError": { "const": false },
+                  "exitCode": { "anyOf": [{ "const": 0 }, { "type": "null" }] },
+                  "reasonCode": { "type": "null" }
+                }
+              },
+              {
+                "properties": {
+                  "isError": { "const": false },
+                  "reasonCode": { "const": "search-target-missing" }
+                }
+              }
+            ]
           }
         },
         {

package/schemas/piagent-webui/subagent-tree-v1.schema.json

@@ -4,7 +4,7 @@
   "title": "Piagent WebUI bounded subagent ownership tree v1",
   "type": "object",
   "additionalProperties": false,
-  "required": ["schemaVersion", "version", "generatedAt", "identity", "runRef", "state", "treeRevision", "evidenceState", "orchestration", "parent", "children", "writer", "nestedLineage", "summary", "warnings", "health"],
+  "required": ["schemaVersion", "version", "generatedAt", "identity", "runRef", "state", "treeRevision", "evidenceState", "orchestration", "delegation", "parent", "children", "writer", "nestedLineage", "summary", "warnings", "health"],
   "properties": {
     "schemaVersion": { "const": 1 },
     "version": { "const": "piagent-webui-subagent-tree-v1" },
@@ -15,6 +15,7 @@
     "treeRevision": { "$ref": "common-v1.schema.json#/$defs/nullableRevisionToken" },
     "evidenceState": { "enum": ["complete", "partial", "aggregate-only", "missing", "unknown"] },
     "orchestration": { "$ref": "#/$defs/orchestration" },
+    "delegation": { "$ref": "#/$defs/delegation" },
     "parent": { "anyOf": [{ "$ref": "#/$defs/parent" }, { "type": "null" }] },
     "children": { "type": "array", "maxItems": 64, "items": { "$ref": "#/$defs/child" } },
     "writer": { "$ref": "#/$defs/writer" },
@@ -51,6 +52,15 @@
       "mode": { "enum": ["solo-first", "bounded-subagents", "parallel-readonly", "unknown"] },
       "subagents": { "enum": ["not-used", "optional", "used", "unknown"] }
     } },
+    "delegation": { "type": "object", "additionalProperties": false, "required": ["action", "reasonCodes", "projectedNetSavingsRatio", "minimumRequiredNetSavingsRatio", "budget"], "properties": {
+      "action": { "enum": ["dispatch", "skip", "unknown"] },
+      "reasonCodes": { "type": "array", "maxItems": 16, "uniqueItems": true, "items": { "type": "string", "pattern": "^[a-z0-9_.:-]+$" } },
+      "projectedNetSavingsRatio": { "type": ["number", "null"], "minimum": -10, "maximum": 1 },
+      "minimumRequiredNetSavingsRatio": { "const": 0.3 },
+      "budget": { "type": "object", "additionalProperties": false, "required": ["maxConcurrent", "maxTotal", "maxRetries", "maxWriters"], "properties": {
+        "maxConcurrent": { "const": 1 }, "maxTotal": { "const": 1 }, "maxRetries": { "const": 0 }, "maxWriters": { "const": 0 }
+      } }
+    } },
     "parent": { "type": "object", "additionalProperties": false, "required": ["nodeRef", "lifecycleState", "budgetTerminal", "mergeOwner"], "properties": {
       "nodeRef": { "$ref": "common-v1.schema.json#/$defs/opaqueRef" }, "lifecycleState": { "enum": ["active", "terminal", "unknown"] },
       "budgetTerminal": { "type": ["boolean", "null"] }, "mergeOwner": { "const": "parent" }

package/schemas/project-profile.schema.json

@@ -382,7 +382,7 @@
         "maxConcurrentSubagents": {
           "type": "integer",
           "minimum": 0,
-          "maximum": 6
+          "maximum": 1
         },
         "defaultReviewLenses": {
           "type": "array",

package/schemas/task-contract.schema.json

@@ -410,6 +410,8 @@
           "properties": {
             "mode": { "enum": ["off", "recommend", "on"] },
             "used": { "type": "boolean" },
+            "decision": { "enum": ["dispatch", "skip"] },
+            "projectedSavingsRatio": { "type": ["number", "null"], "minimum": -10, "maximum": 1 },
             "reasonCodes": { "type": "array", "maxItems": 16, "uniqueItems": true, "items": { "type": "string", "pattern": "^[a-z0-9_.:-]+$" } },
             "helpers": {
               "type": "array", "maxItems": 3,
@@ -540,6 +542,15 @@
       "type": "string",
       "minLength": 10
     },
+    "operatorRequest": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 8000
+    },
+    "operatorRequestDigest": {
+      "type": "string",
+      "pattern": "^operator-request-v1:[a-f0-9]{64}$"
+    },
     "riskLane": {
       "enum": [
         "tiny",
@@ -869,6 +880,10 @@
       "format": "date-time"
     }
   },
+  "dependentRequired": {
+    "operatorRequest": ["operatorRequestDigest"],
+    "operatorRequestDigest": ["operatorRequest"]
+  },
   "allOf": [
     {
       "if": { "properties": { "changeMode": { "const": "read-only" } }, "required": ["changeMode"] },

package/scripts/benchmark-runner-core.mjs

@@ -10,6 +10,7 @@ import { codexModelName, codexThinkingEffort } from "../packages/piagent-core/be
 import { benchmarkEnvironment, benchmarkEnvironmentPolicy, comparisonSurfaces, createCodexRuntime, piagentTreatment } from "../packages/piagent-core/benchmark/benchmark-runtime.js";
 import { assertBenchmarkPiCredentialReady, assertBenchmarkPiCredentialWritebackPolicy, cleanupBenchmarkPiRuntimeHome, createBenchmarkPiRuntimeHome, resetBenchmarkPiRuntimeEphemeralState, withBenchmarkPiCredentialWriteback } from "../packages/piagent-core/benchmark/benchmark-pi-home.js";
 import { benchmarkPreflight, benchmarkPreflightReceipt } from "../packages/piagent-core/benchmark/benchmark-preflight.js";
+import { prepareProductionProviderFreeEvidence, productionProviderFreeEvidenceError } from "../packages/piagent-core/benchmark/benchmark-provider-free-evidence.js";
 import { applyBenchmarkExecutionDefaults } from "../packages/piagent-core/benchmark/benchmark-runner-policy.js";
 import {
   appendPrivateJsonl,
@@ -32,7 +33,7 @@ import {
   buildBenchmarkStageDiagnostic,
   createProductionStageControl,
   durablePairedOutcomeFloorStop,
-  productionSpendControlValidationErrors,
+  productionGuardBindingMatches, productionSpendControlValidationErrors,
   productionStageResumeDisposition
 } from "../packages/piagent-core/benchmark/benchmark-stage-diagnostic.js";
 import { loadBenchmarkAssuranceEvidence, loadBenchmarkSuite, resolveBenchmarkSuiteEntry, validateBenchmarkSuiteFiles } from "../packages/piagent-core/benchmark/benchmark-suite-runtime.js";
@@ -103,7 +104,6 @@ async function runLegacy(argv) {
   const result = await runCommand("bash", [path.join(packageRoot, "scripts", "quality-benchmark.sh"), ...argv], { cwd: process.cwd(), inherit: true });
   process.exitCode = result.code;
 }
-
 async function main() {
   const argv = process.argv.slice(2);
   if (isLegacyInvocation(argv)) return runLegacy(argv);
@@ -268,6 +268,7 @@ async function main() {
   if (resumeState) {
     const manifest = resumeState.manifest;
     if (manifest.suiteDigest !== suiteDigest) fail("Cannot resume benchmark: suite files changed since the original run", 1);
+    if (productionSpendControlled && !productionGuardBindingMatches(manifest, productionSpendControl)) fail("Cannot resume production benchmark: frozen production guard binding is missing or changed", 1);
     if (manifest.rootSeed !== rootSeed) fail("Cannot resume benchmark: root seed mismatch", 1);
     if (manifest.repeats !== options.repeats) fail("Cannot resume benchmark: repeat count mismatch", 1);
     if (!sameStringList(manifest.surfaces, options.surfaces)) fail("Cannot resume benchmark: surface list mismatch", 1);
@@ -528,6 +529,10 @@ async function main() {
     order: fullOrder.map((item) => ({ scenarioId: item.scenario.id, surface: item.surface, repeat: item.repeat }))
   };
   const configurationDigest = crypto.createHash("sha256").update(JSON.stringify(configuration)).digest("hex");
+  const source = bootstrapMetadata?.sourceIdentity;
+  if (!source) fail("Modern benchmark is missing its frozen Git source identity", 1);
+  const { receipt: providerFreeEvidence, binding: providerFreeEvidenceBinding } = await prepareProductionProviderFreeEvidence({
+    required: productionSpendControl?.productionGuards?.providerFreeEvidence?.requiredBeforeFirstPaidSession === true, packageRoot, bootstrapMetadata, candidateProvenance: candidateGuard.provenance, configurationDigest, runCommand, resumedReceipt: resumeState ? resumeState.manifest.providerFreeEvidence ?? null : undefined });
   piCommand = runtimeCommands.pi.resolvedPath;
   if (runtimeCommands.codex) codexCommand = runtimeCommands.codex.resolvedPath;
   if (resumeState && JSON.stringify(resumeState.manifest.runtimeCommands ?? null) !== JSON.stringify(runtimeCommands)) {
@@ -610,10 +615,8 @@ async function main() {
     }
   }
   assertHostReadinessStartReady();
-  const source = bootstrapMetadata?.sourceIdentity;
-  if (!source) fail("Modern benchmark is missing its frozen Git source identity", 1);
   if (options.preflightOnly) {
-    const receipt = benchmarkPreflightReceipt({ packageVersion: packageManifest.version, source, candidateProvenance: candidateGuard.report(), suite, suiteDigest, runtimeDependencies: bootstrapMetadata.runtimeDependencies, runtimeCommands, environmentPolicy, configurationDigest, rootSeedDigest, options, runtime, hostReadinessPolicyDigest: productionHostReadinessPolicyDigest, hostReadiness: hostReadinessReceipt });
+    const receipt = benchmarkPreflightReceipt({ packageVersion: packageManifest.version, source, candidateProvenance: candidateGuard.report(), suite, suiteDigest, runtimeDependencies: bootstrapMetadata.runtimeDependencies, runtimeCommands, environmentPolicy, configurationDigest, rootSeedDigest, options, runtime, hostReadinessPolicyDigest: productionHostReadinessPolicyDigest, hostReadiness: hostReadinessReceipt, providerFreeEvidence });
     process.stdout.write(options.json ? `${JSON.stringify(receipt, null, 2)}\n` : `${plan}${codexPlan}\nPREFLIGHT READY: no model session started.\n${JSON.stringify(receipt, null, 2)}\n`);
     return;
   }
@@ -676,6 +679,8 @@ async function main() {
     stopAfterFailedPair: options.stopAfterFailedPair,
     scenarioIds: options.scenarioIds ?? null,
     ...(productionSpendControlled ? {
+      productionGuards: productionSpendControl.productionGuards,
+      providerFreeEvidence,
       stageControl: createProductionStageControl({
         authorizedThroughRuns: productionStageBoundaries[0],
         generatedAt: startedAt
@@ -912,8 +917,11 @@ async function main() {
   }
   let finalizationReceipt;
   if (!interruptedSignal && !fatalRunError) {
+    if (productionSpendControl?.productionGuards?.providerFreeEvidence?.requiredBeforeFirstPaidSession === true) {
+      fatalRunError ??= productionProviderFreeEvidenceError(manifest.providerFreeEvidence, providerFreeEvidenceBinding, "final production provider-free evidence");
+    }
     finalizationReceipt = executionGuard.receipt("finalization", [piRuntimeHome]);
-    fatalRunError = finalizationReceipt.error;
+    fatalRunError ??= finalizationReceipt.error;
   }
   finalizeBenchmarkRun({
     assuranceEvidence, bootstrapMetadata, candidateGuard, canonicalProductionSuite,

package/scripts/benchmark-runner-finalization.mjs

@@ -248,6 +248,9 @@ export function finalizeBenchmarkRun(context) {
         ? options.codexMode === "controlled" ? "excluded" : "operator-home"
         : null,
       piGlobalInstructions: "excluded",
+      comparisonAccessContract: options.surfaces.includes("codex-cli") && options.codexMode === "controlled"
+        ? "paired-workspace-write-offline-surface-system"
+        : null,
       piAgentHome: manifest.piAgentHome,
       usageIntegrity: manifest.tokenClaimsUnavailableReason ?? "measured",
       codexDisabledFeatures: runtime.codexDisabledFeatures,
@@ -268,6 +271,7 @@ export function finalizeBenchmarkRun(context) {
       hostReadinessHistory,
       environmentPolicy,
       runtimeDependencies: bootstrapMetadata?.runtimeDependencies ?? null,
+      providerFreeEvidence: manifest.providerFreeEvidence ?? null,
       assuranceEvidence
     },
     runs: completedRuns,