humanish 0.133.1 → 0.135.0

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

@@ -2,10 +2,10 @@ import { e2bDesktopTemplate } from "../../substrates/e2b/sandbox.js";
 import { receivingPublication } from "../../comms/receiving-runtime.js";
 import { actorEnding } from "../../actors/stop-cause.js";
 import { cuaGoalSource } from "../../actors/goal-source.js";
-import { redactText } from "../../evidence/redaction.js";
+import { redactEncodedText } from "../../evidence/encoded-text.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) {
@@ -184,7 +186,7 @@ function fanoutFeedbackCandidates(args) {
                     participantId: spec.planned.id,
                     streamId: spec.streamId,
                     personaId: spec.persona.id,
-                    goal: redactText(spec.evidenceInstructions ?? spec.instructions),
+                    goal: redactEncodedText(spec.evidenceInstructions ?? spec.instructions),
                     ...(outcome?.session === undefined ? {} : { session: outcome.session }),
                     ...(outcome?.session === undefined
                         ? {}
@@ -268,7 +270,7 @@ export function buildCuaFanoutBundle(args) {
             // this writer produced. The only adopter-side workaround was scanner evasion.
             //
             // The instructions the model actually receives are untouched; only the persisted copy changes.
-            goal: redactText(specs[0].evidenceInstructions ?? specs[0].instructions),
+            goal: redactEncodedText(specs[0].evidenceInstructions ?? specs[0].instructions),
             source: `study:${plan.studyId}`,
             sourceDigest: specs[0].persona.promptDigest,
         },

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

@@ -6,7 +6,7 @@ import { isLocalBrowserStudy, LOCAL_BROWSER_LIFETIME_MS, } from "../../substrate
 import { resolveParticipant } from "../../run/participant.js";
 import {} from "../../study/types.js";
 import { scrubPersonaBrief } from "../../study/persona.js";
-import { redactText } from "../../evidence/redaction.js";
+import { redactEncodedText } from "../../evidence/encoded-text.js";
 import {} from "../../run/bundle.js";
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { resolveCommittedPersonas } from "../../study/persona-resolve.js";
@@ -237,7 +237,7 @@ export function sanitizeParticipantRuns(runs, scrub) {
     for (const spec of runs) {
         if (spec.evidenceAssignment)
             spec.evidenceAssignment = participantAssignment(spec.evidenceAssignment, scrub);
-        spec.evidenceInstructions = redactText(scrub(spec.instructions));
+        spec.evidenceInstructions = redactEncodedText(scrub(spec.instructions));
         spec.persona = scrubPersonaBrief(spec.persona, scrub);
     }
 }

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

@@ -1,12 +1,12 @@
 import { participantAssignment } from "../../study/participant-assignment.js";
-import { redactText } from "../../evidence/redaction.js";
+import { redactEncodedText } from "../../evidence/encoded-text.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import {} from "../../run/streams.js";
 import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, participantSummary, withCuaReviewProvenance, } from "../../run/outcomes.js";
 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)."],
