humanish 0.146.0 → 0.147.0

package/dist/evidence/webp.js

@@ -0,0 +1,94 @@
+// Lossless WebP screenshots: the file shape verify accepts, and a bounded decode for the readers
+// that need pixels. Only the simple lossless form is accepted: a RIFF container holding one VP8L
+// chunk. The extended form (VP8X) is where EXIF, XMP, ICC and animation chunks live, so a frame
+// in the simple form carries image data only. The VP8L bitstream itself is not proven consumed,
+// so a WebP frame is never redacted evidence: a blurred frame is the PNG redactScreenshot writes.
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import decodeWebpImage, { init as initWebpDecoder } from "@jsquash/webp/decode.js";
+const RIFF_HEADER_BYTES = 12;
+const CHUNK_HEADER_BYTES = 8;
+const VP8L_SIGNATURE = 0x2f;
+/** The VP8L header: its signature byte, then 14-bit width and height, an alpha hint, a version. */
+const VP8L_HEADER_BYTES = 5;
+/**
+ * Why `bytes` is not a simple-format lossless WebP, or null with its dimensions when it is: RIFF
+ * and WEBP, then one VP8L chunk that ends the file (with its pad byte, zero, when its size is
+ * odd), whose header has the VP8L signature and version 0.
+ */
+export function webpStructure(bytes) {
+    const failed = (error) => ({ error });
+    if (bytes.length < RIFF_HEADER_BYTES + CHUNK_HEADER_BYTES + VP8L_HEADER_BYTES ||
+        bytes.toString("latin1", 0, 4) !== "RIFF" ||
+        bytes.toString("latin1", 8, 12) !== "WEBP")
+        return failed("expected a RIFF WEBP file");
+    if (bytes.readUInt32LE(4) !== bytes.length - 8)
+        return failed("the RIFF size does not match the file size");
+    const chunk = bytes.toString("latin1", 12, 16);
+    if (chunk !== "VP8L")
+        return failed(`WebP evidence must be one lossless VP8L chunk, not ${/^[A-Za-z0-9 ]{4}$/.test(chunk) ? chunk.trim() : "a malformed chunk"}`);
+    const size = bytes.readUInt32LE(16);
+    const start = RIFF_HEADER_BYTES + CHUNK_HEADER_BYTES;
+    const end = start + size + (size % 2);
+    if (end !== bytes.length || (size % 2 === 1 && bytes[end - 1] !== 0))
+        return failed("the VP8L chunk must end the file");
+    if (size < VP8L_HEADER_BYTES)
+        return failed("the VP8L chunk has no VP8L header");
+    const dimensions = webpHeaderDimensions(bytes);
+    if (dimensions === undefined)
+        return failed("the VP8L header is not one this reader knows");
+    return { error: null, dimensions };
+}
+/** The bytes webpHeaderDimensions reads: the RIFF header, the VP8L chunk header, the VP8L header. */
+export const WEBP_HEADER_BYTES = RIFF_HEADER_BYTES + CHUNK_HEADER_BYTES + VP8L_HEADER_BYTES;
+/**
+ * Width and height from the first WEBP_HEADER_BYTES of a simple-format lossless WebP: a VP8L
+ * signature and version 0. Undefined for anything else.
+ */
+export function webpHeaderDimensions(header) {
+    const start = RIFF_HEADER_BYTES + CHUNK_HEADER_BYTES;
+    if (header.length < WEBP_HEADER_BYTES ||
+        header.toString("latin1", 0, 4) !== "RIFF" ||
+        header.toString("latin1", 8, 16) !== "WEBPVP8L" ||
+        header[start] !== VP8L_SIGNATURE)
+        return undefined;
+    const bits = header.readUInt32LE(start + 1);
+    if (bits >>> 29 !== 0)
+        return undefined;
+    return { width: (bits & 0x3fff) + 1, height: ((bits >>> 14) & 0x3fff) + 1 };
+}
+let decoderReady;
+/** Loads the decoder from the package's own wasm file: the codec's default fetches it by URL. */
+function readyDecoder() {
+    // The codec builds its result with ImageData, which Node does not define.
+    const scope = globalThis;
+    scope.ImageData ??= class {
+        data;
+        width;
+        height;
+        constructor(data, width, height) {
+            this.data = data;
+            this.width = width;
+            this.height = height;
+        }
+    };
+    decoderReady ??= readFile(createRequire(import.meta.url).resolve("@jsquash/webp/codec/dec/webp_dec.wasm"))
+        .then((wasm) => WebAssembly.compile(wasm))
+        .then((module) => initWebpDecoder(module));
+    return decoderReady;
+}
+/**
+ * The RGBA pixels of a WebP frame that webpStructure accepts, whose dimensions the caller has
+ * checked against its pixel cap; the decoder allocates from them.
+ */
+export async function decodeWebp(bytes) {
+    await readyDecoder();
+    const copy = new Uint8Array(bytes.length);
+    copy.set(bytes);
+    const image = await decodeWebpImage(copy.buffer);
+    return {
+        width: image.width,
+        height: image.height,
+        data: Buffer.from(image.data.buffer, image.data.byteOffset, image.data.byteLength),
+    };
+}

