humanish 0.133.1 → 0.134.0

package/dist/analysis/service.js

@@ -11,7 +11,7 @@ import { loadRunBundlePrepared, resolveRunPath } from "../run/locate.js";
 import { physicalCwdOf, runIdOf, resolvePhysicalCwd, validatePreparedRunRootIdentity, } from "../run/paths.js";
 import { isRunStatusRecord, RUN_STATUS_FILE } from "../run/status.js";
 import { captureEvidence, EVIDENCE_LIMITS } from "./evidence.js";
-import { AnalysisSourceRefusedError, runFileTooLarge } from "./source.js";
+import { AnalysisSourceRefusedError, runFileTooLarge, throwAsAnalysisRefusal } from "./source.js";
 import { pathMissing, readBoundedFile, readBoundedFileResult } from "../run/evidence-files.js";
 import { estimateAnalysisAdmission, preferLargerAnalysisOutput, runAnalysis, ANALYSIS_PROMPT_VERSION, } from "./execute.js";
 import { appendAnalysisCorrection, assertAnalysisPublicationCapacity, listAnalyses, writeAnalysis, } from "./store.js";
@@ -155,7 +155,8 @@ export async function readCompletedAnalysisSource(cwd, prepared) {
     const verified = await verifyRunPrepared(cwd, runIdOf(prepared), prepared);
     if (!verified.ok && verified.recordingOk !== true)
         throw new Error("ANALYSIS_VERIFY_FAILED");
-    const loaded = await loadRunBundlePrepared(cwd, prepared);
+    // Verify passes a run whose trace is past the read limit, which analysis does not read.
+    const loaded = await loadRunBundlePrepared(cwd, prepared).catch(throwAsAnalysisRefusal);
     if (!loaded || loaded.bundle.streams.length === 0)
         throw new Error("ANALYSIS_NO_PARTICIPANTS");
     if (loaded.bundle.mode !== "live")

package/dist/analysis/source.d.ts

@@ -26,3 +26,9 @@ export declare function parseAnalysisSource(prepared: PreparedRunArtifactPaths,
  * ANALYSIS_SOURCE_TOO_LARGE, and any other trace the loader refuses as ANALYSIS_SOURCE_INVALID.
  */
 export declare function readParticipantTraces<T>(prepared: PreparedRunArtifactPaths, bundle: StoredRunBundle, keep: (stream: RunStream, index: number) => T): Promise<T[]>;
+/**
+ * The trace loader's refusal as analysis gives it, ANALYSIS_SOURCE_TOO_LARGE for a trace past the
+ * read limit and ANALYSIS_SOURCE_INVALID for any other; another error as it is. The loader's
+ * message names the participant, the file, why, and what to do.
+ */
+export declare function throwAsAnalysisRefusal(error: unknown): never;

package/dist/analysis/source.js

@@ -78,20 +78,22 @@ export function parseAnalysisSource(prepared, bytes) {
  * ANALYSIS_SOURCE_TOO_LARGE, and any other trace the loader refuses as ANALYSIS_SOURCE_INVALID.
  */
 export async function readParticipantTraces(prepared, bundle, keep) {
-    try {
-        return await reduceRunTraces(prepared, bundle, (stream, index) => {
-            validateTraceItems(stream);
-            return keep(stream, index);
-        });
-    }
-    catch (error) {
-        // The loader's refusal names the participant, the file, why, and what to do.
-        if (error instanceof StreamTraceRefusedError)
-            throw new AnalysisSourceRefusedError(error instanceof StreamTraceTooLargeError
-                ? "ANALYSIS_SOURCE_TOO_LARGE"
-                : "ANALYSIS_SOURCE_INVALID", error.message);
+    return reduceRunTraces(prepared, bundle, (stream, index) => {
+        validateTraceItems(stream);
+        return keep(stream, index);
+    }).catch(throwAsAnalysisRefusal);
+}
+/**
+ * The trace loader's refusal as analysis gives it, ANALYSIS_SOURCE_TOO_LARGE for a trace past the
+ * read limit and ANALYSIS_SOURCE_INVALID for any other; another error as it is. The loader's
+ * message names the participant, the file, why, and what to do.
+ */
+export function throwAsAnalysisRefusal(error) {
+    if (!(error instanceof StreamTraceRefusedError))
         throw error;
-    }
+    throw new AnalysisSourceRefusedError(error instanceof StreamTraceTooLargeError
+        ? "ANALYSIS_SOURCE_TOO_LARGE"
+        : "ANALYSIS_SOURCE_INVALID", error.message);
 }
 function validateTraceItems(stream) {
     const actor = stream.actor;

package/dist/cli/commands/run-signals.js

@@ -134,8 +134,12 @@ async function stopActiveRuns(io, signal, stopping, options) {
     // not swept; verify grades a file that names a receipt's id local_only.
     Promise.all(stopping
         .filter((stop) => stop.report !== null)
-        .map((stop) => scrubRunSandboxIds(stop.run.paths).catch((error) => {
-        // A file the sweep refused to read may still name a sandbox; say which.
+        .map((stop) => scrubRunSandboxIds(stop.run.paths).then(
+    // A file the sweep refused to read may still name a sandbox; say which.
+    (unread) => {
+        if (unread !== undefined)
+            say(io, `humanish: ${signal}: ${unread}`);
+    }, (error) => {
         if (error instanceof Error)
             say(io, `humanish: ${signal}: ${error.message}`);
     }))));

package/dist/observer/render.js

@@ -90,11 +90,13 @@ export async function renderObserver(cwdInput, runInput, options = {}) {
             ? "HUMANISH_RUN_NOT_FOUND"
             : "HUMANISH_INVALID_RUN_BUNDLE", verified.error?.message ?? "Run bundle failed verification.");
     }
-    const loaded = await loadRunBundlePrepared(selectedPhysicalCwd, preparedRunPaths);
+    // Verify passes a trace past the read limit, so its participant shows without its items.
+    const loaded = await loadRunBundlePrepared(selectedPhysicalCwd, preparedRunPaths, {
+        display: true,
+    });
     await validatePreparedRunArtifactPaths(preparedRunPaths);
-    if (!loaded) {
+    if (!loaded)
         return runNotFound(cwd, runInput);
-    }
     if (loaded.bundle.runId !== selection.runId ||
         (await realpath(loaded.runDir)) !== preparedRunPaths.physicalRunRoot) {
         throw new Error("Observer output directory does not match the selected run.");

package/dist/routes/computer-use/bundle-parts.d.ts

@@ -1,6 +1,15 @@
+import type { CuaLoopResult } from "../../actors/computer-use/loop.js";
 import { type RunProviderResource, type RunSubjectProvenance } from "../../run/bundle.js";
 import { type ParticipantIds } from "../../run/participant-records.js";
 import { type ParticipantRunOutcome } from "./types.js";
+/**
+ * The review's gap for the streaks a participant's trace records: turns that repeated a recent
+ * action on an unchanged screen past noProgressSteps, which did not end the session of a
+ * participant held to its scheduled end. Its session passes, so no other gap names them. One line
+ * names the first streak and counts the rest: a page that changes every minute, watched 1 s at a
+ * time, records a streak a minute, and a fan-out would list each.
+ */
+export declare function streakGaps(participantId: string, session: CuaLoopResult | undefined): string[];
 /** The human-readable state story appended to the provenance event (and review.md via it). */
 export declare function describeSubjectState(state: RunSubjectProvenance["state"], dryRun: boolean): string;
 /** Human-readable provenance line for the single-participant subject.provenance event of a clone

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

@@ -1,14 +1,34 @@
 // The parts both computer-use bundle shapes share: the subject-state story and provenance line,
-// provider-resource records, and the public-safe app URL label, the URL digest and the
-// subject-phase event id suffix. The builders are bundle.ts (the dispatcher and the judge),
-// single-bundle.ts and fanout-bundle.ts. Feedback candidates from participant reports are in
-// participant-feedback.ts, which the shared-world bundle reads too.
+// provider-resource records, the review's gap for a held participant's streak, and the public-safe
+// app URL label, the URL digest and the subject-phase event id suffix. The builders are bundle.ts
+// (the dispatcher and the judge), single-bundle.ts and fanout-bundle.ts. Feedback candidates from
+// participant reports are in participant-feedback.ts, which the shared-world bundle reads too.
+import { STREAK_TITLE } from "../../actors/computer-use/loop/streak.js";
 import { scanEncodedText } from "../../evidence/encoded-text.js";
 import { digestText } from "../../evidence/redaction.js";
 import {} from "../../run/bundle.js";
 import { participantResourceIds } from "../../run/participant-records.js";
 import {} from "./types.js";
 import { plural } from "../../run/text.js";
+/**
+ * The review's gap for the streaks a participant's trace records: turns that repeated a recent
+ * action on an unchanged screen past noProgressSteps, which did not end the session of a
+ * participant held to its scheduled end. Its session passes, so no other gap names them. One line
+ * names the first streak and counts the rest: a page that changes every minute, watched 1 s at a
+ * time, records a streak a minute, and a fan-out would list each.
+ */
+export function streakGaps(participantId, session) {
+    const texts = (session?.trace.items ?? []).flatMap((item) => item.kind === "notice" && item.title === STREAK_TITLE && item.text !== undefined
+        ? [item.text]
+        : []);
+    const [first] = texts;
+    if (first === undefined)
+        return [];
+    const more = texts.length > 1
+        ? ` It had ${plural(texts.length - 1, "more such streak")} after that; its trace records each.`
+        : "";
+    return [`${participantId}: ${first}${more}`];
+}
 /** The human-readable state story appended to the provenance event (and review.md via it). */
 export function describeSubjectState(state, dryRun) {
     switch (state.provenance) {

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

@@ -5,7 +5,7 @@ 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, skippedSentence, withCuaReviewProvenance, } from "../../run/outcomes.js";
-import { providerResourcesForOutcome, publicSafeAppUrlLabel } from "./bundle-parts.js";
+import { providerResourcesForOutcome, publicSafeAppUrlLabel, streakGaps } from "./bundle-parts.js";
 import { subjectName } from "../../run/subject-name.js";
 import { participantFeedbackCandidates } from "./participant-feedback.js";
 import { participantFactsOf } from "./participant-facts.js";
@@ -70,18 +70,20 @@ function fanoutSummary(args, facts) {
 }
 /**
  * The review's gaps: one line for the participants a host suspension likely failed, then a line
- * for each other participant that did not pass.
+ * for each other participant that did not pass, then a line for each held participant's streaks.
  */
 function fanoutGaps(args, judgment) {
     const suspended = new Set(args.hostSuspension?.participantIds ?? []);
     const others = judgment.participants.flatMap((participant, index) => participant.gapLine === undefined || suspended.has(args.specs[index].planned.id)
         ? []
         : [participant.gapLine]);
+    const streaks = args.specs.flatMap((spec, index) => streakGaps(spec.planned.id, args.outcomes?.[index]?.session));
     if (suspended.size === 0)
-        return others;
+        return [...others, ...streaks];
     return [
         `${[...suspended].join(", ")}: failed after the host was suspended, likely its effect. Each participant's record keeps its own error.`,
         ...others,
+        ...streaks,
     ];
 }
 function fanoutReview(args, streams, judgment) {

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

@@ -6,7 +6,7 @@ import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, p
 import { participantCaption } from "../../run/participant-caption.js";
 import { actorEnding } from "../../actors/stop-cause.js";
 import { cuaGoalSource, ranUntilClockEnd } from "../../actors/goal-source.js";
-import { describeSubjectState, phaseEventIdSuffix, publicSafeAppUrlLabel, subjectProvenanceMessage, } from "./bundle-parts.js";
+import { describeSubjectState, phaseEventIdSuffix, publicSafeAppUrlLabel, streakGaps, subjectProvenanceMessage, } from "./bundle-parts.js";
 import { participantFeedbackCandidates } from "./participant-feedback.js";
 import { judgeParticipantRecords } from "../../run/judge.js";
 import { buildRunCostSummary } from "../../run/cost-summary.js";
@@ -348,7 +348,7 @@ function singleReview(args, view, stream) {
             ...(credibilityNote === undefined ? {} : { credibilityNote }),
         })}`,
         gaps: args.session || args.sessionError !== undefined
-            ? []
+            ? streakGaps(args.participantId ?? "lane-01", args.session)
             : args.inProgress === true
                 ? ["Live desktop session is still running."]
                 : ["Live desktop session not yet run (dry run only)."],

package/dist/run/locate.d.ts

@@ -55,8 +55,14 @@ export declare function loadRunBundle(cwdInput: string, runInput: string): Promi
     bundlePath: string;
     runDir: string;
 } | null>;
-/** loadRunBundle for a caller that already holds prepared paths. Revalidates them first. */
-export declare function loadRunBundlePrepared(cwdInput: string, runPaths: PreparedRunArtifactPaths): Promise<{
+/**
+ * loadRunBundle for a caller that already holds prepared paths. Revalidates them first. With
+ * `display`, a participant whose trace the loader refuses, such as one past the read limit, is
+ * kept as displayedTraces shows it, for a page that shows the run.
+ */
+export declare function loadRunBundlePrepared(cwdInput: string, runPaths: PreparedRunArtifactPaths, options?: {
+    display?: boolean;
+}): Promise<{
     bundle: RunBundle;
     bundlePath: string;
     runDir: string;

package/dist/run/locate.js

@@ -3,7 +3,7 @@ import { bindExistingRunArtifactPaths, isSafeRunIdSegment, resolveExistingRunDir
 import { assertPreparedSelectedOutputDirectory, bindExistingManagedHumanishOutputDirectory, ContainedReadRefusedError, LATEST_POINTER_MAX_BYTES, readContainedRegularFile, RUN_ARTIFACT_MAX_BYTES, } from "./contained-output.js";
 import { RUN_BUNDLE_FILE } from "./bundle.js";
 import { isRunBundle, isRunPointer } from "./bundle-shape.js";
-import { loadRunTraces } from "./stream-trace.js";
+import { displayedTraces, loadRunTraces, loadStreamTraces } from "./stream-trace.js";
 import { readUnchangedFile } from "./evidence-files.js";
 /** The run input that resolves through latest.json rather than naming a run directory. */
 export const LATEST_RUN_ALIAS = "latest";
@@ -119,8 +119,12 @@ export async function loadRunBundle(cwdInput, runInput) {
     }
     return loadRunBundlePrepared(cwd, runPaths);
 }
-/** loadRunBundle for a caller that already holds prepared paths. Revalidates them first. */
-export async function loadRunBundlePrepared(cwdInput, runPaths) {
+/**
+ * loadRunBundle for a caller that already holds prepared paths. Revalidates them first. With
+ * `display`, a participant whose trace the loader refuses, such as one past the read limit, is
+ * kept as displayedTraces shows it, for a page that shows the run.
+ */
+export async function loadRunBundlePrepared(cwdInput, runPaths, options = {}) {
     const cwd = path.resolve(cwdInput);
     await validatePreparedRunArtifactPaths(runPaths);
     const bundlePath = path.join(runPaths.absoluteRunRoot, RUN_BUNDLE_FILE);
@@ -134,7 +138,9 @@ export async function loadRunBundlePrepared(cwdInput, runPaths) {
     }
     return {
         // A trace that does not match its index throws StreamTraceRefusedError, naming the participant.
-        bundle: await loadRunTraces(runPaths, bundle),
+        bundle: options.display === true
+            ? displayedTraces(await loadStreamTraces(runPaths, bundle))
+            : await loadRunTraces(runPaths, bundle),
         bundlePath: path.relative(cwd, bundlePath),
         runDir: runPaths.absoluteRunRoot,
     };

package/dist/run/run.js

@@ -148,6 +148,14 @@ async function writeRunJson(paths, liveItems, bundle) {
     });
     return { ...publicBundle, streams };
 }
+/** The warn event that names the files the final sandbox id sweep could not read. */
+const unsweptEvent = (message, at) => ({
+    id: "event-sandbox-ids-unresolved",
+    at: new Date(at).toISOString(),
+    level: "warn",
+    type: "sandbox-ids.unresolved",
+    message,
+});
 function runPublisher(args) {
     const { options, runId, createdAt, paths, runStatus, now, admit, participantsRan } = args;
     const observer = observerTarget(options);
@@ -161,11 +169,14 @@ function runPublisher(args) {
         type: "study.warning",
         message: redactText(message),
     }));
-    // So do the host suspensions the heartbeat has seen by the time of the write.
+    // So do the host suspensions the heartbeat has seen by the time of the write, and the files the
+    // final sandbox id sweep could not read.
+    let unswept = [];
     const withRunEvents = (events) => {
         const owned = [
             ...studyWarnings,
             ...hostSuspensionEvents(runStatus.suspensions(), Date.parse(createdAt)),
+            ...unswept,
         ];
         return [...events.filter((event) => !owned.some((mine) => mine.id === event.id)), ...owned];
     };
@@ -231,7 +242,12 @@ function runPublisher(args) {
         await writeBundleFiles(bundle, finishedOutcome(outcome), (publicBundle) => runStatus.finish(runStatusOutcome(publicBundle)));
         // The final run.json indexes each finished trace, so the live files are journal no reader needs.
         await liveItems.remove();
-        await scrubRunSandboxIds(paths);
+        const unread = await scrubRunSandboxIds(paths);
+        if (unread !== undefined) {
+            unswept = [unsweptEvent(unread, now())];
+            // The sweep reads the files the final write left, so run.json is written again to record it.
+            await writeBundleFiles(bundle, finishedOutcome(outcome), async () => { });
+        }
         await writePointer();
         let current = { ok: outcome.ok, execution: outcome.execution };
         // An Observer that did not render, judged under the route's policy and written to run.json

package/dist/run/sandbox-ids.d.ts

@@ -45,10 +45,11 @@ export declare function scrubSandboxIdBytes(file: string, bytes: Buffer, ids: re
  * receipts, with the label in place of the id. Writers such as a participant's actor.json can
  * quote an SDK error that names the sandbox. Run.finish calls it before analysis reads the run.
  * Best effort for writes and listings: verify grades a file this misses. A text file it refuses
- * to read, or a journal it refuses, throws once the sweep ends, naming each, since such a file
- * may still hold an id.
+ * to read, such as a trace past RUN_ARTIFACT_MAX_BYTES, may still hold an id, so the sweep
+ * returns a warning that names each such file and why, for the caller to record; the run goes
+ * on. A journal it refuses throws, since without its ids no file can be swept.
  */
-export declare function scrubRunSandboxIds(paths: PreparedRunArtifactPaths): Promise<void>;
+export declare function scrubRunSandboxIds(paths: PreparedRunArtifactPaths): Promise<string | undefined>;
 /**
  * A run's result as it may be returned or printed: the same object when it names no sandbox,
  * otherwise its public view, scrubbed of the ids the run's receipts journal.

package/dist/run/sandbox-ids.js

@@ -197,16 +197,17 @@ const MAX_SWEPT_ENTRIES = 10_000;
  * receipts, with the label in place of the id. Writers such as a participant's actor.json can
  * quote an SDK error that names the sandbox. Run.finish calls it before analysis reads the run.
  * Best effort for writes and listings: verify grades a file this misses. A text file it refuses
- * to read, or a journal it refuses, throws once the sweep ends, naming each, since such a file
- * may still hold an id.
+ * to read, such as a trace past RUN_ARTIFACT_MAX_BYTES, may still hold an id, so the sweep
+ * returns a warning that names each such file and why, for the caller to record; the run goes
+ * on. A journal it refuses throws, since without its ids no file can be swept.
  */
 export async function scrubRunSandboxIds(paths) {
     const ids = await readRunSandboxIds(paths);
     if (ids.length === 0)
-        return;
+        return undefined;
     const valid = await validatePreparedRunRootIdentity(paths).then(() => true, () => false);
     if (!valid)
-        return;
+        return undefined;
     const refused = [];
     const scrub = async (file) => {
         const read = await readContainedRegularFile(paths, file, RUN_ARTIFACT_MAX_BYTES);
@@ -242,8 +243,9 @@ export async function scrubRunSandboxIds(paths) {
     await walk("").catch(() => {
         // A directory that changed while it was listed ends the sweep; verify names what it missed.
     });
-    if (refused.length > 0)
-        throw new Error(`The sandbox id sweep could not read every run file, so these may still name a sandbox: ${refused.join("; ")}.`);
+    return refused.length === 0
+        ? undefined
+        : `The sandbox id sweep could not read every run file, so these may still name a sandbox: ${refused.join("; ")}.`;
 }
 /**
  * A run's result as it may be returned or printed: the same object when it names no sandbox,

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

@@ -11,10 +11,16 @@ export declare class StreamTraceRefusedError extends Error {
     constructor(streamId: string, detail: string, advice?: string);
 }
 /**
- * A trace or live file whose index records more than the loader reads of one file. The loader reads
- * no file past the limit, so a copy of the file is refused too.
+ * A trace or live file whose index records more than the loader reads of one file, `maxBytes`. The
+ * loader reads no file past the limit, so a copy of the file is refused too.
  */
 export declare class StreamTraceTooLargeError extends StreamTraceRefusedError {
+    /** The file's run-relative path, as its index records it. */
+    readonly file: string;
+    constructor(streamId: string, index: {
+        path: string;
+        bytes: number;
+    }, maxBytes: number);
 }
 /** `trace` without the per-request lists; every other field as it is. */
 export declare function withoutRequestLists<T extends object>(trace: T): WithoutRequestLists<T>;

package/dist/run/stream-trace.js

@@ -28,13 +28,17 @@ export class StreamTraceRefusedError extends Error {
 /** Why the loader reads no trace or live file whose index records more than `maxBytes`. */
 const pastLimitDetail = (index, maxBytes) => `run.json records ${index.path} at ${index.bytes} bytes, more than the ${maxBytes} bytes humanish reads of one file`;
 /**
- * A trace or live file whose index records more than the loader reads of one file. The loader reads
- * no file past the limit, so a copy of the file is refused too.
+ * A trace or live file whose index records more than the loader reads of one file, `maxBytes`. The
+ * loader reads no file past the limit, so a copy of the file is refused too.
  */
 export class StreamTraceTooLargeError extends StreamTraceRefusedError {
+    /** The file's run-relative path, as its index records it. */
+    file;
+    constructor(streamId, index, maxBytes) {
+        super(streamId, pastLimitDetail(index, maxBytes), "Restoring a copy does not help; open the file with another tool, such as jq, to read its items.");
+        this.file = index.path;
+    }
 }
-/** The refusal of a trace or live file whose index records more than `maxBytes`. */
-const tooLarge = (streamId, index, maxBytes) => new StreamTraceTooLargeError(streamId, pastLimitDetail(index, maxBytes), "Restoring a copy does not help; open the file with another tool, such as jq, to read its items.");
 const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
 const isScreenshot = (artifact) => artifact.kind === "screenshot";
 /**
@@ -139,7 +143,9 @@ export function splitStreamTraces(bundle) {
             throw new Error(`Two participants' traces would both be written to ${filePath}.`);
         claimed.add(traceFileKey(filePath));
         const screenshots = stream.artifacts.filter(isScreenshot);
-        const bytes = Buffer.from(`${JSON.stringify({ ...actor, artifacts: screenshots }, null, 2)}\n`);
+        // Compact: every reader refuses a file past RUN_ARTIFACT_MAX_BYTES, and indenting made a
+        // trace 1.36 times its compact size on 236 recorded computer-use traces.
+        const bytes = Buffer.from(`${JSON.stringify({ ...actor, artifacts: screenshots })}\n`);
         files.push({ path: filePath, bytes });
         const { items, ...summary } = actor;
         return {
@@ -274,7 +280,7 @@ async function readLiveItems(read, stream, maxBytes, liveAfter) {
     const after = liveAfter?.(index);
     if (index.bytes > maxBytes) {
         if (after === undefined || !cursorFits(index, after))
-            throw tooLarge(stream.id, index, maxBytes);
+            throw new StreamTraceTooLargeError(stream.id, index, maxBytes);
         // The caller keeps the prefix it holds, read when the file was under the limit.
         return {
             stream: { ...stream, liveActor: { ...summary, items: [] } },
@@ -343,7 +349,7 @@ async function readStreamTrace(read, stream, maxBytes, liveAfter) {
     if (stream.trace !== undefined) {
         assertIndex(stream);
         if (stream.trace.bytes > maxBytes)
-            throw tooLarge(stream.id, stream.trace, maxBytes);
+            throw new StreamTraceTooLargeError(stream.id, stream.trace, maxBytes);
         const file = await read(stream.trace.path, maxBytes);
         if ("refused" in file)
             throw new StreamTraceRefusedError(stream.id, file.refused);

package/dist/study/bundle-estimate.js

@@ -32,9 +32,15 @@ import { runEntryLimit } from "../verify/scan-limit.js";
 // the 0.125.0 smoke test and the 2026-10-12 live checks, 10 participants with 1 to 28 turns and 137
 // model requests. Dry: runs of 1, 2, 24 and 100 participants, for the Observer app and the run's
 // 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.
+// maintainer's machine. The run.json and page data rates were measured again on those runs
+// written as v4.
+// The trace rates were measured on trace files written indented. The writer now writes them as
+// compact JSON, so each trace rate below is the indented figure divided by 1.36, the ratio of
+// indented to compact bytes over 236 kept computer-use traces (1.17 to 1.49 each), and the page's
+// share of the traces is multiplied by it. 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 indented, under the live fit. Its participant of 78 turns writes a trace of 149,637 bytes
+// indented and 107,897 compact.
 const RATES = Object.freeze({
     /** run.json bytes for the run itself: its header, study, review and cost. Live fit: 4,381. */
     runBytes: 4_400,
@@ -44,21 +50,21 @@ const RATES = Object.freeze({
      * bytes and those of two 30,647 to 38,948, beside 20,900 and 37,400 at these rates.
      */
     participantBytes: 16_500,
-    /** A trace file's bytes before its turns: the actor summary. Live fit: 5,378. */
-    participantTraceBytes: 5_400,
+    /** A trace file's bytes before its turns: the actor summary. Live fit: 5,378 indented. */
+    participantTraceBytes: 4_000,
     /**
      * Trace bytes a model turn adds: its items, its screenshot entry and its request's usage, plus 91
-     * for the `page` each screenshot item now carries. Live fit: 1,965 a turn. Participants with 4
-     * or more turns ranged from 1,140 to 4,532; the busiest made 311 items in 15 turns, most of them
-     * UI actions. Analysis refuses the whole run when one trace passes its limit, so each trace is
-     * counted at the busiest participant's rate.
+     * for the `page` each screenshot item now carries, all indented. Live fit: 1,965 a turn.
+     * Participants with 4 or more turns ranged from 1,140 to 4,532; the busiest made 311 items in 15
+     * turns, most of them UI actions. Analysis refuses the whole run when one trace passes its limit,
+     * so each trace is counted at the busiest participant's rate, 4,700 indented.
      */
-    turnTraceBytes: 4_700,
+    turnTraceBytes: 3_500,
     /**
      * Trace bytes a dwell frame adds: 395 for its item and entry on the kept runs with dwell frames,
-     * plus 91 for the page.
+     * plus 91 for the page, indented.
      */
-    frameTraceBytes: 500,
+    frameTraceBytes: 400,
     /**
      * Seconds between model turns: the median of the 27 of 185 kept live participants that worked 5
      * minutes or more was 10.4.
@@ -83,12 +89,12 @@ const RATES = Object.freeze({
      */
     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
-     * turn), 0.142 to 0.184 on runs of one participant and 4 to 11 turns, and 0.095 on 0.124.0's
-     * synthetic 8-hour run.
+     * The page's gzipped base64 items, as a share of all the traces' bytes indented: 0.087 to 0.114
+     * on the live runs of two participants, 0.097 for the busiest participant alone (about 475 bytes
+     * a turn), 0.142 to 0.184 on runs of one participant and 4 to 11 turns, and 0.095 on 0.124.0's
+     * synthetic 8-hour run. The estimate counted 0.12 of indented traces.
      */
-    observerPageItemsShare: 0.12,
+    observerPageItemsShare: 0.16,
     /** A desktop screenshot: the median of 3,990 kept live PNG frames was 107,895 bytes. */
     screenshotBytes: 110_000,
     /**

package/dist/verify/artifacts.d.ts

@@ -22,7 +22,13 @@ export interface UnscannedArtifacts {
  * and where it stopped, each in its own sentence. Undefined when the scan read everything.
  */
 export declare function unscannedMessage(unscanned: UnscannedArtifacts): string | undefined;
-export declare function missingLocalEvidenceArtifacts(runPaths: PreparedRunArtifactPaths, bundle: RunBundle): Promise<string[]>;
+/**
+ * Why each local evidence path the bundle requires is missing or unusable. A path in
+ * `pastReadLimit` is a trace verify found larger than it reads, which verify lists as unscanned so
+ * the run grades local_only. It meets a requirement only while it is still past the limit when
+ * this check reads it, and never a screenshot or recording requirement.
+ */
+export declare function missingLocalEvidenceArtifacts(runPaths: PreparedRunArtifactPaths, bundle: RunBundle, pastReadLimit: ReadonlySet<string>): Promise<string[]>;
 /**
  * The PNG frames that actor traces register as stream screenshots, relative to the run root.
  * RAW_SCREENSHOTS grades these, so the public-safety scan does not report them as unread. Only

package/dist/verify/artifacts.js

@@ -47,7 +47,13 @@ function listed(paths) {
     const more = paths.length - MAX_LISTED_UNSCANNED;
     return `${paths.slice(0, MAX_LISTED_UNSCANNED).join(", ")}${more > 0 ? ` and ${more} more` : ""}`;
 }
-export async function missingLocalEvidenceArtifacts(runPaths, bundle) {
+/**
+ * Why each local evidence path the bundle requires is missing or unusable. A path in
+ * `pastReadLimit` is a trace verify found larger than it reads, which verify lists as unscanned so
+ * the run grades local_only. It meets a requirement only while it is still past the limit when
+ * this check reads it, and never a screenshot or recording requirement.
+ */
+export async function missingLocalEvidenceArtifacts(runPaths, bundle, pastReadLimit) {
     const recordings = new Map(bundle.streams.flatMap((stream) => stream.recording ? [[stream.recording.path, stream.recording]] : []));
     const requiredPaths = new Map();
     const addRequiredPath = (artifactPath, options = {}) => {
@@ -110,12 +116,15 @@ export async function missingLocalEvidenceArtifacts(runPaths, bundle) {
         }
     }
     // Reads overlap, so one frame's file system calls run while another frame's PNG is checked.
-    const found = await mapWithConcurrency([...requiredPaths], EVIDENCE_READ_CONCURRENCY, ([artifactPath, requirements]) => missingArtifact(runPaths, artifactPath, requirements, recordings.get(artifactPath)));
+    const found = await mapWithConcurrency([...requiredPaths], EVIDENCE_READ_CONCURRENCY, ([artifactPath, requirements]) => missingArtifact(runPaths, artifactPath, { ...requirements, pastReadLimit: pastReadLimit.has(artifactPath) }, recordings.get(artifactPath)));
     return found.filter((entry) => entry !== null);
 }
 // Evidence files verify reads at once. Each read holds at most RUN_ARTIFACT_MAX_BYTES.
 const EVIDENCE_READ_CONCURRENCY = 8;
-/** Why one required path fails its requirements, or null when it meets them. */
+/**
+ * Why one required path fails its requirements, or null when it meets them. `pastReadLimit` says
+ * verify listed the path as a trace past the read limit, so a file still past it is present.
+ */
 async function missingArtifact(runPaths, artifactPath, requirements, recording) {
     if (recording) {
         const handle = await openContainedRegularFile(runPaths, artifactPath);
@@ -136,7 +145,9 @@ async function missingArtifact(runPaths, artifactPath, requirements, recording)
         ? await readScreenshot(runPaths, artifactPath)
         : await readSafeRunArtifact(runPaths, artifactPath);
     if (read.state === "limit")
-        return `${artifactPath} (larger than the ${RUN_ARTIFACT_MAX_BYTES} bytes verify reads)`;
+        return requirements.pastReadLimit && !requirements.screenshot
+            ? null
+            : `${artifactPath} (larger than the ${RUN_ARTIFACT_MAX_BYTES} bytes verify reads)`;
     if (read.state === "unavailable" ||
         (("size" in read ? read.size : read.bytes.length) === 0 && !requirements.allowEmpty))
         return artifactPath;