@@ -385,7 +385,7 @@ export function buildSingleParticipantBundle(args) {
         scenario: {
             id: `cua-${args.studyId}`,
             title: args.studyTitle ?? `Computer-use run: ${args.studyId}`,
-            goal: redactText(args.mission),
+            goal: redactEncodedText(args.mission),
             source: `study:${args.studyId}`,
             sourceDigest: args.persona.promptDigest,
         },
@@ -425,7 +425,7 @@ export function buildSingleParticipantBundle(args) {
                         participantId: args.participantId ?? "lane-01",
                         streamId: SINGLE.streamId,
                         personaId: args.persona.id,
-                        goal: redactText(args.mission),
+                        goal: redactEncodedText(args.mission),
                         ...(args.session === undefined ? {} : { session: args.session }),
                         ...(args.traceArtifactPath === undefined
                             ? {}

package/dist/routes/scripted/setup.js

@@ -8,6 +8,7 @@ import { resolveBrowserCommand } from "../../actors/scripted-browser/browser-com
 import { publicSafeToken } from "../../actors/scripted-browser/journey.js";
 import { prepareSelectedOutputDirectory } from "../../run/contained-output.js";
 import { RunSecrets } from "../../run/secrets.js";
+import { redactEncodedText } from "../../evidence/encoded-text.js";
 import { evidenceAppUrlOf } from "./plan.js";
 import { resolveScriptedScenario } from "./scenario.js";
 import {} from "./types.js";
@@ -55,6 +56,9 @@ export async function prepareScriptedRun(plan, input) {
             result: failed("HUMANISH_SCRIPTED_SCENARIO_INVALID", scenario.message),
         };
     }
+    const steps = recordedStepIds(scenario.journey.steps, secrets);
+    if (!steps.ok)
+        return { ok: false, result: failed("HUMANISH_SCRIPTED_SCENARIO_INVALID", steps.message) };
     // The goal, title and step labels are recorded; a step's path, selector, value and expected text
     // drive the browser and stay as written.
     const journey = {
@@ -62,9 +66,9 @@ export async function prepareScriptedRun(plan, input) {
         scenarioId: idHoldsKnownValue(scenario.journey.scenarioId, secrets)
             ? "scenario"
             : scenario.journey.scenarioId,
-        goal: secrets.scrub(scenario.journey.goal),
-        scenarioTitle: secrets.scrub(scenario.journey.scenarioTitle),
-        steps: recordedStepIds(scenario.journey.steps, secrets),
+        goal: recordedText(scenario.journey.goal, secrets),
+        scenarioTitle: recordedText(scenario.journey.scenarioTitle, secrets),
+        steps: steps.steps,
     };
     // The plan lists E2B_API_KEY and the subject env only for a live clone.
     const { requirements } = plan;
@@ -127,6 +131,13 @@ export async function prepareScriptedRun(plan, input) {
         },
     };
 }
+/**
+ * Scenario text the run records, without the run's known values and then without keys as written
+ * or encoded, since verify decodes the files that record it.
+ */
+function recordedText(text, secrets) {
+    return redactEncodedText(secrets.scrub(text));
+}
 /**
  * Whether an id holds a known value as written or as the parser's id token of it, lower-cased with
  * other characters as `-`, which the scrub would not find.
@@ -139,22 +150,56 @@ function idHoldsKnownValue(id, secrets) {
         }));
 }
 /**
- * The steps with their labels scrubbed and their ids safe to record. A step id names the step's
- * screenshot file and is recorded beside it, and the parser derives an omitted id from the label,
- * lower-cased and cut to 80 characters, so the scrub may not find a value in it. A step whose
- * label or id holds a known value is renamed by its position instead.
+ * The steps with their labels redacted and their ids safe to record, or why the run is refused. A
+ * step id names the step's screenshot file and is recorded beside it, and the parser derives an
+ * omitted id from the label, lower-cased and cut to 80 characters, so the scrub may not find a
+ * value in it. A step whose label changes under recordedText, or whose id holds a known value, is
+ * renamed by its position instead.
  */
 function recordedStepIds(steps, secrets) {
     const taken = new Set(steps.map((step) => step.id));
-    return steps.map((step, index) => {
-        const label = secrets.scrub(step.label);
-        if (label === step.label && !idHoldsKnownValue(step.id, secrets))
-            return { ...step, label };
-        const position = `step-${String(index + 1).padStart(2, "0")}`;
-        let id = position;
-        for (let suffix = 2; taken.has(id); suffix += 1)
-            id = `${position}-${suffix}`;
+    const recorded = [];
+    for (const [index, step] of steps.entries()) {
+        const label = recordedText(step.label, secrets);
+        if (label === step.label && !idHoldsKnownValue(step.id, secrets)) {
+            recorded.push({ ...step, label });
+            continue;
+        }
+        const id = positionId(index, taken, secrets);
+        if (id === undefined)
+            return {
+                ok: false,
+                message: `The label or id of scenario step ${index + 1} holds a key, a local path or a value this run keeps out of its files, so the run renames the step by its position, and each id that position gives holds one of those values too. Remove it from the step's label and id.`,
+            };
         taken.add(id);
-        return { ...step, id, label };
-    });
+        recorded.push({ ...step, id, label });
+    }
+    return { ok: true, steps: recorded };
+}
+/**
+ * The id a renamed step takes by its position, such as step-03 for the third step, then step-03-2,
+ * step-03-3 and on when another step has it. A known value can be one of these ids, so one that
+ * holds a known value is passed over. Every id holds the position id, so a position id that holds a
+ * known value gives undefined at once. Otherwise taken.size + 1 ids that hold no known value are
+ * tried, which includes a free one, as long as known values pass over at most
+ * MAX_KNOWN_VALUE_SKIPS of them; a value such as `-01-` that every numbered id holds gives undefined.
+ */
+function positionId(index, taken, secrets) {
+    const position = `step-${String(index + 1).padStart(2, "0")}`;
+    if (idHoldsKnownValue(position, secrets))
+        return undefined;
+    let skips = 0;
+    for (let suffix = 1; suffix <= taken.size + 1 + skips; suffix += 1) {
+        const id = suffix === 1 ? position : `${position}-${suffix}`;
+        if (taken.has(id))
+            continue;
+        if (!idHoldsKnownValue(id, secrets))
+            return id;
+        if (skips === MAX_KNOWN_VALUE_SKIPS)
+            return undefined;
+        skips += 1;
+    }
+    return undefined;
 }
+// Known values are few, and a numbered id holds one only when the value matches its digits.
+const MAX_KNOWN_VALUE_SKIPS = 32;

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

@@ -1,7 +1,7 @@
 // Builds the run bundle for a concurrent shared-world run: per-participant simulations, streams and
 // events, the sharedWorld evidence block and the review summary.
 import { receivingPublication } from "../../comms/receiving-runtime.js";
-import { redactText } from "../../evidence/redaction.js";
+import { redactEncodedText } from "../../evidence/encoded-text.js";
 import { planeStateOf } from "./plan.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import { SHARED_WORLD_SCHEMA, concurrencyFacts, sharedWorldParticipantKeys, } from "../../run/shared-world-evidence.js";
@@ -362,7 +362,7 @@ export function buildConcurrentSharedWorldBundle(args) {
         scenario: {
             id: `concurrent-shared-world-${plan.studyId}`,
             title: plan.title ?? `Concurrent shared-world: ${plan.studyId}`,
-            goal: redactText(actorSpecs[0]?.evidenceInstructions ??
+            goal: redactEncodedText(actorSpecs[0]?.evidenceInstructions ??
                 actorSpecs[0]?.instructions ??
                 "Concurrent shared-world interaction."),
             source: `study:${plan.studyId}`,
@@ -423,7 +423,7 @@ function sharedWorldFeedbackCandidates(args) {
                 participantId: spec.planned.id,
                 streamId: spec.streamId,
                 personaId: spec.persona.id,
-                goal: redactText(spec.evidenceInstructions ?? spec.instructions),
+                goal: redactEncodedText(spec.evidenceInstructions ?? spec.instructions),
                 ...(outcome?.session === undefined
                     ? {}
                     : { session: outcome.session, traceArtifactPath: spec.traceArtifactPath }),

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

@@ -10,7 +10,7 @@ import { startLiveTraceFlush } from "../computer-use/live-flush.js";
 import { desktopParticipantDeps, } from "../computer-use/participant-deps.js";
 import { resolveCommittedPersonasForCwd } from "../../study/persona-resolve.js";
 import { participantAssignment } from "../../study/participant-assignment.js";
-import { redactText } from "../../evidence/redaction.js";
+import { redactEncodedText } from "../../evidence/encoded-text.js";
 import { sandboxHeadroomMs } from "../../substrates/e2b/lifetime.js";
 // prose-check: model prompt (the participant model reads this, not a person)
 const DEFAULT_MISSION = "You are one of MANY users hitting a shared web application at the same time. The browser is already open at the app. Accomplish your role's task, then stop.";
@@ -178,7 +178,7 @@ export async function buildParticipantSpecs(participants, cwd, scrubKnownValues)
     for (const spec of actorSpecs) {
         if (spec.evidenceAssignment)
             spec.evidenceAssignment = participantAssignment(spec.evidenceAssignment, scrubKnownValues);
-        spec.evidenceInstructions = redactText(scrubKnownValues(spec.instructions));
+        spec.evidenceInstructions = redactEncodedText(scrubKnownValues(spec.instructions));
         spec.persona = scrubPersonaBrief(spec.persona, scrubKnownValues);
     }
     return actorSpecs;

package/dist/routes/terminal/bundle.js

@@ -1,4 +1,4 @@
-import { redactText } from "../../evidence/redaction.js";
+import { redactEncodedText } from "../../evidence/encoded-text.js";
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import {} from "../../run/judge.js";
@@ -250,7 +250,7 @@ function terminalRunBundle(args, parts) {
             // The author mission is public-safe committed study text. It is recorded plaintext as the goal,
             // redacted defensively before persisting (it never carries a secret, but the harness never
             // trusts that). The full composed prompt is bound by digest, not text.
-            goal: redactText(args.mission),
+            goal: redactEncodedText(args.mission),
             source: `study:${args.studyId}`,
             sourceDigest: args.persona.promptDigest,
         },

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

@@ -3,6 +3,7 @@
 // their own evidence files; this module owns when the run starts, how it is published, and how it
 // is closed on every exit.
 import { randomBytes } from "node:crypto";
+import { redactEncodedText } from "../evidence/encoded-text.js";
 import { redactText } from "../evidence/redaction.js";
 import { buildObserverData } from "../observer/data.js";
 import { splitObserverData } from "../observer/participant-items.js";
@@ -148,24 +149,35 @@ 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);
     // The study's warnings join whatever events the route wrote, once, in every write. A warning can
-    // quote the study file, which may name a sandbox URL a participant needs, so each goes through
-    // the redaction a run failure gets.
+    // quote the study file, which may name a sandbox URL a participant needs or hold an encoded key,
+    // so each goes through the redaction study text gets.
     const studyWarnings = (options.warnings ?? []).map((message, index) => ({
         id: `event-study-warning-${String(index + 1).padStart(3, "0")}`,
         at: createdAt,
         level: "warn",
         type: "study.warning",
-        message: redactText(message),
+        message: redactEncodedText(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 +243,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/run-study.d.ts

@@ -21,9 +21,9 @@ export declare function runStudyWith(config: StudyConfig, options: InternalRunSt
 /**
  * The package's study runner (`src/index.ts`): runStudyWith with the public options only. A
  * config that skipped parseStudy is checked first (libraryConfigRefusal): a humanish.lab.v2 config
- * or one with a humanish 0.110 field, no `actor`, or a `route` the config does not take. That, or a
- * field RunStudyOptions no longer has, is refused in the route's own result envelope before
- * anything runs.
+ * or one with a humanish 0.110 field, no `actor`, a `route` the config does not take, or an
+ * `actor.model` verify would flag. That, or a field RunStudyOptions no longer has, is refused in the
+ * route's own result envelope before anything runs.
  */
 export declare function runStudy(config: StudyConfig, options: RunStudyOptions): Promise<StudyOutcome>;
 /** A study planned once: the route's refusal, or the run of its plan. */

package/dist/run-study.js

@@ -34,9 +34,9 @@ export async function runStudyWith(config, options, deps = {}) {
 /**
  * The package's study runner (`src/index.ts`): runStudyWith with the public options only. A
  * config that skipped parseStudy is checked first (libraryConfigRefusal): a humanish.lab.v2 config
- * or one with a humanish 0.110 field, no `actor`, or a `route` the config does not take. That, or a
- * field RunStudyOptions no longer has, is refused in the route's own result envelope before
- * anything runs.
+ * or one with a humanish 0.110 field, no `actor`, a `route` the config does not take, or an
+ * `actor.model` verify would flag. That, or a field RunStudyOptions no longer has, is refused in the
+ * route's own result envelope before anything runs.
  */
 export async function runStudy(config, options) {
     const rejected = libraryConfigRefusal(config);

package/dist/study/bundle-estimate.d.ts

@@ -16,8 +16,6 @@ export interface BundleEstimate {
     readonly runFileBytes: number;
     /** The largest participant trace file, which analysis also reads whole. */
     readonly largestTraceBytes: number;
-    /** Every participant's trace file together, whose items the Observer page joins in one string. */
-    readonly tracesBytes: number;
     /** observer/index.html, which verify reads whole. */
     readonly observerPageBytes: number;
     /** Every file, screenshots included. */