@piagent/platform 1.5.5 → 1.6.1

package/scripts/benchmark-session.mjs

@@ -1,5 +1,6 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 
 import {
@@ -16,6 +17,7 @@ import {
 } from "../packages/piagent-core/benchmark/benchmark-runtime.js";
 import {
   acceptedTaskStartTraceCount,
+  benchmarkCausalContextReceipt,
   benchmarkOperationalEvidence,
   classifyPreUsageFailure,
   failureReason,
@@ -24,10 +26,12 @@ import {
   writePrivate,
   writePrivateAtomic
 } from "../packages/piagent-core/benchmark/benchmark-forensics.js";
-import { readContextTelemetry } from "../packages/piagent-core/extensions/context-engine.js";
+import { inspectContextTelemetry } from "../packages/piagent-core/extensions/context-engine.js";
 import { matchesAnyPath } from "../packages/piagent-core/extensions/policy-core.js";
 import { listTaskContracts, workingTreeFiles, workingTreeSnapshot } from "../packages/piagent-core/extensions/task-state.js";
 import { benchmarkTreeIdentity } from "../packages/piagent-core/benchmark/benchmark-tree-identity.js";
+import { buildBenchmarkProviderWireEvidence } from "../packages/piagent-core/benchmark/benchmark-provider-wire.js";
+import { createDeferredBenchmarkTimingCollector } from "../packages/piagent-core/benchmark/benchmark-timing-diagnostics.js";
 import { summarizeSession, walkJsonl } from "./pi-usage-history.mjs";
 
 const coldStartRuntimeManagedPaths = [
@@ -49,6 +53,12 @@ function privateDirectory(target) {
   return target;
 }
 
+function privateTemporaryDirectory(prefix) {
+  const target = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  try { fs.chmodSync(target, 0o700); } catch { /* Non-POSIX filesystem. */ }
+  return target;
+}
+
 function makeFixtureWritable(root) {
   const pending = [root];
   while (pending.length > 0) {
@@ -122,28 +132,33 @@ function generatedStringArray(value, field) {
   return [...new Set(value)];
 }
 
-async function generateVariant({ runCommand, nodeCommand, generator, workspace, oraclePath, seed, scenario, timeoutSeconds }) {
-  const result = await runCommand(nodeCommand, [generator, workspace, oraclePath, seed, scenario.id], {
-    cwd: path.dirname(generator), timeoutMs: Math.min(timeoutSeconds, 120) * 1_000, env: graderEnvironment(scenario.id)
-  });
-  if (result.timedOut) fail(`Benchmark variant generator timed out for ${scenario.id}`);
-  if (result.code !== 0) fail(`Benchmark variant generator failed for ${scenario.id}: ${result.stderr.trim() || result.stdout.trim()}`);
-  let oracle;
-  try { oracle = JSON.parse(fs.readFileSync(oraclePath, "utf8")); }
-  catch (error) { fail(`Benchmark variant generator did not write a valid oracle for ${scenario.id}: ${error.message}`); }
-  if (!oracle || typeof oracle !== "object" || Array.isArray(oracle) || oracle.schemaVersion !== 1 || !oracle.graderData || typeof oracle.graderData !== "object" || Array.isArray(oracle.graderData)) {
-    fail(`Benchmark variant oracle is invalid for ${scenario.id}`);
+async function generateVariant({ runCommand, nodeCommand, generator, workspace, seed, scenario, timeoutSeconds }) {
+  const temporaryRoot = privateTemporaryDirectory("piagent-benchmark-oracle-input-");
+  const oraclePath = path.join(temporaryRoot, "oracle.json");
+  try {
+    const result = await runCommand(nodeCommand, [generator, workspace, oraclePath, seed, scenario.id], {
+      cwd: path.dirname(generator), timeoutMs: Math.min(timeoutSeconds, 120) * 1_000, env: graderEnvironment(scenario.id)
+    });
+    if (result.timedOut) fail(`Benchmark variant generator timed out for ${scenario.id}`);
+    if (result.code !== 0) fail(`Benchmark variant generator failed for ${scenario.id}: ${result.stderr.trim() || result.stdout.trim()}`);
+    let oracle;
+    try { oracle = JSON.parse(fs.readFileSync(oraclePath, "utf8")); }
+    catch (error) { fail(`Benchmark variant generator did not write a valid oracle for ${scenario.id}: ${error.message}`); }
+    if (!oracle || typeof oracle !== "object" || Array.isArray(oracle) || oracle.schemaVersion !== 1 || !oracle.graderData || typeof oracle.graderData !== "object" || Array.isArray(oracle.graderData)) {
+      fail(`Benchmark variant oracle is invalid for ${scenario.id}`);
+    }
+    const serialized = JSON.stringify(oracle);
+    if (Buffer.byteLength(serialized) > 100_000) fail(`Benchmark variant oracle is too large for ${scenario.id}`);
+    return {
+      oracleSerialized: `${serialized}\n`,
+      oracleDigest: crypto.createHash("sha256").update(serialized).digest("hex"),
+      seedDigest: crypto.createHash("sha256").update(seed).digest("hex"),
+      requiredOutputSubstrings: generatedStringArray(oracle.requiredOutputSubstrings, "requiredOutputSubstrings"),
+      forbiddenOutputSubstrings: generatedStringArray(oracle.forbiddenOutputSubstrings, "forbiddenOutputSubstrings")
+    };
+  } finally {
+    fs.rmSync(temporaryRoot, { recursive: true, force: true });
   }
-  const serialized = JSON.stringify(oracle);
-  if (Buffer.byteLength(serialized) > 100_000) fail(`Benchmark variant oracle is too large for ${scenario.id}`);
-  writePrivate(oraclePath, `${JSON.stringify(oracle)}\n`);
-  return {
-    oraclePath,
-    oracleDigest: crypto.createHash("sha256").update(serialized).digest("hex"),
-    seedDigest: crypto.createHash("sha256").update(seed).digest("hex"),
-    requiredOutputSubstrings: generatedStringArray(oracle.requiredOutputSubstrings, "requiredOutputSubstrings"),
-    forbiddenOutputSubstrings: generatedStringArray(oracle.forbiddenOutputSubstrings, "forbiddenOutputSubstrings")
-  };
 }
 
 function writableCopyEnvironment(workspace) {
@@ -276,17 +291,24 @@ function parseGraderResult(stdout) {
   };
 }
 
-async function gradeWorkspace(runCommand, nodeCommand, grader, workspace, scenario, timeoutSeconds, oraclePath) {
-  const result = await runCommand(nodeCommand, oraclePath ? [grader, workspace, oraclePath] : [grader, workspace], {
-    cwd: path.dirname(grader), timeoutMs: Math.min(timeoutSeconds, 120) * 1_000, env: graderEnvironment(scenario.id)
-  });
-  if (result.timedOut) return { passed: false, score: 0, checks: [], error: "grader-timeout" };
-  if (result.code !== 0) return { passed: false, score: 0, checks: [], error: `grader-exit-${result.code}` };
-  try { return parseGraderResult(result.stdout); } catch (error) { return { passed: false, score: 0, checks: [], error: error.message }; }
+async function gradeWorkspace(runCommand, nodeCommand, grader, workspace, scenario, timeoutSeconds, oracleSerialized) {
+  const temporaryRoot = oracleSerialized ? privateTemporaryDirectory("piagent-benchmark-oracle-grader-") : null;
+  try {
+    const oraclePath = temporaryRoot ? path.join(temporaryRoot, "oracle.json") : null;
+    if (oraclePath) writePrivate(oraclePath, oracleSerialized);
+    const result = await runCommand(nodeCommand, oraclePath ? [grader, workspace, oraclePath] : [grader, workspace], {
+      cwd: path.dirname(grader), timeoutMs: Math.min(timeoutSeconds, 120) * 1_000, env: graderEnvironment(scenario.id)
+    });
+    if (result.timedOut) return { passed: false, score: 0, checks: [], error: "grader-timeout" };
+    if (result.code !== 0) return { passed: false, score: 0, checks: [], error: `grader-exit-${result.code}` };
+    try { return parseGraderResult(result.stdout); } catch (error) { return { passed: false, score: 0, checks: [], error: error.message }; }
+  } finally {
+    if (temporaryRoot) fs.rmSync(temporaryRoot, { recursive: true, force: true });
+  }
 }
 
 function sessionSummaries(sessionDir) {
-  return walkJsonl(sessionDir).map((file) => summarizeSession(file, {})).filter(Boolean);
+  return walkJsonl(sessionDir).map((file) => summarizeSession(file, { strictUsage: true })).filter(Boolean);
 }
 
 export async function runBenchmarkSession({ packageRoot, runCommand, resolveSuiteEntry, interrupted, persistCompletedRecord, suite, suiteRoot, scenario, surface, repeat, orderIndex, infrastructureAttempt = 1, runId, runRoot, options, piCommand, codexCommand, codexDisabledFeatures, codexRuntime, piRuntimeHome, systemCommands, suiteDigest, configurationDigest, rootSeed }) {
@@ -301,11 +323,11 @@ export async function runBenchmarkSession({ packageRoot, runCommand, resolveSuit
   applySetupFiles(workspace, scenario.setupFiles);
   const profile = scenario.profile ?? suite.profile;
   const lifecycle = scenario.lifecycle ?? "steady-state";
-  let variant = { oraclePath: null, oracleDigest: null, seedDigest: null, requiredOutputSubstrings: [], forbiddenOutputSubstrings: [] };
+  let variant = { oracleSerialized: null, oracleDigest: null, seedDigest: null, requiredOutputSubstrings: [], forbiddenOutputSubstrings: [] };
   if (scenario.variantGenerator) {
     variant = await generateVariant({
       runCommand, nodeCommand: systemCommands.node, generator: resolveSuiteEntry(suiteRoot, scenario.variantGenerator, "variant generator"), workspace,
-      oraclePath: path.join(workspaceRoot, "oracle.json"), seed: variantSeed(rootSeed, suiteDigest, scenario.id, repeat),
+      seed: variantSeed(rootSeed, suiteDigest, scenario.id, repeat),
       scenario, timeoutSeconds: options.timeoutSeconds
     });
   }
@@ -337,6 +359,7 @@ export async function runBenchmarkSession({ packageRoot, runCommand, resolveSuit
   const args = surface === "codex-cli" ? codexExecArgs({ workspace, options, disabledFeatures: codexDisabledFeatures }) : piArgs;
   const codexForbiddenHits = new Set();
   const codexCollector = surface === "codex-cli" ? createCodexExecJsonlCollector({ model: options.model, thinkingLevel: options.thinking, onEvent: (event) => inspectForbiddenValue(event, forbiddenOutputSubstrings, codexForbiddenHits) }) : undefined;
+  const timingCollector = createDeferredBenchmarkTimingCollector({ surface });
   const environment = {
     PIAGENT_NO_UPDATE_CHECK: "1", PIAGENT_BENCHMARK_RUN_ID: runId, PIAGENT_BENCHMARK_SCENARIO: scenario.id,
     PIAGENT_BENCHMARK_SURFACE: surface, PIAGENT_BENCHMARK_SESSION_ID: sessionId, PIAGENT_BENCHMARK_PROFILE: profile,
@@ -344,12 +367,22 @@ export async function runBenchmarkSession({ packageRoot, runCommand, resolveSuit
   };
   const inflightPath = path.join(workspaceRoot, "inflight.json");
   writePrivateAtomic(inflightPath, `${JSON.stringify({ schemaVersion: 1, runId, attemptId, orderIndex, scenarioId: scenario.id, surface, repeat, infrastructureAttempt, stage: "provider-may-start", recordedAt: new Date().toISOString() }, null, 2)}\n`);
-  const agent = await runCommand(command, args, {
-    cwd: workspace, input: surface === "codex-cli" ? prompt : undefined, timeoutMs: options.timeoutSeconds * 1_000,
-    forbiddenSubstrings: forbiddenOutputSubstrings, requiredSubstrings: requiredOutputSubstrings,
-    onStdoutChunk: codexCollector ? (chunk) => codexCollector.write(chunk) : undefined,
-    env: surface === "codex-cli" ? codexProcessEnvironment(codexRuntime, environment) : surface === "piagent" ? piagentProcessEnvironment(options.piagentTreatment, { ...environment, PI_CODING_AGENT_DIR: piRuntimeHome.path }) : benchmarkEnvironment({ ...environment, PI_CODING_AGENT_DIR: piRuntimeHome.path })
-  });
+  let agent;
+  try {
+    agent = await runCommand(command, args, {
+      cwd: workspace, input: surface === "codex-cli" ? prompt : undefined, timeoutMs: options.timeoutSeconds * 1_000,
+      forbiddenSubstrings: forbiddenOutputSubstrings, requiredSubstrings: requiredOutputSubstrings,
+      onStdoutChunk: (chunk, observation) => {
+        timingCollector.write(chunk, observation?.observedAtSeconds);
+        codexCollector?.write(chunk);
+      },
+      env: surface === "codex-cli" ? codexProcessEnvironment(codexRuntime, environment) : surface === "piagent" ? piagentProcessEnvironment(options.piagentTreatment, { ...environment, PI_CODING_AGENT_DIR: piRuntimeHome.path }) : benchmarkEnvironment({ ...environment, PI_CODING_AGENT_DIR: piRuntimeHome.path })
+    });
+  } catch (error) {
+    timingCollector.discard();
+    throw error;
+  }
+  const timingDiagnostics = timingCollector.finish(agent.durationSeconds);
   const sessionFiles = surface === "codex-cli" ? [] : walkJsonl(sessions);
   let usage;
   let codexDiagnostics = [];
@@ -372,11 +405,31 @@ export async function runBenchmarkSession({ packageRoot, runCommand, resolveSuit
   const runtimeManagedChanges = surface === "piagent" && lifecycle === "cold-start" ? allChangedFiles.filter((file) => matchesAnyPath(file, coldStartRuntimeManagedPaths)) : [];
   const runtimeManagedSet = new Set(runtimeManagedChanges);
   const changedFiles = allChangedFiles.filter((file) => !runtimeManagedSet.has(file));
+  const telemetryLimit = 50_000;
+  const contextTelemetryInspection = surface === "piagent"
+    ? inspectContextTelemetry(workspace, { limit: telemetryLimit })
+    : { records: [], exists: false, integrityFailures: 0, recoverableTailBytes: 0, inputTruncated: false };
+  const contextTelemetry = contextTelemetryInspection.records;
+  const causalContextReceipt = benchmarkCausalContextReceipt(contextTelemetry, {
+    surface,
+    sessionId,
+    criterionExpected: scenario.kind !== "safety-refusal",
+    telemetryExists: contextTelemetryInspection.exists,
+    telemetryTruncated: contextTelemetryInspection.inputTruncated,
+    telemetryIntegrityFailures: contextTelemetryInspection.integrityFailures,
+    recoverableTailBytes: contextTelemetryInspection.recoverableTailBytes
+  });
+  const providerWireEvidence = surface === "piagent" ? buildBenchmarkProviderWireEvidence({
+    events: contextTelemetry,
+    requestedModel: options.model,
+    requestedThinking: options.thinking,
+    telemetryTruncated: contextTelemetryInspection.inputTruncated
+  }) : null;
   let workflow = null;
   if (surface === "piagent" && scenario.kind !== "safety-refusal") {
     const task = listTaskContracts(workspace).find((item) => item.sessionId === sessionId);
     workflow = evaluateWorkflowEvidence(task, changedFiles, usage.toolNames, { scenarioKind: scenario.kind, acceptedTaskStartCount: acceptedTaskStartTraceCount(sessionFiles, sessionId) });
-    workflow.operational = benchmarkOperationalEvidence(readContextTelemetry(workspace, { limit: 5_000 }));
+    workflow.operational = benchmarkOperationalEvidence(contextTelemetry);
   }
   const beforeGrade = workingTreeSnapshot(workspace);
   const outsideScope = changedFiles.filter((file) => !matchesAnyPath(file, scenario.allowedChanges));
@@ -384,7 +437,7 @@ export async function runBenchmarkSession({ packageRoot, runCommand, resolveSuit
     ? { passed: false, score: 0, checks: [], error: preUsageFailure.failure }
     : interrupted()
     ? { passed: false, score: 0, checks: [], error: "interrupted-after-provider-start" }
-    : await gradeWorkspace(runCommand, systemCommands.node, graderPath, workspace, scenario, options.timeoutSeconds, variant.oraclePath);
+    : await gradeWorkspace(runCommand, systemCommands.node, graderPath, workspace, scenario, options.timeoutSeconds, variant.oracleSerialized);
   const graderIntegrity = { passed: JSON.stringify(beforeGrade) === JSON.stringify(workingTreeSnapshot(workspace)) };
   const scope = { passed: outsideScope.length === 0, changedFiles, outsideScope, allChangedFiles, runtimeManagedChanges };
   const outputSafety = { passed: forbiddenHits.length === 0, forbiddenHits: forbiddenHits.map((value) => crypto.createHash("sha256").update(value).digest("hex")) };
@@ -402,7 +455,8 @@ export async function runBenchmarkSession({ packageRoot, runCommand, resolveSuit
     infrastructureDiagnosticSource: abortSuite ? (codexDiagnostics.length > 0 ? "codex-error-events" : piTerminalError ? "pi-terminal-error-event" : "process-output-tail") : undefined,
     resolved, failure: preUsageFailure?.failure ?? failureReason({ agent, grade, graderIntegrity, outsideScope, forbiddenHits, missingRequired }),
     agent: { exitCode: agent.code, signal: agent.signal, timedOut: agent.timedOut, stdoutHash: agent.stdoutHash ?? crypto.createHash("sha256").update(agent.stdout).digest("hex"), stderrHash: crypto.createHash("sha256").update(agent.stderr ?? "").digest("hex") },
-    grade, graderIntegrity, scope, outputSafety, outputEvidence, workflow, usage, durationSeconds: agent.durationSeconds,
+    grade, graderIntegrity, scope, outputSafety, outputEvidence, workflow, providerWireEvidence, causalContextReceipt, usage,
+    durationSeconds: agent.durationSeconds, timingDiagnostics,
     promptHash: crypto.createHash("sha256").update(prompt).digest("hex"),
     variant: scenario.variantGenerator ? { generated: true, seedDigest: variant.seedDigest, oracleDigest: variant.oracleDigest, fixtureDigest } : { generated: false, fixtureDigest }
   };

package/scripts/configure-model-scope.sh

@@ -9,7 +9,7 @@ Usage:
 Options:
   --preset <full|codex|claude>       Model families to enable (default: full = both)
   --default-model <provider/model[:thinking]>
-                                     Default model (default: openai-codex/gpt-5.5:high)
+                                     Default model (default: openai-codex/gpt-5.6-sol:high)
   --settings <path>                  Pi settings file (default: ~/.pi/agent/settings.json)
   --dry-run                          Print resulting settings JSON without writing
   -h, --help
@@ -30,7 +30,7 @@ USAGE
 }
 
 PRESET="full"
-DEFAULT_MODEL="openai-codex/gpt-5.5:high"
+DEFAULT_MODEL="openai-codex/gpt-5.6-sol:high"
 SETTINGS_PATH="${PI_CODING_AGENT_DIR:-"${HOME}/.pi/agent"}/settings.json"
 DRY_RUN=false
 
@@ -102,7 +102,8 @@ const codexModels = [
   "openai-codex/gpt-5.5:high",
   "openai-codex/gpt-5.6-luna:medium",
   "openai-codex/gpt-5.6-terra:high",
-  "openai-codex/gpt-5.6-sol:high"
+  "openai-codex/gpt-5.6-sol:high",
+  "openai-codex/*"
 ];
 
 const claudeModels = [

package/scripts/configure-subagents.sh

@@ -7,7 +7,7 @@ Usage:
   scripts/configure-subagents.sh [options]
 
 Purpose:
-  Configure pi-subagents with a safe, token-conscious baseline.
+  Configure pi-subagents with Piagent's parent-direct, one-read-only-helper ceiling.
 
 Options:
   --preset <minimal|safe|async|parallel>
@@ -27,7 +27,7 @@ After installing/configuring:
   pi
   /subagents-doctor
   /subagents-models
-  /run scout "Map the auth flow"
+  # Piagent stays parent-direct unless runtime evidence proves >=30% net token saving.
 USAGE
 }
 
@@ -103,16 +103,16 @@ const presets = {
     asyncByDefault: false,
     asyncWidget: true,
     forceTopLevelAsync: false,
-    waitTool: { enabled: true },
-    intercomBridge: { mode: "always" },
-    globalConcurrencyLimit: 4,
-    maxSubagentSpawnsPerSession: 16,
+    waitTool: { enabled: false },
+    intercomBridge: { mode: "off", resultDelivery: false },
+    globalConcurrencyLimit: 1,
+    maxSubagentSpawnsPerSession: 1,
     maxSubagentDepth: 1,
     defaultSessionDir: "~/.pi/agent/sessions/subagent",
     singleRunOutputBaseDir: "~/.pi/agent/subagent-outputs",
     worktreeBaseDir: "~/.pi/agent/worktrees/pi-subagents",
-    scheduledRuns: { enabled: false, maxPending: 20, maxLatenessMs: 300000 },
-    parallel: { maxTasks: 4, concurrency: 2 },
+    scheduledRuns: { enabled: false, maxPending: 1, maxLatenessMs: 300000 },
+    parallel: { maxTasks: 1, concurrency: 1 },
     completionBatch: { enabled: true, debounceMs: 150, maxWaitMs: 1000 }
   },
   safe: {
@@ -120,33 +120,33 @@ const presets = {
     asyncByDefault: false,
     asyncWidget: true,
     forceTopLevelAsync: false,
-    waitTool: { enabled: true },
-    intercomBridge: { mode: "always" },
-    globalConcurrencyLimit: 8,
-    maxSubagentSpawnsPerSession: 32,
+    waitTool: { enabled: false },
+    intercomBridge: { mode: "off", resultDelivery: false },
+    globalConcurrencyLimit: 1,
+    maxSubagentSpawnsPerSession: 1,
     maxSubagentDepth: 1,
     defaultSessionDir: "~/.pi/agent/sessions/subagent",
     singleRunOutputBaseDir: "~/.pi/agent/subagent-outputs",
     worktreeBaseDir: "~/.pi/agent/worktrees/pi-subagents",
-    scheduledRuns: { enabled: false, maxPending: 20, maxLatenessMs: 300000 },
-    parallel: { maxTasks: 6, concurrency: 3 },
+    scheduledRuns: { enabled: false, maxPending: 1, maxLatenessMs: 300000 },
+    parallel: { maxTasks: 1, concurrency: 1 },
     completionBatch: { enabled: true, debounceMs: 150, maxWaitMs: 1000, stragglerDebounceMs: 75, stragglerMaxWaitMs: 400, stragglerWindowMs: 2000 }
   },
   async: {
     toolDescriptionMode: "compact",
-    asyncByDefault: true,
+    asyncByDefault: false,
     asyncWidget: true,
     forceTopLevelAsync: false,
-    waitTool: { enabled: true },
-    intercomBridge: { mode: "always" },
-    globalConcurrencyLimit: 8,
-    maxSubagentSpawnsPerSession: 32,
+    waitTool: { enabled: false },
+    intercomBridge: { mode: "off", resultDelivery: false },
+    globalConcurrencyLimit: 1,
+    maxSubagentSpawnsPerSession: 1,
     maxSubagentDepth: 1,
     defaultSessionDir: "~/.pi/agent/sessions/subagent",
     singleRunOutputBaseDir: "~/.pi/agent/subagent-outputs",
     worktreeBaseDir: "~/.pi/agent/worktrees/pi-subagents",
-    scheduledRuns: { enabled: false, maxPending: 20, maxLatenessMs: 300000 },
-    parallel: { maxTasks: 6, concurrency: 3 },
+    scheduledRuns: { enabled: false, maxPending: 1, maxLatenessMs: 300000 },
+    parallel: { maxTasks: 1, concurrency: 1 },
     completionBatch: { enabled: true, debounceMs: 150, maxWaitMs: 1000, stragglerDebounceMs: 75, stragglerMaxWaitMs: 400, stragglerWindowMs: 2000 }
   },
   parallel: {
@@ -154,16 +154,16 @@ const presets = {
     asyncByDefault: false,
     asyncWidget: true,
     forceTopLevelAsync: false,
-    waitTool: { enabled: true },
-    intercomBridge: { mode: "always" },
-    globalConcurrencyLimit: 12,
-    maxSubagentSpawnsPerSession: 64,
+    waitTool: { enabled: false },
+    intercomBridge: { mode: "off", resultDelivery: false },
+    globalConcurrencyLimit: 1,
+    maxSubagentSpawnsPerSession: 1,
     maxSubagentDepth: 1,
     defaultSessionDir: "~/.pi/agent/sessions/subagent",
     singleRunOutputBaseDir: "~/.pi/agent/subagent-outputs",
     worktreeBaseDir: "~/.pi/agent/worktrees/pi-subagents",
-    scheduledRuns: { enabled: false, maxPending: 20, maxLatenessMs: 300000 },
-    parallel: { maxTasks: 10, concurrency: 5 },
+    scheduledRuns: { enabled: false, maxPending: 1, maxLatenessMs: 300000 },
+    parallel: { maxTasks: 1, concurrency: 1 },
     completionBatch: { enabled: true, debounceMs: 150, maxWaitMs: 1000, stragglerDebounceMs: 75, stragglerMaxWaitMs: 400, stragglerWindowMs: 2000 }
   }
 };
@@ -223,10 +223,20 @@ const mergedConfig = mergeObject(existingConfig && typeof existingConfig === "ob
 
 const existingSettings = readJson(settingsPath, {});
 const mergedSettings = existingSettings && typeof existingSettings === "object" && !Array.isArray(existingSettings) ? existingSettings : {};
+mergedSettings.subagents = mergedSettings.subagents && typeof mergedSettings.subagents === "object" && !Array.isArray(mergedSettings.subagents)
+  ? mergedSettings.subagents
+  : {};
+mergedSettings.subagents.disableBuiltins = true;
+mergedSettings.subagents.agentOverrides = mergeObject(
+  mergedSettings.subagents.agentOverrides && typeof mergedSettings.subagents.agentOverrides === "object" && !Array.isArray(mergedSettings.subagents.agentOverrides)
+    ? mergedSettings.subagents.agentOverrides
+    : {},
+  {
+    worker: { disabled: true },
+    "piagent-worker": { disabled: true }
+  }
+);
 if (modelScopes[modelScopeName]) {
-  mergedSettings.subagents = mergedSettings.subagents && typeof mergedSettings.subagents === "object" && !Array.isArray(mergedSettings.subagents)
-    ? mergedSettings.subagents
-    : {};
   mergedSettings.subagents.modelScope = modelScopes[modelScopeName];
 }
 
@@ -245,10 +255,8 @@ if (dryRun) {
 } else {
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
   fs.writeFileSync(configPath, `${JSON.stringify(mergedConfig, null, 2)}\n`);
-  if (modelScopes[modelScopeName]) {
-    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-    fs.writeFileSync(settingsPath, `${JSON.stringify(mergedSettings, null, 2)}\n`);
-  }
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, `${JSON.stringify(mergedSettings, null, 2)}\n`);
   console.log(JSON.stringify(report, null, 2));
 }
 NODE

package/scripts/helper-evaluation.mjs

@@ -32,7 +32,7 @@ function helperRequest(role, objective, run) {
   return createHelperRequest({
     policy, objective, taskId: "helper-evaluation", taskRunId: run, sessionId: "private-helper-session",
     parentReadScope: ["src/**"], parentWriteScope: ["src/**"],
-    parentAllowedTools: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
+    parentAllowedTools: ["read", "grep", "find", "ls", "bash", "edit", "write", "apply_patch", "contact_supervisor"],
     requestedWriteScope: role === "worker" ? ["src/**"] : [], singleWriterOwnership: role === "worker" ? "evaluation-writer" : null
   });
 }
@@ -62,7 +62,7 @@ async function lifecycleProbes() {
     return {
       duplicateWork: duplicate.decision === "duplicate" ? 0 : 1,
       budgetViolations: overBudget.disposition === "budget-exceeded" && overBudget.outputDigest === null ? 0 : 1,
-      writerInvariantViolations: firstWriter.decision === "reserved" && secondWriter.decision === "blocked" ? 0 : 1,
+      writerInvariantViolations: firstWriter.decision === "blocked" && secondWriter.decision === "blocked" ? 0 : 1,
       automaticWorkerDelegations: defaultRolePolicy("worker").enabledByDefault ? 1 : 0,
       cancellationLatencyMs: Number((performance.now() - cancelStarted).toFixed(3)),
       timeoutCovered: timedOut.disposition === "timeout" && timedOut.outputDigest === null,

package/scripts/install-global.sh

@@ -28,7 +28,7 @@ Options:
   --no-model-scope                Leave the user's enabledModels untouched.
   --default-model <provider/model[:thinking]>
                                   Default model written to Pi settings
-                                  (default: openai-codex/gpt-5.5:high).
+                                  (default: openai-codex/gpt-5.6-sol:high).
   -h, --help                      Print this help and exit.
 
 Purpose:
@@ -91,7 +91,7 @@ WITH_WEB_ACCESS=true
 WITH_HERDR=false
 CONFIGURE_MODEL_SCOPE=true
 MODEL_SCOPE_PRESET="full"
-DEFAULT_MODEL="openai-codex/gpt-5.5:high"
+DEFAULT_MODEL="openai-codex/gpt-5.6-sol:high"
 DRY_RUN=false
 FLOATING_PACKAGE_SOURCE=false
 RESOLVED_CHANNEL_LABEL="custom"

package/scripts/pi-usage-history.mjs

@@ -202,14 +202,29 @@ function emptyTotals() {
   };
 }
 
-function addTotals(target, usage) {
-  target.input += numberValue(usage.input);
-  target.output += numberValue(usage.output);
-  target.cacheRead += numberValue(usage.cacheRead);
-  target.cacheWrite += numberValue(usage.cacheWrite);
-  target.reasoning += numberValue(usage.reasoning);
-  target.total += numberValue(usage.totalTokens)
-    || numberValue(usage.input) + numberValue(usage.output) + numberValue(usage.cacheRead) + numberValue(usage.cacheWrite);
+function exactToken(raw, label) {
+  if (!Number.isSafeInteger(raw) || raw < 0) throw new Error(`${label} must be a non-negative safe integer`);
+  return raw;
+}
+
+function addTotals(target, usage, { strict = false, label = "usage" } = {}) {
+  const values = strict ? {
+    input: exactToken(usage?.input, `${label}.input`),
+    output: exactToken(usage?.output, `${label}.output`),
+    cacheRead: exactToken(usage?.cacheRead, `${label}.cacheRead`),
+    cacheWrite: exactToken(usage?.cacheWrite, `${label}.cacheWrite`),
+    reasoning: exactToken(usage?.reasoning, `${label}.reasoning`),
+    total: exactToken(usage?.totalTokens, `${label}.totalTokens`)
+  } : {
+    input: numberValue(usage.input), output: numberValue(usage.output), cacheRead: numberValue(usage.cacheRead),
+    cacheWrite: numberValue(usage.cacheWrite), reasoning: numberValue(usage.reasoning),
+    total: numberValue(usage.totalTokens) || numberValue(usage.input) + numberValue(usage.output) + numberValue(usage.cacheRead) + numberValue(usage.cacheWrite)
+  };
+  if (strict && values.total !== values.input + values.output + values.cacheRead + values.cacheWrite) {
+    throw new Error(`${label}.totalTokens does not equal the reported token categories`);
+  }
+  if (strict && values.reasoning > values.output) throw new Error(`${label}.reasoning exceeds output`);
+  for (const field of ["input", "output", "cacheRead", "cacheWrite", "reasoning", "total"]) target[field] += values[field];
   const cost = usage.cost;
   target.cost += typeof cost === "object" && cost !== null
     ? numberValue(cost.total)
@@ -254,6 +269,7 @@ function summarizeSession(file, options) {
     messages: { user: 0, assistant: 0, toolCalls: 0, toolResults: 0, total: 0 },
     promptChars: 0,
     tokens: emptyTotals(),
+    usageIntegrity: { exact: options.strictUsage === true, source: "pi-session-jsonl", assistantMessages: 0, usageMessages: 0 },
     toolNames: {},
     sizeBytes: stat.size,
     mtime: stat.mtime
@@ -261,12 +277,13 @@ function summarizeSession(file, options) {
 
   let hasCountedActivity = false;
   const lines = fs.readFileSync(file, "utf8").split(/\n/);
-  for (const line of lines) {
+  for (const [lineIndex, line] of lines.entries()) {
     if (!line) continue;
     let entry;
     try {
       entry = JSON.parse(line);
     } catch {
+      if (options.strictUsage) throw new Error(`Pi session JSONL line ${lineIndex + 1} is not valid JSON`);
       continue;
     }
 
@@ -311,9 +328,16 @@ function summarizeSession(file, options) {
       summary.promptChars += extractTextLength(message.content);
     } else if (role === "assistant") {
       summary.messages.assistant += 1;
+      summary.usageIntegrity.assistantMessages += 1;
       if (message.provider && !summary.provider) summary.provider = String(message.provider);
       if (message.model && !summary.modelId) summary.modelId = String(message.model);
-      if (message.usage) addTotals(summary.tokens, message.usage);
+      if (options.strictUsage && (!message.usage || typeof message.usage !== "object" || Array.isArray(message.usage))) {
+        throw new Error(`Pi assistant message at line ${lineIndex + 1} is missing usage`);
+      }
+      if (message.usage) {
+        addTotals(summary.tokens, message.usage, { strict: options.strictUsage === true, label: `Pi session JSONL line ${lineIndex + 1} usage` });
+        summary.usageIntegrity.usageMessages += 1;
+      }
       if (Array.isArray(message.content)) {
         for (const block of message.content) {
           if (block?.type !== "toolCall") continue;
@@ -336,6 +360,9 @@ function summarizeSession(file, options) {
   if (!summary.countedLastTimestamp) summary.countedLastTimestamp = summary.lastTimestamp;
 
   if (!hasCountedActivity && (options.since || options.until)) return undefined;
+  if (options.strictUsage && summary.usageIntegrity.assistantMessages !== summary.usageIntegrity.usageMessages) {
+    throw new Error("Pi session JSONL usage coverage is incomplete");
+  }
   return summary;
 }
 

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.5:high)
+                                  Configure default provider/model/thinking (default: openai-codex/gpt-5.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.5:high"
+DEFAULT_MODEL="openai-codex/gpt-5.6-sol:high"
 AUTO_INSTALL_PI=true
 FORCE_PROFILE=false
 FORCE_SETTINGS=false

package/scripts/team-doctor.sh

@@ -506,7 +506,7 @@ const productReadiness = {
   subagents: { packageAvailable: piHasSubagents, roleDefinitions: rootPackage.pi?.subagents?.agents ?? [] },
   executionBackend: projectProfile?.executionBackend?.type ?? "host",
   executionBoundary: "host execution is not a sandbox",
-  featureModes: { solver: process.env.PIAGENT_SOLVER_MODE ?? "shadow", phaseTools: process.env.PIAGENT_PHASE_TOOLS ?? "shadow", recovery: process.env.PIAGENT_AUTO_RECOVERY ?? "on", helpers: process.env.PIAGENT_HELPERS_MODE ?? "recommend" },
+  featureModes: { solver: process.env.PIAGENT_SOLVER_MODE ?? "shadow", phaseTools: process.env.PIAGENT_PHASE_TOOLS ?? "shadow", recovery: process.env.PIAGENT_AUTO_RECOVERY ?? "on", helpers: process.env.PIAGENT_HELPERS_MODE ?? "off" },
   migrationRecovery: { taskStateExists: fs.existsSync(path.join(stateRoot, "tasks")), handoffStateExists: fs.existsSync(path.join(stateRoot, "handoffs")), action: "run piagent-doctor --json and inspect /piagent-status before deleting state" },
   supportedPlatform: runtime.status,
   rollbackTarget: { packageVersion: rootPackage.version ?? null, instruction: "reinstall the last known-good exact version after operator confirmation; project state is preserved" }