package/dist/feedback/derivative-text.d.ts

@@ -5,8 +5,13 @@ interface TextFile {
     bytes: Buffer;
 }
 export declare function jsonBytes(value: unknown): Buffer;
-export declare function transformText(file: TextFile, imagePaths: ReadonlySet<string>): Buffer;
+/**
+ * Each kept image's source path and the path the copy holds it at; they differ for a WebP frame,
+ * which the copy holds as a blurred PNG.
+ */
+type ImagePaths = ReadonlyMap<string, string>;
+export declare function transformText(file: TextFile, imagePaths: ImagePaths): Buffer;
 export declare function assertRewritableNumbers(json: string): void;
 /** The loaded source bundle as the copy records it: screenshots declared and labelled blurred. */
-export declare function derivedBundle(bundle: RunBundle, imagePaths: ReadonlySet<string>): RunBundle;
+export declare function derivedBundle(bundle: RunBundle, imagePaths: ImagePaths): RunBundle;
 export {};

package/dist/feedback/derivative-text.js

@@ -62,7 +62,10 @@ function updateScreenshotDeclarations(value, imagePaths) {
                 if (typeof ref.path !== "string" || !imagePaths.has(ref.path)) {
                     throw new Error("Actor screenshot reference must resolve to a PNG transformed from this run's inventory.");
                 }
-                return { ...entry, screenshotRef: { ...ref, redaction: "blurred" } };
+                return {
+                    ...entry,
+                    screenshotRef: { ...ref, path: imagePaths.get(ref.path), redaction: "blurred" },
+                };
             });
         }
     }
@@ -120,11 +123,27 @@ export function derivedBundle(bundle, imagePaths) {
         status: "passed",
         notes: `${bundle.redaction.notes} Exported copy: screenshots were blurred during export; the original capture is retained separately. See derivation.json.`,
     };
+    // Only a path whose output differs is rewritten; every other cite keeps its exact spelling.
+    const renamed = (cite) => {
+        const output = imagePaths.get(path.posix.normalize(cite));
+        return output !== undefined && output !== path.posix.normalize(cite) ? output : cite;
+    };
     for (const stream of transformed.streams) {
+        // The stream's latest frame, as the Observer embeds it and its UI state names it.
+        if (stream.embed?.kind === "screenshot" && stream.embed.url !== undefined)
+            stream.embed.url = renamed(stream.embed.url);
+        if (stream.ui?.screenshotUrl !== undefined)
+            stream.ui.screenshotUrl = renamed(stream.ui.screenshotUrl);
         for (const artifact of stream.artifacts) {
+            artifact.path = renamed(artifact.path);
             if (artifact.kind === "screenshot")
                 artifact.label = artifact.label.replace(/\((raw|blurred)\)/g, "(blurred at export)");
         }
     }
+    for (const candidate of transformed.feedbackCandidates)
+        for (const evidence of candidate.evidence)
+            evidence.path = renamed(evidence.path);
+    for (const artifact of transformed.adapterArtifacts ?? [])
+        artifact.path = renamed(artifact.path);
     return transformed;
 }

package/dist/feedback/export-bundle.js

@@ -7,7 +7,11 @@ import { tmpdir } from "node:os";
 import { renderObserver } from "../observer/render.js";
 import { inventorySandboxIds, publicSandboxView, scrubSandboxIdBytes } from "../run/sandbox-ids.js";
 import { splitStreamTraces } from "../run/stream-trace.js";
