@piagent/platform 1.5.4 → 1.6.0

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/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
   });
 }

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/piagent-dashboard.mjs

@@ -122,6 +122,17 @@ async function currentLaunchUrl() {
   return null;
 }
 
+async function waitForGatewayStopped(previous, timeoutMs = 8_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const previousAlive = Boolean(previous && processAlive(previous.pid));
+    const liveUrl = await currentLaunchUrl();
+    if (!previousAlive && !liveUrl) return;
+    await new Promise((resolve) => setTimeout(resolve, 80));
+  }
+  throw new Error("gateway-restart-stop-timeout\nThe previous Gateway did not stop; restart refused to reuse the old process.");
+}
+
 async function ensureStarted() {
   const existing = await currentLaunchUrl();
   if (existing) return existing;
@@ -199,8 +210,9 @@ async function main() {
     return;
   }
   if (command === "restart") {
+    const previous = readGatewayDescriptor(gatewayProfileState(agentDir));
     try { await control("stop"); } catch { /* already stopped */ }
-    await new Promise((resolve) => setTimeout(resolve, 150));
+    await waitForGatewayStopped(previous);
     const launchUrl = await ensureStarted();
     output(json ? { state: "running", launchUrl } : launchUrl);
     openBrowser(launchUrl);

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/verify-local.sh

@@ -211,6 +211,7 @@ required_files=(
   "$ROOT/schemas/piagent-webui/approval-v1.schema.json"
   "$ROOT/schemas/piagent-webui/capabilities-v1.schema.json"
   "$ROOT/schemas/piagent-webui/session-catalog-v1.schema.json"
+  "$ROOT/schemas/piagent-webui/session-live-state-v1.schema.json"
   "$ROOT/schemas/piagent-webui/session-command-v1.schema.json"
   "$ROOT/schemas/piagent-webui/gateway-capabilities-v1.schema.json"
   "$ROOT/schemas/piagent-webui/gateway-protocol-v1.schema.json"
@@ -235,6 +236,7 @@ required_files=(
   "$ROOT/packages/piagent-webui/contracts/generated/attachment-v1.ts"
   "$ROOT/packages/piagent-webui/contracts/generated/document-workspace-v1.ts"
   "$ROOT/packages/piagent-webui/contracts/generated/session-catalog-v1.ts"
+  "$ROOT/packages/piagent-webui/contracts/generated/session-live-state-v1.ts"
   "$ROOT/packages/piagent-webui/contracts/generated/session-command-v1.ts"
   "$ROOT/packages/piagent-webui/contracts/generated/gateway-capabilities-v1.ts"
   "$ROOT/packages/piagent-webui/contracts/generated/gateway-protocol-v1.ts"
@@ -303,6 +305,7 @@ required_files=(
   "$ROOT/packages/piagent-webui/gateway/session-command-store.ts"
   "$ROOT/packages/piagent-webui/gateway/session-lease-store.ts"
   "$ROOT/packages/piagent-webui/gateway/session-metadata-store.ts"
+  "$ROOT/packages/piagent-webui/gateway/session-operation-watchdog.ts"
   "$ROOT/packages/piagent-webui/gateway/session-runtime-supervisor.ts"
   "$ROOT/packages/piagent-webui/server/gateway-websocket.ts"
   "$ROOT/packages/piagent-webui/extension/piagent-webui.ts"
@@ -590,6 +593,7 @@ const jsonFiles = [
   "schemas/piagent-webui/approval-v1.schema.json",
   "schemas/piagent-webui/capabilities-v1.schema.json",
   "schemas/piagent-webui/session-catalog-v1.schema.json",
+  "schemas/piagent-webui/session-live-state-v1.schema.json",
   "schemas/piagent-webui/session-command-v1.schema.json",
   "schemas/piagent-webui/gateway-capabilities-v1.schema.json",
   "schemas/piagent-webui/gateway-protocol-v1.schema.json",
@@ -959,7 +963,7 @@ if [[ "$OFFLINE" == true || "${PIAGENT_VERIFY_OFFLINE:-}" == "1" || "${CI:-}" ==
 else
   bash "$ROOT/scripts/pi-model-catalog.sh" --json >/dev/null
 fi
-bash "$ROOT/scripts/configure-model-scope.sh" --dry-run --preset full --default-model openai-codex/gpt-5.5:high >/dev/null
+bash "$ROOT/scripts/configure-model-scope.sh" --dry-run --preset full --default-model openai-codex/gpt-5.6-sol:high >/dev/null
 node "$ROOT/scripts/mcp-manage.mjs" --list >/dev/null
 node "$ROOT/scripts/mcp-manage.mjs" --dry-run --preset popular --scope project --project "$ROOT" >/dev/null
 node --input-type=module - "$ROOT" <<'NODE'

package/templates/global/settings.json

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