humanish 0.127.1 → 0.129.0

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

@@ -4,7 +4,7 @@ import { actorEnding } from "../../actors/stop-cause.js";
 import { cuaGoalSource } from "../../actors/goal-source.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
-import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, gapsListClause, withCuaReviewProvenance, } from "../../run/outcomes.js";
+import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, gapsListClause, skippedSentence, withCuaReviewProvenance, } from "../../run/outcomes.js";
 import { providerResourcesForOutcome, publicSafeAppUrlLabel } from "./bundle-parts.js";
 import { subjectName } from "../../run/subject-name.js";
 import { participantFeedbackCandidates } from "./participant-feedback.js";
@@ -63,12 +63,9 @@ function fanoutSummary(args, facts) {
     // 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}.`);
+    const skipped = skippedSentence(facts.skipped, gaps === "");
+    if (skipped !== "")
+        sentences.push(skipped);
     return `${host}${rerun}${sentences.join(" ")}${tasks}`;
 }
 /**

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/routes/shared-world/bundle-records.js

@@ -67,7 +67,12 @@ function sharedWorldSimulation(ctx, spec, index, view) {
         mode: "browser-sim",
         progress: inProgress ? 35 : 100,
         currentStep: view.reason,
-        summary: participantSummary(name, { name: "the shared app" }, { trace: session?.trace, sessionError: outcome?.sessionError, inProgress }),
+        summary: participantSummary(name, { name: "the shared app" }, {
+            trace: session?.trace,
+            skippedReason: outcome?.skippedReason,
+            sessionError: outcome?.sessionError,
+            inProgress,
+        }),
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
         ...(args.plan.arrivals.declared

package/dist/routes/shared-world/bundle.d.ts

@@ -7,6 +7,14 @@ export declare function maxSimultaneousWindows(windows: Array<{
     startedAt: number;
     endedAt: number;
 }>): number;
+/**
+ * The windows of the participants that used the app, for overlap and the live-at-once count. A
+ * participant the run skipped before its session started never used it, though its window sits
+ * inside another participant's session. run.json's laneWindows keep that window: verify expects
+ * one per declared participant, and reads overlap from them only on a pass, which a run with a
+ * skipped participant cannot reach.
+ */
+export declare function usedAppWindows(results: readonly ActorRunResult[]): ActorRunResult[];
 /**
  * The judgment for a shared-world bundle's inputs: how each participant ended, plus what the run
  * observed about its world: overlap, a state change under overlap on the provisioned plane, and

package/dist/routes/shared-world/bundle.js

@@ -16,7 +16,7 @@ import { hostOriginDigest } from "./provenance.js";
 import { participantEvent, participantIds } from "../../run/participant-records.js";
 import { sharedWorldParticipantRecords } from "./bundle-records.js";
 import { CONCURRENT_ATTRIBUTION_LIMITS, EXTERNAL_PUBLIC_ATTRIBUTION_LIMITS, } from "./types.js";
-import { gapsListClause } from "../../run/outcomes.js";
+import { gapsListClause, skippedSentence } from "../../run/outcomes.js";
 import { plural } from "../../run/text.js";
 import { describeArrivals } from "../../study/arrivals.js";
 /** Max windows live at the same instant (sweep over start/end points). The simultaneity
@@ -38,6 +38,16 @@ export function maxSimultaneousWindows(windows) {
     }
     return max;
 }
+/**
+ * The windows of the participants that used the app, for overlap and the live-at-once count. A
+ * participant the run skipped before its session started never used it, though its window sits
+ * inside another participant's session. run.json's laneWindows keep that window: verify expects
+ * one per declared participant, and reads overlap from them only on a pass, which a run with a
+ * skipped participant cannot reach.
+ */
+export function usedAppWindows(results) {
+    return results.filter((result) => result.outcome.skippedReason === undefined);
+}
 /**
  * The judgment for a shared-world bundle's inputs: how each participant ended, plus what the run
  * observed about its world: overlap, a state change under overlap on the provisioned plane, and
@@ -52,11 +62,7 @@ export function judgeSharedWorldRun(args) {
         expected: args.actorSpecs.length,
         participants: args.actorResults.map((result) => participantFactsOf(result.outcome)),
         world: {
-            // The same windows and state series the bundle writes, read by verify's pass gate too.
-            ...concurrencyFacts(args.actorSpecs.map((_spec, index) => ({
-                startedAt: args.actorResults[index]?.startedAt ?? 0,
-                endedAt: args.actorResults[index]?.endedAt ?? 0,
-            })), external ? undefined : args.stateSnapshots),
+            ...concurrencyFacts(usedAppWindows(args.actorResults), external ? undefined : args.stateSnapshots),
             ...(external ? { lobbyConvergence: args.lobbyConvergenceDigest !== undefined } : {}),
         },
     });
@@ -68,8 +74,10 @@ export function actorRunPassed(result) {
  * The run's summary in plain sentences: who took part, how many reached the goal, and what the
  * world showed. A participant reached the goal when its session passed the judge's checks and
  * ended at the goal, so a productive `budget_reached` session does not count even when the lobby
- * converged. Each participant's ending stays in `sharedWorld.outcomes`, and the plane, topology
- * and attribution limits stay in the bundle's events and `sharedWorld` block.
+ * converged. A participant the run skipped, such as a follower stopped at the handoff, never used
+ * the app, so it is counted in a sentence of its own. Each participant's ending stays in
+ * `sharedWorld.outcomes`, and the plane, topology and attribution limits stay in the bundle's
+ * events and `sharedWorld` block.
  */
 function sharedWorldSummary(args, facts) {
     const count = args.actorSpecs.length;
@@ -79,16 +87,20 @@ function sharedWorldSummary(args, facts) {
         const served = facts.external ? ", as it is deployed" : ", served from a sandbox";
         return `Dry run: ${people} would use ${app} at the same time${served}. No sandboxes were launched and $0 was spent.`;
     }
+    // The live summary is written once, before any participant starts, so it names the plan.
     if (facts.inProgress) {
-        return `${people} ${count === 1 ? "is" : "are"} using ${app} at the same time. The run is still going, so nothing here is final.`;
+        return `${people} ${count === 1 ? "is planned, in" : "are planned, all in"} ${app}. The run is still going, so nothing here is final.`;
     }
     const passed = facts.outcomes.filter((outcome) => outcome.ok);
     const reached = passed.filter((outcome) => outcome.completionReason === "goal_satisfied").length;
-    const together = facts.overlaps ? " at the same time" : ", but never at the same time";
+    const skipped = args.actorResults.filter((result) => result.outcome.skippedReason !== undefined).length;
+    const tookPart = count - skipped;
+    const together = tookPart === 1 ? "" : facts.overlaps ? " at the same time" : ", but never at the same time";
     // A participant who did not pass has a gap line; one who passed but stopped short has none.
+    const gaps = gapsListClause(tookPart - passed.length, tookPart);
     const rest = [
         passed.length > reached ? `; ${passed.length - reached} ended without reaching it` : "",
-        gapsListClause(count - passed.length, count),
+        gaps,
     ].join("");
     const world = facts.external
         ? args.lobbyConvergenceDigest
@@ -97,7 +109,15 @@ function sharedWorldSummary(args, facts) {
         : facts.deltas === 0
             ? "The app's shared state did not change during the run."
             : `The app's shared state changed ${plural(facts.deltas, "time")} during the run.`;
-    return `${people} used ${app}${together}. ${reached} of ${count} reached the goal${rest}. ${world}`;
+    return [
+        tookPart > 0
+            ? `${plural(tookPart, "participant")} used ${app}${together}. ${reached} of ${tookPart} reached the goal${rest}.`
+            : "",
+        skippedSentence(skipped, gaps === ""),
+        world,
+    ]
+        .filter((sentence) => sentence !== "")
+        .join(" ");
 }
 /** The run's first two events: its creation and the shared plane's provenance. */
 function planeEvents(args, external) {
@@ -261,7 +281,7 @@ function concurrencyReview(args, external, inProgress, evidence, events, nextEve
     // The count that matters is how many participants were live at once, which can be fewer than exist:
     // a 6-participant run capped at 3 must never read as 6-wide concurrency.
     const capForReport = plan.concurrency;
-    const maxLive = maxSimultaneousWindows(windows);
+    const maxLive = maxSimultaneousWindows(usedAppWindows(args.actorResults));
     events.push({
         id: nextEventId("concurrency"),
         at: createdAt,

package/dist/routes/shared-world/participant-specs.d.ts

@@ -12,7 +12,8 @@ export declare function resolveActorEntryUrl(baseUrl: string, entry: string | un
  *  follower joins through the real UI (a direct /lobby/CODE visit does not auto-join a non-member). */
 export declare function withLobbyCodeMission(spec: DesktopParticipantRun, code: string): DesktopParticipantRun;
 /** A follower blocked by an expired deadline or an ended host. It never opened a browser;
- * keep the actual reason rather than turning every upstream failure into a timeout. */
+ * keep the actual reason rather than turning every upstream failure into a timeout. The skip
+ * reason is a sentence in the form the computer-use skips use, since run lines and gaps print it. */
 export declare function makeBlockedFollowerOutcome(spec: DesktopParticipantRun, reason: string, timedOut: boolean): ParticipantRunOutcome;
 /**
  * A live run publishes an in-progress bundle before its participants start, whether or not an

package/dist/routes/shared-world/participant-specs.js

@@ -63,7 +63,8 @@ export function withLobbyCodeMission(spec, code) {
     };
 }
 /** A follower blocked by an expired deadline or an ended host. It never opened a browser;
- * keep the actual reason rather than turning every upstream failure into a timeout. */
+ * keep the actual reason rather than turning every upstream failure into a timeout. The skip
+ * reason is a sentence in the form the computer-use skips use, since run lines and gaps print it. */
 export function makeBlockedFollowerOutcome(spec, reason, timedOut) {
     return {
         spec,
@@ -77,7 +78,9 @@ export function makeBlockedFollowerOutcome(spec, reason, timedOut) {
         noEngagement: true,
         selfReportedBlocker: false,
         harnessError: false,
-        skippedReason: timedOut ? "handoff-timeout" : "host-ended-before-handoff",
+        skippedReason: timedOut
+            ? "skipped: the host did not reach a lobby within the handoff deadline; no desktop was created"
+            : "skipped: the host ended before it reached a lobby; no desktop was created",
     };
 }
 /**

package/dist/routes/shared-world/result.js

@@ -8,7 +8,7 @@ import { validatePreparedRunArtifactPaths } from "../../run/paths.js";
 import { participantExecutionFailures, participantFactsOf, } from "../computer-use/participant-facts.js";
 import { participantCapWarning } from "../computer-use/participant-model.js";
 import { resolveSubjectState } from "../computer-use/subject-projection.js";
-import { actorRunPassed, buildConcurrentSharedWorldBundle, judgeSharedWorldRun, maxSimultaneousWindows, } from "./bundle.js";
+import { actorRunPassed, buildConcurrentSharedWorldBundle, judgeSharedWorldRun, maxSimultaneousWindows, usedAppWindows, } from "./bundle.js";
 import { planeStateOf } from "./plan.js";
 import { buildSubjectProvenance, hostOriginDigest } from "./provenance.js";
 import {} from "./types.js";
@@ -47,9 +47,16 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
         }
         const session = result.outcome.session;
         const thisOk = participantOk(result);
+        const { skippedReason } = result.outcome;
+        // The same judged record run.json writes, so the run line and the bundle name one status.
+        const record = judgeParticipantRecords([participantFactsOf(result.outcome)], {
+            sessionLabel: "Participant",
+            missingSessionMessage: "Actor did not produce a terminal session.",
+        }).participants[0];
         return {
             ...base,
-            status: session ? session.status : "failed",
+            status: record.status,
+            ...(skippedReason === undefined ? {} : { skippedReason }),
             ok: thisOk,
             window: { startedAt: result.startedAt, endedAt: result.endedAt },
             ...(session
@@ -70,10 +77,7 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
                 : {
                     error: {
                         code: "HUMANISH_SHARED_WORLD_FAILED",
-                        message: judgeParticipantRecords([participantFactsOf(result.outcome)], {
-                            sessionLabel: "Participant",
-                            missingSessionMessage: "Actor did not produce a terminal session.",
-                        }).participants[0].notPassedMessage,
+                        message: record.notPassedMessage,
                     },
                 }),
         };
@@ -306,7 +310,9 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
             ? {}
             : { subjectSandbox: { sandboxId: subjectSandboxId, killed: subjectKilled } }),
         ...(dryRun ? {} : { overlapProven }),
-        ...(dryRun ? {} : { maxSimultaneousLanes: maxSimultaneousWindows(actorResults) }),
+        ...(dryRun
+            ? {}
+            : { maxSimultaneousLanes: maxSimultaneousWindows(usedAppWindows(actorResults)) }),
         subject,
         roles: participantResults,
         observer,

package/dist/routes/shared-world/types.d.ts

@@ -94,6 +94,8 @@ export interface ConcurrentSharedWorldParticipantResult {
         sandboxIdDigest?: string;
         killed: boolean;
     };
+    /** Set when the run skipped the participant before its session started (status `blocked`). */
+    skippedReason?: string;
     error?: {
         code: ConcurrentSharedWorldStudyErrorCode;
         message: string;

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/outcomes.d.ts

@@ -53,6 +53,13 @@ interface SummarySession {
 export declare function participantSummary(name: string, app: SummaryApp, session: SummarySession): string;
 /** "; the gaps list the other 2", or "all 3" when nobody passed. Empty when the gaps list nobody. */
 export declare function gapsListClause(listed: number, total: number): string;
+/**
+ * The sentence that counts the participants a run skipped before their sessions started, or ""
+ * when it skipped none. A skipped participant never used the app, so a summary counts it here and
+ * leaves it out of the sentence about those that took part. `pointAtGaps` is false when that
+ * sentence already points at the gaps.
+ */
+export declare function skippedSentence(skipped: number, pointAtGaps: boolean): string;
 /** One line a stakeholder can read, with the denominator attached to every number. */
 export declare function formatParticipantOutcomes(outcomes: ParticipantOutcomes, terminalCauses?: readonly ParticipantOutcomeDetail[]): string;
 /** Presentation details tolerate optional legacy actor payloads without changing their tallies. */

package/dist/run/outcomes.js

@@ -206,6 +206,20 @@ export function gapsListClause(listed, total) {
         return `; the gaps list the other ${listed}`;
     return total === 1 ? "; the gaps say why" : `; the gaps list all ${total}`;
 }
+/**
+ * The sentence that counts the participants a run skipped before their sessions started, or ""
+ * when it skipped none. A skipped participant never used the app, so a summary counts it here and
+ * leaves it out of the sentence about those that took part. `pointAtGaps` is false when that
+ * sentence already points at the gaps.
+ */
+export function skippedSentence(skipped, pointAtGaps) {
+    const why = pointAtGaps ? "; the gaps say why" : "";
+    if (skipped === 1)
+        return `1 participant was skipped before its session started${why}.`;
+    if (skipped > 1)
+        return `${skipped} participants were skipped before their sessions started${why}.`;
+    return "";
+}
 /** One line a stakeholder can read, with the denominator attached to every number. */
 export function formatParticipantOutcomes(outcomes, terminalCauses = []) {
     if (outcomes.total === 0)

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

@@ -2,17 +2,23 @@ import { type RunBundle } from "./bundle.js";
 import { type PreparedOutputRoot } from "./contained-output.js";
 import { type LiveItemsCursor } from "./live-items.js";
 import type { LiveItemsIndex, RunStream } from "./streams.js";
-/** A trace that does not match its index, or cannot be read. The message names the stream. */
+/**
+ * A trace that does not match its index, or cannot be read. The message names the stream, and ends
+ * with `advice`: by default, restore the run folder from a copy.
+ */
 export declare class StreamTraceRefusedError extends Error {
     readonly streamId: string;
-    constructor(streamId: string, detail: string);
+    constructor(streamId: string, detail: string, advice?: 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;
@@ -36,13 +42,22 @@ export type TraceFileReader = (relativePath: string, maxBytes: number, length?:
 }>;
 /**
  * A live file the loader joined into stream `streamId`: the index it read the items by, and the
- * cursor it read past when the stream holds only the items after one.
+ * cursor it read past when the stream holds only the items after one. A read with `stopped` has
+ * an index that records more than the loader reads of one file, so it read nothing and joined no
+ * items past `after`, which it always has; `stopped` is the warning a reader that shows the run
+ * gives.
  */
-export interface LiveItemsRead {
+export type LiveItemsRead = {
     streamId: string;
     index: LiveItemsIndex;
     after?: LiveItemsCursor;
-}
+    stopped?: undefined;
+} | {
+    streamId: string;
+    index: LiveItemsIndex;
+    after: LiveItemsCursor;
+    stopped: string;
+};
 /** For a live file's index, the prefix of that file the caller holds already, if any. */
 type LiveAfter = (index: LiveItemsIndex) => LiveItemsCursor | undefined;
 /**
@@ -50,10 +65,17 @@ type LiveAfter = (index: LiveItemsIndex) => LiveItemsCursor | undefined;
  * stream without an index is returned as it is (a v1 stream, or one with no actor). An indexed
  * stream's file must have a trace file name (isStreamTracePath); it is read under `maxBytes` and
  * checked against the index's byte count, sha256, item count and screenshot count, and any
- * difference throws StreamTraceRefusedError. The rules that need the whole bundle (an unindexed v2
+ * difference throws StreamTraceRefusedError. An index that records more than `maxBytes` throws
+ * before the file is read. The rules that need the whole bundle (an unindexed v2
  * 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[];
@@ -71,7 +93,9 @@ interface LoadedTraces {
  * `liveAfter` names, for a live file's index, the prefix the caller holds already (the Observer
  * feed's cursor). The loader then reads and joins only the items past it, checked by liveItemsAfter
  * without the indexed sha256, and `live` records the cursor; a cursor past the index or off the
- * file's lines gets the whole prefix, checked as always.
+ * file's lines gets the whole prefix, checked as always. A live file whose index records more than
+ * `maxBytes` is not read: for a cursor that fits the index the stream gets no items past it and
+ * `live` records `stopped`, and without one the stream is refused.
  *
  * A live file that cannot be read may have been removed by the writer after `bundle` was read: it
  * removes a superseded generation once run.json names the next one, and every live file once the
@@ -85,13 +109,16 @@ 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. A live file the loader
+ * stopped reading (LiveItemsRead's `stopped`) gives its stream a `live-items.not-read` warn event.
  */
 export declare function displayedTraces(loaded: {
     bundle: RunBundle;
     refused: readonly StreamTraceRefusedError[];
+    live?: readonly LiveItemsRead[];
 }): RunBundle;
 /** The bundle with every stream loaded; the first refusal throws. */
 export declare function loadRunTraces(source: PreparedOutputRoot | TraceFileReader, bundle: RunBundle, maxBytes?: number): Promise<RunBundle>;