+import { PNG } from "pngjs";
+import { imageDimensionsError } from "../evidence/image.js";
 import { redactScreenshot, redactText } from "../evidence/redaction.js";
+import { readingsOf } from "../evidence/encoded-text.js";
+import { decodeWebp, webpStructure } from "../evidence/webp.js";
 import { assertRewritableNumbers, derivedBundle, jsonBytes, transformText, } from "./derivative-text.js";
 import { streamScreenshotPaths } from "../verify/artifacts.js";
 import { runEntryLimit } from "../verify/scan-limit.js";
@@ -146,7 +150,7 @@ async function prospectivePhysicalPath(requested) {
         return path.join(await prospectivePhysicalPath(parent), path.basename(requested));
     }
 }
-function assertFeedbackReferences(bundle, source) {
+function assertFeedbackReferences(bundle, source, imagePaths) {
     const retained = new Set(source.files.filter((file) => omittedReason(file.path) === undefined).map((file) => file.path));
     retained.add("observer/index.html");
     retained.add("observer/observer-data.json");
@@ -154,14 +158,16 @@ function assertFeedbackReferences(bundle, source) {
         for (const evidence of candidate.evidence) {
             if (!retained.has(evidence.path))
                 throw new Error("Feedback evidence must resolve to a retained or regenerated artifact in the derivative.");
-            if (evidence.kind === "screenshot" && path.extname(evidence.path).toLowerCase() !== ".png") {
+            if (evidence.kind === "screenshot" &&
+                path.extname(imagePaths.get(evidence.path) ?? evidence.path).toLowerCase() !== ".png") {
                 throw new Error("Feedback screenshot evidence must resolve to a transformed PNG.");
             }
         }
     }
 }
-/** PNG paths that run.json cites outside actor traces: feedback, adapter and stream artifacts. */
-function citedPngPaths(bundle) {
+const IMAGE_EXTENSIONS = new Set([".png", ".webp"]);
+/** Image paths that run.json cites outside actor traces: feedback, adapter and stream artifacts. */
+function citedImagePaths(bundle) {
     const cited = [
         ...bundle.feedbackCandidates.flatMap((candidate) => candidate.evidence.map(({ path }) => path)),
         ...(bundle.adapterArtifacts ?? []).map((artifact) => artifact.path),
@@ -169,25 +175,38 @@ function citedPngPaths(bundle) {
     ];
     return new Set(cited
         .map((cite) => path.posix.normalize(cite))
-        .filter((cite) => path.extname(cite).toLowerCase() === ".png"));
+        .filter((cite) => IMAGE_EXTENSIONS.has(path.extname(cite).toLowerCase())));
 }
 /**
- * The PNGs the derivative keeps. verify cannot read an image, so only one an actor trace registers
- * as a stream screenshot can be share_ready. A PNG nothing cites is dropped; a PNG that other
- * evidence cites refuses the export, since dropping it would change that evidence.
+ * The images the derivative keeps, each with the path the copy holds it at: a PNG at its own path,
+ * a WebP frame at the same path ending .png, since a blurred frame is a PNG. verify cannot read an
+ * image, so only one an actor trace registers as a stream screenshot can be share_ready. An image
+ * nothing cites is dropped; one that other evidence cites refuses the export, since dropping it
+ * would change that evidence.
  */
-function keptPngPaths(source, bundle) {
+function keptImagePaths(source, bundle) {
     const streamShots = streamScreenshotPaths(bundle);
-    const cited = citedPngPaths(bundle);
-    const kept = new Set();
+    const cited = citedImagePaths(bundle);
+    const present = new Set(source.files.map((file) => file.path));
+    const kept = new Map();
+    const outputs = new Set();
     for (const file of source.files) {
-        if (path.extname(file.path).toLowerCase() !== ".png")
+        const extension = path.extname(file.path).toLowerCase();
+        if (!IMAGE_EXTENSIONS.has(extension))
             continue;
-        // A file that only claims to be a PNG may conceal a payload; refuse it rather than drop it.
-        if (!file.bytes.subarray(0, 8).equals(PNG_MAGIC))
+        // A file that only claims to be an image may conceal a payload; refuse it rather than drop it.
+        if (extension === ".png" && !file.bytes.subarray(0, 8).equals(PNG_MAGIC))
             throw new Error("PNG artifact has invalid signature.");
+        if (extension === ".webp" && webpStructure(file.bytes).error !== null)
+            throw new Error(`WebP artifact ${file.path} is not a lossless WebP frame.`);
         if (streamShots.has(file.path)) {
-            kept.add(file.path);
+            const output = extension === ".webp" ? `${file.path.slice(0, -extension.length)}.png` : file.path;
+            if (output !== file.path && present.has(output))
+                throw new Error(`${file.path} would be blurred to ${output}, which the run already holds; export refuses to overwrite it.`);
+            if (outputs.has(output))
+                throw new Error(`Two frames would be exported as ${output}.`);
+            outputs.add(output);
+            kept.set(file.path, output);
         }
         else if (cited.has(file.path)) {
             throw new Error(`Evidence cites ${file.path}, an image that is not a stream screenshot; verify cannot read it, so no export of this run can be share_ready.`);
@@ -195,9 +214,21 @@ function keptPngPaths(source, bundle) {
     }
     return kept;
 }
+/** A WebP frame as the PNG redactScreenshot reads, after the same pixel cap a PNG meets. */
+async function webpAsPng(bytes) {
+    const structure = webpStructure(bytes);
+    const refusal = structure.error ??
+        imageDimensionsError("WebP", structure.dimensions.width, structure.dimensions.height);
+    if (refusal !== null)
+        throw new Error(`WebP artifact could not be decoded safely: ${refusal}.`);
+    const image = await decodeWebp(bytes);
+    const png = new PNG({ width: image.width, height: image.height });
+    image.data.copy(png.data);
+    return PNG.sync.write(png);
+}
 async function writeDerivative(source, stagePaths, bundle) {
     const entries = [];
-    const imagePaths = keptPngPaths(source, bundle);
+    const imagePaths = keptImagePaths(source, bundle);
     const sandboxIds = inventorySandboxIds(source.files);
     // run.json and each trace file come from one rewritten bundle, so each trace's index binds the
     // bytes written here. A v1 source is written as v2.
@@ -206,11 +237,25 @@ async function writeDerivative(source, stagePaths, bundle) {
         ["run.json", jsonBytes(derived.bundle)],
         ...derived.files.map((file) => [file.path, file.bytes]),
     ]);
+    // A file that still names a WebP frame would cite a frame the copy lacks. Its file name is
+    // matched in every reading verify decodes (escapes, percent-encoding), so an alias such as
+    // `screenshots/./frame.webp` or `%66rame.webp` is caught too.
+    const renamedNames = [...imagePaths]
+        .filter(([from, to]) => from !== to)
+        .map(([from]) => path.posix.basename(from).toLowerCase());
+    const assertNoRenamedSource = (relative, bytes) => {
+        if (renamedNames.length === 0)
+            return;
+        const readings = readingsOf(bytes.toString("utf8")).map((reading) => reading.toLowerCase());
+        const named = renamedNames.find((name) => readings.some((reading) => reading.includes(name)));
+        if (named !== undefined)
+            throw new Error(`${relative} names ${named}, a WebP frame the copy holds as a blurred PNG; export cannot rewrite that reference.`);
+    };
     let images = 0;
     for (const file of source.files) {
-        const isPng = path.extname(file.path).toLowerCase() === ".png";
+        const isImage = IMAGE_EXTENSIONS.has(path.extname(file.path).toLowerCase());
         const reason = omittedReason(file.path) ??
-            (isPng && !imagePaths.has(file.path)
+            (isImage && !imagePaths.has(file.path)
                 ? "unreferenced image: nothing cites it and verify cannot read it"
                 : undefined);
         if (reason) {
@@ -220,10 +265,11 @@ async function writeDerivative(source, stagePaths, bundle) {
         const extension = path.extname(file.path).toLowerCase();
         let bytes;
         let action;
-        if (extension === ".png") {
-            if (!file.bytes.subarray(0, 8).equals(PNG_MAGIC))
+        const outputPath = imagePaths.get(file.path) ?? file.path;
+        if (extension === ".png" || extension === ".webp") {
+            if (extension === ".png" && !file.bytes.subarray(0, 8).equals(PNG_MAGIC))
                 throw new Error("PNG artifact has invalid signature.");
-            const redacted = redactScreenshot(file.bytes);
+            const redacted = redactScreenshot(extension === ".webp" ? await webpAsPng(file.bytes) : file.bytes);
             if (!redacted.decoded)
                 throw new Error("PNG artifact could not be decoded safely; export refuses a placeholder.");
             bytes = redacted.buffer;
@@ -232,7 +278,7 @@ async function writeDerivative(source, stagePaths, bundle) {
         }
         else {
             if (!TEXT_EXTENSIONS.has(extension))
-                throw new Error(`Unsupported artifact format ${extension || "(no extension)"}; bundle export supports PNG and UTF-8 text only.`);
+                throw new Error(`Unsupported artifact format ${extension || "(no extension)"}; bundle export supports PNG, lossless WebP frames and UTF-8 text only.`);
             bytes = transformText(file, imagePaths);
             const rewritten = derivedFiles.get(file.path);
             if (rewritten !== undefined) {
@@ -241,16 +287,24 @@ async function writeDerivative(source, stagePaths, bundle) {
                 derivedFiles.delete(file.path);
             }
             bytes = scrubSandboxIdBytes(file.path, bytes, sandboxIds);
+            assertNoRenamedSource(file.path, bytes);
             action = bytes.equals(file.bytes) ? "copied" : "updated";
         }
-        await writeContainedOutputFile(stagePaths, file.path, bytes);
-        entries.push({ path: file.path, sourceSha256: file.sha256, outputSha256: hash(bytes), action });
+        await writeContainedOutputFile(stagePaths, outputPath, bytes);
+        entries.push({
+            path: file.path,
+            ...(outputPath === file.path ? {} : { outputPath }),
+            sourceSha256: file.sha256,
+            outputSha256: hash(bytes),
+            action,
+        });
     }
     // A v1 source stream with no actor trace file gets one; its content came from run.json.
     const runJson = source.files.find((file) => file.path === "run.json");
     for (const [relative, bytes] of derivedFiles) {
         if (relative === "run.json" || runJson === undefined)
             continue;
+        assertNoRenamedSource(relative, bytes);
         await writeContainedOutputFile(stagePaths, relative, bytes);
         entries.push({
             path: relative,
@@ -419,7 +473,7 @@ async function verifyFrozenSource(workspace, source, runId) {
     if (bundle.runId !== runId)
         throw new Error("Source run identity does not match its directory.");
     assertFinished(bundle);
-    assertFeedbackReferences(bundle, source);
+    assertFeedbackReferences(bundle, source, keptImagePaths(source, bundle));
     await removeOwnedDirectory(rawSnapshot, true);
     workspace.rawSnapshot = undefined;
     return { bundle };

package/dist/remote/launch.js

@@ -8,7 +8,7 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { readContainedRegularFile, writeContainedOutputFile } from "../run/contained-output.js";
+import { readContainedRegularFile, removeContainedOutputFile, writeContainedOutputFile, } from "../run/contained-output.js";
 import { createRunArtifactPaths } from "../run/paths.js";
 import { reclaimRunSandboxes } from "../run/reclaim.js";
 import { pointLatestRunAt } from "../run/run.js";
@@ -141,7 +141,7 @@ export async function followRemoteRun(args) {
     // Evidence already copied while the run went on, by path, with its size then.
     const copied = new Map();
     const copy = async () => {
-        const { files, alreadyHere } = await copyRunBack(runner, paths, runId);
+        const { files, alreadyHere } = await copyRunBack(runner, paths, runId, copied);
         if (alreadyHere > 0)
             say(`${alreadyHere} of its ${files} files were already here.`);
         return files;
@@ -255,9 +255,10 @@ async function readRun(runner, runId, seen, signals) {
 /**
  * Copy every file of the runner's run directory into this machine's run directory, each checked
  * against the digest the runner listed. The sandbox journal keeps this machine's lines (the
- * runner's own receipt) and adds the runner's (its participants').
+ * runner's own receipt) and adds the runner's (its participants'). A file copied while the run went
+ * on that the runner no longer has, a frame's PNG replaced by its WebP, is removed here too.
  */
-async function copyRunBack(runner, paths, runId) {
+async function copyRunBack(runner, paths, runId, copiedWhileRunning) {
     const files = await listRemoteRun(runner, runId);
     let alreadyHere = 0;
     const wanted = [];
@@ -278,6 +279,10 @@ async function copyRunBack(runner, paths, runId) {
         const mine = local.status === "read" ? Buffer.from(local.bytes).toString("utf8") : "";
         await writeContainedOutputFile(paths, file.path, joinJournals(mine, Buffer.from(bytes).toString("utf8")), "utf8");
     });
+    const listed = new Set(files.map((file) => file.path));
+    for (const file of copiedWhileRunning.keys())
+        if (!listed.has(file))
+            await removeContainedOutputFile(paths, file);
     await pointLatestRunAt(paths, runId);
     return { files: files.length, alreadyHere };
 }

package/dist/routes/computer-use/participant-execution.d.ts

@@ -1,12 +1,5 @@
-import { type PreparedOutputRoot } from "../../run/contained-output.js";
 import type { CuaParticipantDeps, CuaParticipantPlan, CuaParticipantResult, DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
 import type { RunSubjectProvenance } from "../../run/bundle.js";
-/** Build a participant's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
- *  the relative path the trace references (screenshots/<name> at N=1; screenshots/<laneId>/<name>
- *  at N>1). */
-export declare function makeParticipantWriteScreenshot(artifactRoot: PreparedOutputRoot, spec: {
-    screenshotDir: string;
-}, screenshots: string[]): (name: string, bytes: Buffer) => Promise<string>;
 /** Run one participant against a prepared desktop. The adapter owns provisioning, final
  * evidence and cleanup; this runner owns the model, trace and participant outcome. */
 export declare function runCuaParticipant(spec: DesktopParticipantRun, deps: CuaParticipantDeps): Promise<ParticipantRunOutcome>;

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

@@ -2,36 +2,12 @@ import { scheduledParticipantDeps } from "./participant-runs.js";
 import { judgeParticipantRecords } from "../../run/judge.js";
 import { createE2BParticipantDesktop } from "./e2b-desktop/desktop.js";
 import { createInProcessDesktop } from "./in-process-desktop.js";
-import path from "node:path";
 import { cuaParticipantDiagnostics } from "./diagnostics.js";
 import { pastEndReason, runOnSchedule } from "../../study/arrivals.js";
-import { assertScreenshotEvidence, stripPngMetadataChunks } from "../../evidence/image.js";
 import { redactText, toErrorMessage } from "../../evidence/redaction.js";
-import { assertSafeOutputPathSegment, writeContainedOutputFile, } from "../../run/contained-output.js";
+import { participantFrames } from "./participant-frames.js";
 import { participantOutcomeOk, participantFactsOf } from "./participant-facts.js";
 import { closeParticipantModel, judgeParticipantSession, participantSessionOptions, recordParticipantTrace, startParticipantModel, } from "./participant-model.js";
-/** Build a participant's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
- *  the relative path the trace references (screenshots/<name> at N=1; screenshots/<laneId>/<name>
- *  at N>1). */
-export function makeParticipantWriteScreenshot(artifactRoot, spec, screenshots) {
-    if (spec.screenshotDir) {
-        assertSafeOutputPathSegment(spec.screenshotDir, "Screenshot participant id");
-    }
-    const dirParts = spec.screenshotDir ? ["screenshots", spec.screenshotDir] : ["screenshots"];
-    const relPrefix = spec.screenshotDir
-        ? path.posix.join("screenshots", spec.screenshotDir)
-        : "screenshots";
-    return async (name, bytes) => {
-        assertSafeOutputPathSegment(name, "Screenshot name");
-        const rel = path.posix.join(relPrefix, name);
-        // Evidence holds image data only, whatever the executor's frames carried.
-        const frame = stripPngMetadataChunks(bytes);
-        await assertScreenshotEvidence(rel, frame);
-        await writeContainedOutputFile(artifactRoot, path.join(...dirParts, name), frame);
-        screenshots.push(rel);
-        return rel;
-    };
-}
 /** A blocked participant outcome: the pipeline gate or the study budget skipped it. */
 function skippedOutcome(spec, reason, arrival) {
     return {
@@ -65,8 +41,8 @@ export async function runCuaParticipant(spec, deps) {
         return skippedOutcome(spec, pastEnd);
     let model = {};
     const warnings = [];
-    const screenshots = [];
-    const writeScreenshot = makeParticipantWriteScreenshot(deps.artifactRoot, spec, screenshots);
+    const frames = participantFrames(deps.artifactRoot, spec, { blurred: deps.redactScreenshots });
+    const writeScreenshot = frames.write;
     let session;
     let sessionError;
     let providerCleanupError;
@@ -112,6 +88,7 @@ export async function runCuaParticipant(spec, deps) {
         else
             sessionError = desktopFailure;
     }
+    const replacedFrames = await frames.finish(session?.trace);
     if (session)
         await recordParticipantTrace(spec, deps, session, warnings);
     const { noEngagement, selfReportedBlocker, reportedFriction } = judgeParticipantSession(session, deps, warnings);
@@ -129,7 +106,8 @@ export async function runCuaParticipant(spec, deps) {
         ...(providerPolicyError === undefined ? {} : { providerPolicyError }),
         ...desktopEvidence,
         killed: released,
-        screenshots,
+        screenshots: frames.screenshots,
+        replacedFrames,
         warnings,
         noEngagement,
         selfReportedBlocker,

package/dist/routes/computer-use/participant-frames.d.ts

@@ -0,0 +1,32 @@
+import type { ActorTrace } from "../../actors/contract.js";
+import { type WebpTranscoder } from "../../evidence/webp-transcoder.js";
+import { type PreparedOutputRoot } from "../../run/contained-output.js";
+/** Build a participant's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
+ *  the relative path the trace references (screenshots/<name> at N=1; screenshots/<laneId>/<name>
+ *  at N>1). */
+export declare function makeParticipantWriteScreenshot(artifactRoot: PreparedOutputRoot, spec: {
+    screenshotDir: string;
+}, screenshots: string[]): (name: string, bytes: Buffer) => Promise<string>;
+export interface ParticipantFrames {
+    /** The session's writeScreenshot: writes the PNG, then queues its WebP. */
+    write(name: string, bytes: Buffer): Promise<string>;
+    /** Every frame written, by the path its trace references names. */
+    readonly screenshots: string[];
+    /**
+     * Waits up to FINISH_WAIT_MS for the frames still queued, then points `trace` and `screenshots`
+     * at each frame's WebP. Returns the PNGs those WebP replace, which the run removes once its final
+     * bundle is written: until then the live trace in run.json still names them.
+     */
+    finish(trace: ActorTrace | undefined): Promise<string[]>;
+}
+/**
+ * `blurred` is the study's policies.redactScreenshots: its frames are the redactor's PNG
+ * thumbnails, which stay PNG, since only that shape counts as blurred evidence.
+ */
+export declare function participantFrames(artifactRoot: PreparedOutputRoot, spec: {
+    screenshotDir: string;
+}, options: {
+    blurred: boolean;
+    transcoder?: WebpTranscoder;
+    finishWaitMs?: number;
+}): ParticipantFrames;

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

@@ -0,0 +1,93 @@
+// A computer-use participant's screenshots: each frame is written and referenced as PNG during the
+// session, as the live Observer and a mid-run copy read it, and queued for a lossless WebP copy.
+// When the session ends, each frame whose WebP is written is referenced by its WebP instead and
+// its PNG removed, so at no point does a reference name a file that is not there.
+import path from "node:path";
+import { assertScreenshotEvidence, stripPngMetadataChunks } from "../../evidence/image.js";
+import { webpTranscoder } from "../../evidence/webp-transcoder.js";
+import { assertSafeOutputPathSegment, writeContainedOutputFile, } from "../../run/contained-output.js";
+/**
+ * How long a finished session waits for its frames still queued. Encoding takes about 330 ms a
+ * frame, so this covers a short backlog; a frame not done by then stays PNG.
+ */
+const FINISH_WAIT_MS = 5_000;
+/** Build a participant's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
+ *  the relative path the trace references (screenshots/<name> at N=1; screenshots/<laneId>/<name>
+ *  at N>1). */
+export function makeParticipantWriteScreenshot(artifactRoot, spec, screenshots) {
+    if (spec.screenshotDir) {
+        assertSafeOutputPathSegment(spec.screenshotDir, "Screenshot participant id");
+    }
+    const dirParts = spec.screenshotDir ? ["screenshots", spec.screenshotDir] : ["screenshots"];
+    const relPrefix = spec.screenshotDir
+        ? path.posix.join("screenshots", spec.screenshotDir)
+        : "screenshots";
+    return async (name, bytes) => {
+        assertSafeOutputPathSegment(name, "Screenshot name");
+        const rel = path.posix.join(relPrefix, name);
+        // Evidence holds image data only, whatever the executor's frames carried.
+        const frame = stripPngMetadataChunks(bytes);
+        await assertScreenshotEvidence(rel, frame);
+        await writeContainedOutputFile(artifactRoot, path.join(...dirParts, name), frame);
+        screenshots.push(rel);
+        return rel;
+    };
+}
+/**
+ * `blurred` is the study's policies.redactScreenshots: its frames are the redactor's PNG
+ * thumbnails, which stay PNG, since only that shape counts as blurred evidence.
+ */
+export function participantFrames(artifactRoot, spec, options) {
+    const transcoder = options.blurred ? undefined : (options.transcoder ?? webpTranscoder());
+    const finishWaitMs = options.finishWaitMs ?? FINISH_WAIT_MS;
+    const screenshots = [];
+    const writePng = makeParticipantWriteScreenshot(artifactRoot, spec, screenshots);
+    const queued = [];
+    /** Each frame whose WebP is written: its PNG path and its WebP path. */
+    const done = new Map();
+    // Once the session's references are settled, a late WebP is not written: nothing would name it.
+    let finished = false;
+    return {
+        screenshots,
+        async write(name, bytes) {
+            const rel = await writePng(name, bytes);
+            const webpRel = rel.replace(/\.png$/, ".webp");
+            const job = webpRel === rel ? undefined : transcoder?.transcode(bytes);
+            // A frame the worker cannot take, or fails to encode or write, stays PNG.
+            if (job !== undefined)
+                queued.push({
+                    done: job.webp
+                        .then(async (webp) => {
+                        if (finished)
+                            return;
+                        await writeContainedOutputFile(artifactRoot, webpRel, webp);
+                        done.set(rel, webpRel);
+                    })
+                        .catch(() => undefined),
+                    abandon: job.abandon,
+                });
+            return rel;
+        },
+        async finish(trace) {
+            let timer;
+            await Promise.race([
+                Promise.all(queued.map((job) => job.done)),
+                new Promise((resolve) => (timer = setTimeout(resolve, finishWaitMs))),
+            ]);
+            clearTimeout(timer);
+            finished = true;
+            const replaced = new Map(done);
+            if (trace !== undefined)
+                trace.items = trace.items.map((item) => {
+                    const webp = item.screenshotRef && replaced.get(item.screenshotRef.path);
+                    return webp === undefined || item.screenshotRef === undefined
+                        ? item
+                        : { ...item, screenshotRef: { ...item.screenshotRef, path: webp } };
+                });
+            screenshots.splice(0, screenshots.length, ...screenshots.map((rel) => replaced.get(rel) ?? rel));
+            for (const job of queued)
+                job.abandon();
+            return [...replaced.keys()];
+        },
+    };
+}

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

@@ -118,6 +118,9 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
             ...(spec.planned.limits.maxOutputTokens === undefined
                 ? {}
                 : { maxOutputTokens: spec.planned.limits.maxOutputTokens }),
+            ...(spec.planned.limits.serviceTier === undefined
+                ? {}
+                : { serviceTier: spec.planned.limits.serviceTier }),
         },
         ...(maxUsd === undefined
             ? {}

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

@@ -152,6 +152,9 @@ function planEntry(spec) {
         ...(spec.planned.limits.maxOutputTokens === undefined
             ? {}
             : { maxOutputTokens: spec.planned.limits.maxOutputTokens }),
+        ...(spec.planned.limits.serviceTier === undefined
+            ? {}
+            : { serviceTier: spec.planned.limits.serviceTier }),
         ...(spec.planned.targetUrl === undefined
             ? {}
             : { targetDigest: digestUrl(spec.planned.targetUrl) }),
@@ -179,6 +182,7 @@ export function formatParticipantPlanEntry(entry) {
         entry.surface ? `surface=${entry.surface}` : undefined,
         entry.caseGroup ? `case=${entry.caseGroup}` : undefined,
         entry.reasoningEffort ? `effort=${entry.reasoningEffort}` : undefined,
+        entry.serviceTier ? `tier=${entry.serviceTier}` : undefined,
         entry.startAfterMs === undefined ? undefined : `start=+${formatDuration(entry.startAfterMs)}`,
         entry.endAfterMs === undefined ? undefined : `end=+${formatDuration(entry.endAfterMs)}`,
         entry.maxSessionMs === undefined ? undefined : `cap=${formatDuration(entry.maxSessionMs)}`,