humanish 0.127.0 → 0.128.0

package/dist/routes/computer-use/fanout-bundle.js

@@ -37,14 +37,18 @@ function fanoutPlanEvents(args) {
 }
 /**
  * The run's summary in plain sentences: who took part, what happened to them with the denominator
- * attached, and that the gaps list the participants who did not pass.
+ * attached, and that the gaps list the participants who did not pass. A participant the run
+ * skipped before its session started never used the app, so it is counted in a sentence of its
+ * own.
  */
 function fanoutSummary(args, facts) {
     const count = args.specs.length;
     const people = plural(count, "participant");
     const rerun = args.rerun === undefined ? "" : `Rerun from ${args.rerun.sourceRunId}: `;
+    // The live summary is written once, before any participant starts, so it names the plan: by
+    // the time it is read a participant may still be waiting, or skipped.
     if (args.inProgress === true) {
-        return `${people} ${count === 1 ? "is" : "are"} each using their own copy of the app. The run is still going, so nothing here is final.`;
+        return `${people} ${count === 1 ? "is planned, in its own copy" : "are planned, each in their own copy"} of the app. The run is still going, so nothing here is final.`;
     }
     if (args.dryRun) {
         return `${rerun}Dry run: ${people} would each use their own copy of ${subjectName(publicSafeAppUrlLabel(args.appUrl), args.aggregateSubject)}. No desktops were launched and $0 was spent.`;
@@ -52,7 +56,20 @@ function fanoutSummary(args, facts) {
     const tasks = facts.tasks === undefined ? "" : ` Tasks: ${facts.tasks}.`;
     // A host suspension comes first: it may explain everything after it.
     const host = args.hostSuspension === undefined ? "" : `${args.hostSuspension.summary} `;
-    return `${host}${rerun}${people} took part, each in their own copy of the app: ${facts.outcomes}${gapsListClause(count - facts.passed, count)}.${tasks}`;
+    const tookPart = count - facts.skipped;
+    const outcomes = facts.outcomes ?? `0/${tookPart} finished a session`;
+    const gaps = gapsListClause(tookPart - facts.passed, tookPart);
+    const sentences = [];
+    // A run where every participant was skipped has no one to describe in this sentence.
+    if (tookPart > 0)
+        sentences.push(`${plural(tookPart, "participant")} took part, ${tookPart === 1 ? "in its own copy" : "each in their own copy"} of the app: ${outcomes}${gaps}.`);
+    // The gaps are pointed at once: here only when the sentence before did not.
+    const why = gaps === "" ? "; the gaps say why" : "";
+    if (facts.skipped === 1)
+        sentences.push(`1 participant was skipped before its session started${why}.`);
+    if (facts.skipped > 1)
+        sentences.push(`${facts.skipped} participants were skipped before their sessions started${why}.`);
+    return `${host}${rerun}${sentences.join(" ")}${tasks}`;
 }
 /**
  * The review's gaps: one line for the participants a host suspension likely failed, then a line
@@ -75,6 +92,7 @@ function fanoutReview(args, streams, judgment) {
     // The judge's verdict: live fan-out must prove every participant (judgeParticipants).
     const verdict = args.verdict;
     const passedParticipants = judgment.participants.filter((participant) => participant.judgedStatus === "passed").length;
+    const skippedParticipants = (outcomes ?? []).filter((outcome) => outcome?.skippedReason !== undefined).length;
     // What happened to the participants, with the denominator attached. The verdict above has to
     // collapse the run to one word; this does not (docs/principles/three-roles.md).
     const terminalOutcomes = (outcomes ?? []).filter((outcome) => outcome?.session?.status !== undefined);
@@ -103,9 +121,10 @@ function fanoutReview(args, streams, judgment) {
         // sandbox, so the summary carries its digest, which verify accepts in a shared run.
         summary: fanoutSummary(args, {
             passed: passedParticipants,
-            outcomes: participants === undefined
-                ? `0/${args.specs.length} finished a session`
-                : formatParticipantOutcomes(participants, participantEndings),
+            skipped: skippedParticipants,
+            ...(participants === undefined
+                ? {}
+                : { outcomes: formatParticipantOutcomes(participants, participantEndings) }),
             ...(runTasks === undefined ? {} : { tasks: formatRunTaskFunnel(runTasks) }),
         }),
         gaps: args.inProgress === true

package/dist/routes/computer-use/participant-model.js

@@ -153,7 +153,7 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
                     const crossed = deps.runBudget.crossed();
                     return crossed === undefined
                         ? null
-                        : `study budget reached: ${crossed}; this lane stops here and sibling lanes stop at their next turn`;
+                        : `study budget reached: ${crossed}; the study's participants stop before their next model request`;
                 },
             }),
         ...(deps.onObservedUrl === undefined ? {} : { onObservedUrl: deps.onObservedUrl }),

package/dist/run/bundle.d.ts

@@ -7,14 +7,17 @@ import type { RunInterruptSignal } from "./status.js";
 import type { RunSimulationStatus, RunStream, RunStreamKind } from "./streams.js";
 /**
  * The run bundle version this release writes: each stream's trace, and each running participant's
- * items so far, are files run.json indexes.
+ * items so far, are files run.json indexes, and each participant's per-request lists are only in
+ * its trace file (REQUEST_LISTS in src/run/stream-trace.ts).
  */
-export declare const RUN_BUNDLE_SCHEMA = "humanish.run-bundle.v3";
+export declare const RUN_BUNDLE_SCHEMA = "humanish.run-bundle.v4";
+/** The version 0.125.0 and 0.126.0 wrote, with the per-request lists in run.json too. It is still read. */
+export declare const RUN_BUNDLE_V3_SCHEMA = "humanish.run-bundle.v3";
 /** The version 0.123.0 and 0.124.0 wrote, with a running participant's items inline. It is still read. */
 export declare const RUN_BUNDLE_V2_SCHEMA = "humanish.run-bundle.v2";
 /** The version 0.122.0 and earlier wrote, with every trace inline. It is still read. */
 export declare const RUN_BUNDLE_V1_SCHEMA = "humanish.run-bundle.v1";
-/** Whether `value` names a run bundle version this release reads: v3, v2 or v1. */
+/** Whether `value` names a run bundle version this release reads: v4, v3, v2 or v1. */
 export declare function isReadRunBundleSchema(value: unknown): value is RunBundle["schema"];
 /** The run bundle file, relative to the run directory. */
 export declare const RUN_BUNDLE_FILE = "run.json";
@@ -238,7 +241,7 @@ export interface RunBundle {
         restrictions: ["real-communications"];
     };
     commsReceiving?: CommsReceivingEvidence;
-    schema: typeof RUN_BUNDLE_SCHEMA | typeof RUN_BUNDLE_V2_SCHEMA | typeof RUN_BUNDLE_V1_SCHEMA;
+    schema: typeof RUN_BUNDLE_SCHEMA | typeof RUN_BUNDLE_V3_SCHEMA | typeof RUN_BUNDLE_V2_SCHEMA | typeof RUN_BUNDLE_V1_SCHEMA;
     runId: string;
     mode: "dry-run" | "live";
     simCount: number;

package/dist/run/bundle.js

@@ -3,16 +3,22 @@ import { captureGitState } from "./git-state.js";
 import { studyFields } from "./study-provenance.js";
 /**
  * The run bundle version this release writes: each stream's trace, and each running participant's
- * items so far, are files run.json indexes.
+ * items so far, are files run.json indexes, and each participant's per-request lists are only in
+ * its trace file (REQUEST_LISTS in src/run/stream-trace.ts).
  */
-export const RUN_BUNDLE_SCHEMA = "humanish.run-bundle.v3";
+export const RUN_BUNDLE_SCHEMA = "humanish.run-bundle.v4";
+/** The version 0.125.0 and 0.126.0 wrote, with the per-request lists in run.json too. It is still read. */
+export const RUN_BUNDLE_V3_SCHEMA = "humanish.run-bundle.v3";
 /** The version 0.123.0 and 0.124.0 wrote, with a running participant's items inline. It is still read. */
 export const RUN_BUNDLE_V2_SCHEMA = "humanish.run-bundle.v2";
 /** The version 0.122.0 and earlier wrote, with every trace inline. It is still read. */
 export const RUN_BUNDLE_V1_SCHEMA = "humanish.run-bundle.v1";
-/** Whether `value` names a run bundle version this release reads: v3, v2 or v1. */
+/** Whether `value` names a run bundle version this release reads: v4, v3, v2 or v1. */
 export function isReadRunBundleSchema(value) {
-    return (value === RUN_BUNDLE_SCHEMA || value === RUN_BUNDLE_V2_SCHEMA || value === RUN_BUNDLE_V1_SCHEMA);
+    return (value === RUN_BUNDLE_SCHEMA ||
+        value === RUN_BUNDLE_V3_SCHEMA ||
+        value === RUN_BUNDLE_V2_SCHEMA ||
+        value === RUN_BUNDLE_V1_SCHEMA);
 }
 /** The run bundle file, relative to the run directory. */
 export const RUN_BUNDLE_FILE = "run.json";

package/dist/run/detail.js

@@ -72,7 +72,7 @@ function participantFrom(stream, index, savedPersonaId) {
         ...(typeof trace.counts?.turns === "number" ? { turns: trace.counts.turns } : {}),
         ...(typeof trace.counts?.actions === "number" ? { actions: trace.counts.actions } : {}),
         ...(thoughts > 0 ? { thoughts } : {}),
-        ...costOf(trace),
+        ...costOf(trace, stream.traceUnavailable === undefined),
         ...(stream.traceUnavailable === undefined
             ? {}
             : { evidenceUnavailable: stream.traceUnavailable }),
@@ -85,13 +85,19 @@ function participantFrom(stream, index, savedPersonaId) {
  * model it prices at, so the same estimator gives a figure mid-run instead of the screen reporting
  * the cost as unknown until the moment the run ends. That is the half of a run where knowing what
  * it is costing actually changes what you do.
+ *
+ * Without `rowsLoaded` (the loader refused the participant's trace) only a recorded figure is
+ * shown: long-context pricing needs each request's input size, and the totals alone can price
+ * under half of what the rows give.
  */
-function costOf(trace) {
+function costOf(trace, rowsLoaded) {
     if (trace.executionProfile?.billing === "account-unknown")
         return { estimatedCostUsd: null };
     const recorded = trace.estimatedCost?.estimatedCostUsd;
     if (recorded !== undefined)
         return { estimatedCostUsd: recorded };
+    if (!rowsLoaded)
+        return {};
     const usage = trace.tokenUsage;
     const model = trace.ids?.model;
     if (usage === undefined || typeof model !== "string")

package/dist/run/locate.d.ts

@@ -44,8 +44,8 @@ export declare function readSafeRunArtifactJson(runPaths: PreparedRunArtifactPat
  * A run's bundle as `humanish verify` reads it, for a reader outside humanish: run.json of run
  * `runInput` (a run id, or `latest`) under `cwdInput`'s `.humanish/runs/`, with every participant's
  * trace file and, while the run is in progress, live file joined, so each stream has its
- * `actor.items`, its screenshot entries and its `liveActor.items` as a v1 run.json held them. It
- * reads run bundles v1, v2 and v3. Each file must match the index run.json records for it (path,
+ * `actor.items`, its per-request lists, its screenshot entries and its `liveActor.items` as a v1
+ * run.json held them. It reads run bundles v1, v2, v3 and v4. Each file must match the index run.json records for it (path,
  * size, sha256, item count); one that does not throws an Error named `StreamTraceRefusedError`
  * that names the participant. Resolves to null when there is no such run, or its run.json is not
  * a run bundle. `bundlePath` is run.json relative to `cwdInput`, `runDir` the run folder.

package/dist/run/locate.js

@@ -105,8 +105,8 @@ export async function readSafeRunArtifactJson(runPaths, relativePath) {
  * A run's bundle as `humanish verify` reads it, for a reader outside humanish: run.json of run
  * `runInput` (a run id, or `latest`) under `cwdInput`'s `.humanish/runs/`, with every participant's
  * trace file and, while the run is in progress, live file joined, so each stream has its
- * `actor.items`, its screenshot entries and its `liveActor.items` as a v1 run.json held them. It
- * reads run bundles v1, v2 and v3. Each file must match the index run.json records for it (path,
+ * `actor.items`, its per-request lists, its screenshot entries and its `liveActor.items` as a v1
+ * run.json held them. It reads run bundles v1, v2, v3 and v4. Each file must match the index run.json records for it (path,
  * size, sha256, item count); one that does not throws an Error named `StreamTraceRefusedError`
  * that names the participant. Resolves to null when there is no such run, or its run.json is not
  * a run bundle. `bundlePath` is run.json relative to `cwdInput`, `runDir` the run folder.

package/dist/run/run.js

@@ -122,8 +122,9 @@ function observerTarget(options) {
  * run.json for `bundle`, written after every live file and trace file it indexes, then the removal
  * of the live files it no longer names. Returns the bundle the review and the projections read:
  * raw sandbox ids scrubbed, each finished trace inline, each running participant's items as the
- * index of its live file, and the live files' warning among the events. Live items are scrubbed
- * as they are appended, so the scrub of the bundle no longer walks them.
+ * index of its live file with the estimate run.json records for it, and the live files' warning
+ * among the events. Live items are scrubbed as they are appended, so the scrub of the bundle no
+ * longer walks them.
  */
 async function writeRunJson(paths, liveItems, bundle) {
     const sandboxIds = await readRunSandboxIds(paths);
@@ -138,7 +139,14 @@ async function writeRunJson(paths, liveItems, bundle) {
         await writeContainedOutputFile(paths, file.path, file.bytes);
     await writeContainedOutputFile(paths, RUN_BUNDLE_FILE, json(split.bundle), "utf8");
     await live.published();
-    return publicBundle;
+    // The split prices each running participant from the rows it leaves out of run.json.
+    const streams = publicBundle.streams.map((stream, index) => {
+        const estimate = split.bundle.streams[index]?.liveActor?.estimatedCost;
+        return stream.liveActor === undefined || estimate === undefined
+            ? stream
+            : { ...stream, liveActor: { ...stream.liveActor, estimatedCost: estimate } };
+    });
+    return { ...publicBundle, streams };
 }
 function runPublisher(args) {
     const { options, runId, createdAt, paths, runStatus, now, admit, participantsRan } = args;

package/dist/run/stream-trace.d.ts

@@ -7,12 +7,15 @@ export declare class StreamTraceRefusedError extends Error {
     readonly streamId: string;
     constructor(streamId: string, detail: string);
 }
+/** `trace` without the per-request lists; every other field as it is. */
+export declare function withoutRequestLists<T extends object>(trace: T): T;
 /**
  * The run.json the run writes, and the trace files it writes first. Each stream with a finished
- * actor keeps that actor without `items`, its artifacts other than screenshots, and an index of its
- * trace file; the file is the actor trace with the stream's screenshot entries as `artifacts`. A
- * stream already split (its actor read back from a v2 run.json without its items) keeps its index,
- * since its file is on disk.
+ * actor keeps that actor without `items` and the per-request lists, its artifacts other than
+ * screenshots, and an index of its trace file; the file is the whole actor trace with the stream's
+ * screenshot entries as `artifacts`. A stream already split (its actor read back from run.json
+ * without its items) keeps its index, since its file is on disk, and loses any lists an older
+ * run.json held beside it. A running participant's live actor is written by liveSummary.
  */
 export declare function splitStreamTraces(bundle: RunBundle): {
     bundle: RunBundle;
@@ -54,6 +57,12 @@ type LiveAfter = (index: LiveItemsIndex) => LiveItemsCursor | undefined;
  * actor, two participants indexing one file) are loadStreamTraces'.
  */
 export declare function loadStreamTrace(runPaths: PreparedOutputRoot, stream: RunStream, maxBytes?: number): Promise<RunStream>;
+/**
+ * Whether a run.json of `schema` holds the per-request lists (REQUEST_LISTS) the writer kept in
+ * it: v1 to v3, and a schema WRITER_RULES does not name, which is read as v1. From v4 they are
+ * only in the trace file, so a running participant's `liveActor` holds none.
+ */
+export declare const keepsRequestListsInRunJson: (schema: string) => boolean;
 interface LoadedTraces {
     bundle: RunBundle;
     refused: StreamTraceRefusedError[];
@@ -85,9 +94,10 @@ export declare function loadStreamTraces(source: PreparedOutputRoot | TraceFileR
 }): Promise<LoadedTraces>;
 /**
  * A loaded bundle as a reader that shows a run presents it. A refused stream keeps run.json's
- * summary, shows none of the items run.json or a file supplied for it (its actor's items, its
- * in-progress items, its screenshot entries), and carries `traceUnavailable` with the reason; a
- * warn event on its timeline says the same.
+ * summary, shows none of the items or per-request lists run.json or a file supplied for it (its
+ * actor's items and lists, its in-progress items, its screenshot entries), and carries
+ * `traceUnavailable` with the reason; a warn event on its timeline says the same. A reader that
+ * shows the run then never prices or checks rows the loader refused.
  */
 export declare function displayedTraces(loaded: {
     bundle: RunBundle;

package/dist/run/stream-trace.js

@@ -1,14 +1,16 @@
 // Where a participant's trace lives. A v1 run.json holds every stream's trace items and screenshot
 // entries inline. From v2 the run writer moves them into one file per stream and leaves an index
 // in run.json, so run.json stays a summary whatever the length of the sessions. From v3 a running
-// participant's items so far are in a live file run.json indexes too (src/run/live-items.ts).
-// Every reader that needs the items loads them here, which accepts every version and checks each
-// file against its index.
+// participant's items so far are in a live file run.json indexes too (src/run/live-items.ts). From
+// v4 the per-request lists (REQUEST_LISTS) are only in the trace file, and a running participant
+// carries its totals and the estimate priced from its rows. Every reader that needs the items or
+// the lists loads them here, which accepts every version and checks each file against its index.
 import { createHash } from "node:crypto";
-import { RUN_BUNDLE_FILE, RUN_BUNDLE_SCHEMA, RUN_BUNDLE_V2_SCHEMA, } from "./bundle.js";
+import { RUN_BUNDLE_FILE, RUN_BUNDLE_SCHEMA, RUN_BUNDLE_V2_SCHEMA, RUN_BUNDLE_V3_SCHEMA, } from "./bundle.js";
 import { isRunBundle } from "./bundle-shape.js";
 import { readContainedPrefix, readContainedRegularFile, refusalText, RUN_ARTIFACT_MAX_BYTES, } from "./contained-output.js";
 import { isLiveItemsIndex, LIVE_ACTOR_SCHEMA, LIVE_ACTOR_V1_SCHEMA, liveItemsAfter, liveItemsFromBytes, } from "./live-items.js";
+import { estimateActorCostForExecution } from "./pricing.js";
 import { isRunStreamArtifact, isStreamTraceIndex, isStreamTracePath } from "./stream-shape.js";
 import { isRecord } from "./type-guards.js";
 /** A trace that does not match its index, or cannot be read. The message names the stream. */
@@ -43,12 +45,64 @@ function tracePath(stream, index, claimed) {
         !POSITION_TRACE_FILE.test(artifact.path))?.path;
     return own !== undefined && !claimed.has(traceFileKey(own)) ? own : `actors/${index + 1}.json`;
 }
+/**
+ * A participant's lists that gain one entry per model request, as paths into its actor trace. From
+ * run bundle v4 run.json leaves them out of `actor` and `liveActor`, and the trace file alone holds
+ * them; the Observer's data leaves them out too.
+ */
+const REQUEST_LISTS = ["tokenUsage.turns", "conversation.requests", "providerRequests"];
+/** The value at `list`'s path in `trace`, when the object holding it is there. */
+function listIn(trace, list) {
+    const [first, second] = list.split(".");
+    if (second === undefined)
+        return trace[first];
+    const parent = trace[first];
+    return isRecord(parent) ? parent[second] : undefined;
+}
+/** `trace` without the per-request lists; every other field as it is. */
+export function withoutRequestLists(trace) {
+    const copy = { ...trace };
+    for (const list of REQUEST_LISTS) {
+        const [first, second] = list.split(".");
+        const parent = copy[first];
+        if (second === undefined)
+            delete copy[first];
+        else if (isRecord(parent) && second in parent) {
+            const { [second]: _list, ...rest } = parent;
+            copy[first] = rest;
+        }
+    }
+    return copy;
+}
+/** The first per-request list `trace` holds, if any. */
+function heldRequestList(trace) {
+    return REQUEST_LISTS.find((list) => listIn(trace, list) !== undefined);
+}
+/**
+ * run.json's live actor: without the per-request lists, and with the estimate priced from the
+ * rows it leaves out. Long-context pricing needs each request's input size, so a figure priced
+ * from the totals alone could be under half the real one. A live actor read back from run.json
+ * has no rows and keeps the estimate they gave.
+ */
+function liveSummary(live) {
+    const summary = withoutRequestLists(live);
+    const model = live.ids?.model;
+    if (live.tokenUsage === undefined || typeof model !== "string")
+        return summary;
+    if (live.tokenUsage.turns === undefined && live.estimatedCost !== undefined)
+        return summary;
+    return {
+        ...summary,
+        estimatedCost: estimateActorCostForExecution(live.tokenUsage, model, live.executionProfile),
+    };
+}
 /**
  * The run.json the run writes, and the trace files it writes first. Each stream with a finished
- * actor keeps that actor without `items`, its artifacts other than screenshots, and an index of its
- * trace file; the file is the actor trace with the stream's screenshot entries as `artifacts`. A
- * stream already split (its actor read back from a v2 run.json without its items) keeps its index,
- * since its file is on disk.
+ * actor keeps that actor without `items` and the per-request lists, its artifacts other than
+ * screenshots, and an index of its trace file; the file is the whole actor trace with the stream's
+ * screenshot entries as `artifacts`. A stream already split (its actor read back from run.json
+ * without its items) keeps its index, since its file is on disk, and loses any lists an older
+ * run.json held beside it. A running participant's live actor is written by liveSummary.
  */
 export function splitStreamTraces(bundle) {
     const files = [];
@@ -56,10 +110,15 @@ export function splitStreamTraces(bundle) {
     for (const stream of bundle.streams)
         if (stream.trace)
             claimed.add(traceFileKey(stream.trace.path));
-    const streams = bundle.streams.map((stream, index) => {
+    const streams = bundle.streams.map((written, index) => {
+        const stream = written.liveActor === undefined
+            ? written
+            : { ...written, liveActor: liveSummary(written.liveActor) };
         const actor = stream.actor;
-        if (actor === undefined || !Array.isArray(actor.items))
+        if (actor === undefined)
             return stream;
+        if (!Array.isArray(actor.items))
+            return { ...stream, actor: withoutRequestLists(actor) };
         const { trace: _previous, ...rest } = stream;
         const filePath = tracePath(rest, index, claimed);
         // Only a stream already split that moved position can hold this stream's position name.
@@ -72,8 +131,8 @@ export function splitStreamTraces(bundle) {
         const { items, ...summary } = actor;
         return {
             ...rest,
-            // run.json's actor is the summary: every field of the trace except its items.
-            actor: summary,
+            // run.json's actor is the summary: every field of the trace except its items and lists.
+            actor: withoutRequestLists(summary),
             artifacts: stream.artifacts.filter((artifact) => !isScreenshot(artifact)),
             trace: {
                 path: filePath,
@@ -125,13 +184,38 @@ function joinTrace(stream, bytes) {
         refuse(`${index.path} lists an artifact that is not a screenshot entry`);
     if (value.items.length !== index.items || artifacts.length !== index.screenshots)
         refuse(`${index.path} holds ${value.items.length} items and ${artifacts.length} screenshots and run.json records ${index.items} and ${index.screenshots}`);
+    const actor = joinRequestLists(stream.actor, value, index.path, refuse);
     const { trace: _index, ...rest } = stream;
     return {
         ...rest,
-        actor: { ...stream.actor, items: value.items },
+        actor: { ...actor, items: value.items },
         artifacts: [...stream.artifacts, ...artifacts],
     };
 }
+/**
+ * run.json's actor with each per-request list its trace file holds, whatever the bundle's
+ * version: before v4 the writer wrote run.json's lists and the file's from one actor, so they are
+ * equal. A nested list goes into run.json's `tokenUsage` or `conversation` when run.json has it.
+ */
+function joinRequestLists(summary, file, filePath, refuse) {
+    if (isRecord(file.conversation) && !Array.isArray(file.conversation.requests))
+        refuse(`${filePath} records a conversation without its requests list`);
+    const joined = { ...summary };
+    for (const list of REQUEST_LISTS) {
+        const value = listIn(file, list);
+        if (value === undefined)
+            continue;
+        if (!Array.isArray(value))
+            refuse(`${filePath} holds ${list} as something other than a list`);
+        const [first, second] = list.split(".");
+        const parent = joined[first];
+        if (second === undefined)
+            joined[first] = value;
+        else if (isRecord(parent))
+            joined[first] = { ...parent, [second]: value };
+    }
+    return joined;
+}
 /** Refuses an index the shape check would refuse, naming a file that is not a trace file name. */
 function assertIndex(stream) {
     const index = stream.trace;
@@ -242,16 +326,30 @@ async function readStreamTrace(read, stream, maxBytes, liveAfter) {
 export async function loadStreamTrace(runPaths, stream, maxBytes = RUN_ARTIFACT_MAX_BYTES) {
     return (await readStreamTrace(containedReader(runPaths), stream, maxBytes)).stream;
 }
+/**
+ * What each version's writer never puts in run.json, so a run.json of that version that holds it
+ * did not come from the writer. From v2 the writer indexes every actor on every write, mid-run
+ * flushes included, and the final write replaces `liveActor`. From v3 a running participant's
+ * items are in a live file (humanish.live-actor.v2). From v4 the per-request lists are only in
+ * the trace file. A run.json of v1, or of no version this table names, is read as v1 is.
+ */
+const WRITER_RULES = new Map([
+    [RUN_BUNDLE_V2_SCHEMA, { liveFiles: false, listsOut: false }],
+    [RUN_BUNDLE_V3_SCHEMA, { liveFiles: true, listsOut: false }],
+    [RUN_BUNDLE_SCHEMA, { liveFiles: true, listsOut: true }],
+]);
+/**
+ * Whether a run.json of `schema` holds the per-request lists (REQUEST_LISTS) the writer kept in
+ * it: v1 to v3, and a schema WRITER_RULES does not name, which is read as v1. From v4 they are
+ * only in the trace file, so a running participant's `liveActor` holds none.
+ */
+export const keepsRequestListsInRunJson = (schema) => WRITER_RULES.get(schema)?.listsOut !== true;
 /**
  * Why a stream of this bundle cannot be read, before any file is. A trace file belongs to one
  * participant, so every stream indexing a path another stream indexes, compared as a
- * case-insensitive file system compares them, is refused. In v2 the writer
- * indexes every actor on every write, mid-run flushes included, so a v2 actor without an index lost
- * its trace file, and inline items never come from the writer. A run still writing carries its
- * participants' items so far as `liveActor`: inline in v2 (humanish.live-actor.v1), in a live file
- * from v3 (humanish.live-actor.v2), so a v3 run.json with inline live items did not come from the
- * writer. A run.json whose outcome says the run finished never carries `liveActor`, since the
- * final write replaces it.
+ * case-insensitive file system compares them, is refused in every version. The other rules are
+ * WRITER_RULES': a v2 actor without an index lost its trace file, and a run.json whose outcome says
+ * the run finished never carries `liveActor`.
  */
 function bundleRefusal(bundle, stream, owners) {
     const shared = isRecord(stream.trace)
@@ -259,16 +357,23 @@ function bundleRefusal(bundle, stream, owners) {
         : undefined;
     if (shared !== undefined && shared.length > 1)
         return `run.json indexes ${String(stream.trace.path)} for participants ${shared.join(", ")} (paths that differ only in case name one file on some file systems), and a trace file belongs to one participant`;
-    if (bundle.schema !== RUN_BUNDLE_SCHEMA && bundle.schema !== RUN_BUNDLE_V2_SCHEMA)
+    const rules = WRITER_RULES.get(String(bundle.schema));
+    if (rules === undefined)
         return undefined;
+    const version = String(bundle.schema).replace("humanish.run-bundle.", "");
     if (stream.actor !== undefined && stream.trace === undefined)
         return "run.json holds its actor and names no trace file";
     if (stream.liveActor !== undefined && bundle.outcome?.state === "finished")
         return "run.json records a finished run and still holds in-progress items";
-    if (bundle.schema === RUN_BUNDLE_SCHEMA &&
-        stream.liveActor !== undefined &&
-        isInlineLiveActor(stream.liveActor))
-        return "run.json v3 holds in-progress items inline, which the writer keeps in a live file";
+    if (rules.liveFiles && stream.liveActor !== undefined && isInlineLiveActor(stream.liveActor))
+        return `run.json ${version} holds in-progress items inline, which the writer keeps in a live file`;
+    if (rules.listsOut)
+        for (const field of ["actor", "liveActor"]) {
+            const trace = stream[field];
+            const list = isRecord(trace) ? heldRequestList(trace) : undefined;
+            if (list !== undefined)
+                return `run.json ${version} holds ${list} in its ${field}, which the writer keeps only in the trace file`;
+        }
     return undefined;
 }
 /**
@@ -348,9 +453,10 @@ async function loadEveryStream(read, bundle, maxBytes, liveAfter) {
 }
 /**
  * A loaded bundle as a reader that shows a run presents it. A refused stream keeps run.json's
- * summary, shows none of the items run.json or a file supplied for it (its actor's items, its
- * in-progress items, its screenshot entries), and carries `traceUnavailable` with the reason; a
- * warn event on its timeline says the same.
+ * summary, shows none of the items or per-request lists run.json or a file supplied for it (its
+ * actor's items and lists, its in-progress items, its screenshot entries), and carries
+ * `traceUnavailable` with the reason; a warn event on its timeline says the same. A reader that
+ * shows the run then never prices or checks rows the loader refused.
  */
 export function displayedTraces(loaded) {
     const reasons = new Map(loaded.refused.map((error) => [error.streamId, error.message]));
@@ -363,7 +469,7 @@ export function displayedTraces(loaded) {
         const { liveActor: _live, trace: _index, actor, ...rest } = stream;
         return {
             ...rest,
-            ...(actor === undefined ? {} : { actor: { ...actor, items: [] } }),
+            ...(actor === undefined ? {} : { actor: { ...withoutRequestLists(actor), items: [] } }),
             artifacts: stream.artifacts.filter((artifact) => !isScreenshot(artifact)),
             traceUnavailable: reason,
         };

package/dist/run/streams.d.ts

@@ -289,7 +289,10 @@ export interface RunStream {
      * completionReason, or completedAt, and this shape cannot claim them. Present only on
      * `inProgress` bundles; the final write replaces it with the real `actor` and never
      * carries it. A v3 run.json holds `humanish.live-actor.v2` with `itemsFile` in place of `items`;
-     * the trace loader (src/run/stream-trace.ts) reads the file and puts the items back.
+     * the trace loader (src/run/stream-trace.ts) reads the file and puts the items back. A v4
+     * run.json's live actor also leaves out `tokenUsage.turns` and `providerRequests`, which are
+     * written only in the trace when the participant finishes, and carries the `estimatedCost` the
+     * run writer priced from those rows.
      */
     liveActor?: {
         schema: "humanish.live-actor.v1" | "humanish.live-actor.v2";

package/dist/study/bundle-estimate.js

@@ -4,11 +4,14 @@
 // RUN_ARTIFACT_MAX_BYTES, and the public-safety scan visits at most runEntryLimit(participants)
 // files and folders.
 //
-// observer/index.html carries every participant's items gzipped, so with busy participants it can
-// pass verify's 32 MiB before run.json passes analysis's 16 MiB: at these rates, 17 participants
-// working 8 hours. observer-data.json carries the same per-request lists as run.json and was within
-// 7 % of its size on every live run measured, so it passes 32 MiB only after run.json passes
-// 16 MiB, and the estimate does not check it.
+// observer/index.html carries every participant's items gzipped, so with busy participants it
+// passes verify's 32 MiB long before run.json passes analysis's 16 MiB: at these rates, 20
+// participants working 8 hours. From run bundle v4 run.json grows by participant, not by model
+// request: each participant's per-request lists are only in its trace. run.json can still pass
+// 16 MiB, since a study's mission is not capped and each participant's stream copies it.
+// observer-data.json leaves the lists out too and was 0.94 to 1.12 of run.json's size on the live
+// runs measured, so it passes 32 MiB only after run.json passes 16 MiB, and the estimate does not
+// check it.
 import { EVIDENCE_LIMITS } from "../analysis/analysis-limits.js";
 import { RUN_ARTIFACT_MAX_BYTES } from "../run/contained-output.js";
 import { formatDuration } from "../run/projection.js";
@@ -20,19 +23,16 @@ import { runEntryLimit } from "../verify/scan-limit.js";
 // own files. Pace, session length and screenshots: the live computer-use runs kept on the
 // maintainer's machine. A trace's rate a turn on the public site/public/runs/lobby-0927 run
 // (8 participants, 20 to 78 turns) was 1,579 bytes plus 91 for the page, under the live fit.
+// The run.json and page data rates were measured again on those runs written as v4.
 const RATES = Object.freeze({
     /** run.json bytes for the run itself: its header, study, review and cost. Live fit: 4,381. */
     runBytes: 4_400,
     /**
-     * run.json bytes for each participant before its turns: its stream, actor summary and closing
-     * report request. Live fit: 16,239, plus one request.
+     * run.json bytes for each participant: its stream, actor summary and closing report request.
+     * Live fit on v3: 16,239. Written as v4, the kept runs of one participant held 20,571 to 23,160
+     * bytes and those of two 30,647 to 38,948, beside 20,900 and 37,400 at these rates.
      */
     participantBytes: 16_500,
-    /**
-     * run.json bytes a model turn adds: the request's entries in `tokenUsage.turns` and
-     * `conversation.requests`. Live: 30,623 bytes over 137 requests, 223.5 each.
-     */
-    turnRunBytes: 225,
     /** A trace file's bytes before its turns: the actor summary. Live fit: 5,378. */
     participantTraceBytes: 5_400,
     /**
@@ -63,10 +63,10 @@ const RATES = Object.freeze({
     /** observer/index.html's app before any run data: 1,199,831 bytes on the dry runs. */
     observerAppBytes: 1_200_000,
     /**
-     * The page's compact copy of observer-data.json, as a share of run.json: 0.64 to 0.81 whole on
-     * the live runs, 0.49 for a participant's part, and 0.42 for the per-request entries.
+     * The page's compact copy of observer-data.json, as a share of run.json: 0.71 to 0.84 on the
+     * live runs written as v4, where neither carries the per-request lists.
      */
-    observerPageDataShare: 0.5,
+    observerPageDataShare: 0.85,
     /**
      * The page's gzipped base64 items, as a share of all the traces' bytes: 0.087 to 0.114 on the
      * live runs of two participants, 0.097 for the busiest participant alone (about 475 bytes a
@@ -124,7 +124,7 @@ export function estimateBundle(participants, sessionMs) {
         largestTrace = Math.max(largestTrace, trace);
     }
     const count = participants.length;
-    const runFileBytes = RATES.runBytes + count * RATES.participantBytes + turns * RATES.turnRunBytes;
+    const runFileBytes = RATES.runBytes + count * RATES.participantBytes;
     const screenshots = count + turns + frames;
     const observerPageBytes = Math.round(RATES.observerAppBytes +
         RATES.observerPageDataShare * runFileBytes +
@@ -204,7 +204,7 @@ export function bundleLimitReason(estimate) {
         : `${changes.slice(0, -1).join(", ")}, or ${changes.at(-1)}`;
     return [
         ...passed,
-        `The estimate counts ${counted.join(" and ")}, at a model turn every ${formatDuration(RATES.secondsPerTurn * 1000)} that adds about ${RATES.turnRunBytes} bytes to run.json and up to ${(RATES.turnTraceBytes / 1000).toFixed(1)} KB to the participant's trace.`,
+        `The estimate counts ${counted.join(" and ")}, at a model turn every ${formatDuration(RATES.secondsPerTurn * 1000)} that adds up to ${(RATES.turnTraceBytes / 1000).toFixed(1)} KB to the participant's trace.`,
         "The run goes ahead.",
         `To stay under ${passed.length === 1 ? "the limit" : "the limits"}, ${advice}.`,
     ].join(" ");

package/dist/verify/costs.d.ts

@@ -24,7 +24,11 @@ export declare function contradictsAccountBilling(streams: readonly {
  * a null estimate, or a participant without estimatedCost is fine. A non-null figure must carry its
  * ratesAsOf date + source; a number total must equal round6(sum of only the non-null lines) and a
  * null line may never be coerced to 0. A null estimate must be declared (a reason + null
- * ratesAsOf), mirroring the terminal no-spend proof's null-discipline. Account-billed participants
- * also have their execution profile and provider request receipts checked here.
+ * ratesAsOf), mirroring the terminal no-spend proof's null-discipline. A running participant's
+ * estimate is checked the same way. Account-billed participants also have their execution profile
+ * and provider request receipts checked here. From v4 a running participant's receipts are written
+ * only in its trace when it finishes, so its live actor holds none. The receipts of a stream in
+ * `refused` (its trace the loader refused) are not checked: from v4 they are only in that trace,
+ * and verify reports the refusal.
  */
-export declare function costAndReceiptFindings(bundle: RunBundle): string[];
+export declare function costAndReceiptFindings(bundle: RunBundle, refused: ReadonlySet<string>): string[];