humanish 0.146.0 → 0.147.0

package/dist/routes/computer-use/plan.js

@@ -13,7 +13,7 @@ import { brainOf, callerBrainOf, planCaps, desktopRequirements, planBase, provis
 import { computerUseParticipants, declaredTargets, } from "../../study/plan-participants.js";
 import { planStarts, windowDeadlineRefusal } from "../../study/arrivals.js";
 import { computerUseParticipantCount, participantCountReason } from "../../study/routing.js";
-import { cloneTargetValidationReason, computerUseValidationReason, desktopMediaValidationReason, networkCaptureValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "../../study/validation.js";
+import { cloneTargetValidationReason, computerUseValidationReason, desktopMediaValidationReason, networkCaptureValidationReason, outputTokenLimitValidationReason, serviceTierValidationReason, receivingEmailValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "../../study/validation.js";
 import { desktopCliProductReason } from "../../study/composition-rules.js";
 import { isLocalBrowserStudy } from "../../substrates/local/runtime-config.js";
 import { boundedConcurrency, defaultSessionTimeoutMs, resolveParticipantSandboxMs, } from "./participant-runs.js";
@@ -89,12 +89,16 @@ function unsupportedDeclarationReason(config, hasRunSession, driving, { inProces
     const reason = desktopMediaValidationReason(config) ||
         networkCaptureValidationReason(config, "computer-use") ||
         outputTokenLimitValidationReason(config) ||
+        serviceTierValidationReason(config) ||
         waitLimitValidationReason(config);
     if (reason)
         return invalid(reason);
     if (config.actor?.maxOutputTokens !== undefined &&
         (hasRunSession || driving.createProvider || driving.inProcess))
         return invalid("maxOutputTokens cannot be enforced by a custom runSession/provider/executor route.");
+    if (config.actor?.serviceTier !== undefined &&
+        (hasRunSession || driving.createProvider || driving.inProcess))
+        return invalid("serviceTier is not sent by a custom runSession/provider/executor route.");
     const receivingReason = receivingEmailValidationReason(config);
     if (receivingReason)
         return invalid(receivingReason);

package/dist/routes/computer-use/result.js

@@ -1,3 +1,4 @@
+import { removeContainedOutputFile } from "../../run/contained-output.js";
 import { adapterScoreFailureMessage, applyBrowserScorer } from "../../study/adapter-extension.js";
 import { redactText } from "../../evidence/redaction.js";
 import { foldScorerFailures, judgeExecution, judgeParticipantRecords, OUTCOME_POLICIES, participantHarnessFailed, resultOk, } from "../../run/judge.js";
@@ -260,6 +261,11 @@ export async function finishCuaRun(setup, finish, ran) {
         execution,
         policy,
     });
+    // The final bundle names each replaced frame's WebP, so its PNG goes before the Observer
+    // verifies the run directory.
+    for (const outcome of outcomes ?? [])
+        for (const png of outcome.replacedFrames ?? [])
+            await removeContainedOutputFile(finished.paths, png);
     const observer = await finished.renderObserver();
     // A caller's renderer runs with this process's file access, so after one that reports success
     // the run directory is checked again before the result points anyone at it. A failed render is

package/dist/routes/computer-use/types.d.ts

@@ -112,6 +112,8 @@ export interface CuaParticipantPlanEntry {
      *  you read before spending money, so a declared per-participant difference has to be visible there. */
     reasoningEffort?: string;
     maxOutputTokens?: number;
+    /** The declared OpenAI service tier, which bills at its own rate. */
+    serviceTier?: string;
     /** Present only when a participant overrides subject.appUrl; digest avoids leaking preview hosts in plan logs. */
     targetDigest?: string;
     /** The participant's declared start, in ms after the run starts its participants. */
@@ -432,6 +434,8 @@ export interface SandboxReleaseFact {
 /** One participant's end-to-end run outcome (internal; projected into CuaParticipantResult + the bundle). */
 export interface ParticipantRunOutcome {
     spec: DesktopParticipantRun;
+    /** The PNG frames its WebP replaced, which the run removes once its final bundle is written. */
+    replacedFrames?: string[];
     session?: CuaLoopResult;
     /** The harness failed before the session reached a terminal status. */
     sessionError?: string;

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

@@ -12,7 +12,7 @@ import { DESKTOP_FILES_ROUTE_REASON } from "../../study/desktop-files.js";
 import { participantList } from "../../study/study-fields.js";
 import { PUBLIC_TARGET_OWNER_PATTERN } from "../../study/parse/subject.js";
 import { REPO_SLUG_PATTERN } from "../../study/parse/values.js";
-import { concurrentSharedWorldValidationReason, desktopMediaValidationReason, networkCaptureValidationReason, externalPublicSharedWorldValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "../../study/validation.js";
+import { concurrentSharedWorldValidationReason, desktopMediaValidationReason, networkCaptureValidationReason, externalPublicSharedWorldValidationReason, outputTokenLimitValidationReason, serviceTierValidationReason, receivingEmailValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "../../study/validation.js";
 import { unpricedCapCheck } from "../../study/requirements.js";
 import { participantsAtOnce, sandboxDeadlineRefusal, sandboxHeadroomMs, } from "../../substrates/e2b/lifetime.js";
 import { boundedConcurrency } from "../computer-use/participant-runs.js";
@@ -62,6 +62,7 @@ export function planSharedWorldStudy(config, input) {
     // A library caller's config skips the parser, which refuses these first.
     studyUrlCredentialReason(config) ??
         outputTokenLimitValidationReason(config) ??
+        serviceTierValidationReason(config) ??
         waitLimitValidationReason(config) ??
         (externalPublic
             ? externalPublicSharedWorldValidationReason(config)
@@ -70,6 +71,8 @@ export function planSharedWorldStudy(config, input) {
         return refuse(invalid, invalidReason, actor);
     if (config.actor?.maxOutputTokens !== undefined && input.hasRunSession === true)
         return refuse(invalid, "maxOutputTokens cannot be enforced by a custom runSession.", actor);
+    if (config.actor?.serviceTier !== undefined && input.hasRunSession === true)
+        return refuse(invalid, "serviceTier is not sent by a custom runSession.", actor);
     // A live cap is priced here, at plan time, so its refusal wins over the route's key checks.
     const unpriced = input.dryRun
         ? undefined

package/dist/run/pricing.d.ts

@@ -30,6 +30,11 @@ export interface ModelRate {
     until?: string;
     /** The rates the sheet publishes from the day after `until`. */
     after?: Pick<ModelRate, "inputUsdPerToken" | "outputUsdPerToken" | "cachedInputUsdPerToken">;
+    /** Fast mode rates (OpenAI `service_tier: "fast"`, served as `fast` or `priority`), when the
+     *  sheet publishes them. The long-context multipliers apply on top. */
+    fast?: Pick<ModelRate, "inputUsdPerToken" | "outputUsdPerToken" | "cachedInputUsdPerToken" | "cacheWriteUsdPerToken"> & {
+        source?: string;
+    };
     /** The `YYYY-MM-DD` date the entry was last checked against `source`. */
     asOf: string;
     /** Public pricing page the number came from (a comment/URL, never a secret). */
@@ -101,6 +106,8 @@ export interface ActorEstimatedCost {
         /** How many requests crossed the long-context threshold and were re-tiered. Present only
          *  when per-request `turns` records made exact tiering possible. */
         longContextTurns?: number;
+        /** How many requests the provider served in Fast mode and were priced at its rates. */
+        fastTurns?: number;
     };
 }
 /** The desktop-minute cost estimate (host-side create->teardown span * a per-minute rate). Same

package/dist/run/pricing.js

@@ -54,6 +54,26 @@ function geminiRate(inPer1M, cachedPer1M, outPer1M, change = {}) {
         source: "ai.google.dev/gemini-api/docs/pricing (paid tier, standard)",
     };
 }
+// Fast mode: OpenAI's `service_tier: "fast"` (formerly priority processing), billed per token at
+// its own rates with the cached-input discount and the long-context tier. gpt-5.6-sol's fast rates
+// are twice every standard rate ("For GPT-5.6 Sol, Fast mode costs twice the corresponding Standard
+// rate", developers.openai.com/api/docs/guides/fast-mode, read 2026-10-24); the 6-series rates are
+// the Fast tab of developers.openai.com/api/docs/pricing?latest-pricing=fast, read 2026-10-24.
+const FAST_MODE_GUIDE = "developers.openai.com/api/docs/guides/fast-mode (gpt-5.6-sol, 2x standard)";
+const FAST_MODE_SHEET = "developers.openai.com/api/docs/pricing?latest-pricing=fast (fast tier)";
+/** A rate with Fast mode rates per 1M tokens: input, cached input, cache write and output. */
+function withFast(rate, inPer1M, cachedPer1M, writePer1M, outPer1M, source) {
+    return {
+        ...rate,
+        fast: {
+            inputUsdPerToken: inPer1M * 1e-6,
+            cachedInputUsdPerToken: cachedPer1M * 1e-6,
+            cacheWriteUsdPerToken: writePer1M * 1e-6,
+            outputUsdPerToken: outPer1M * 1e-6,
+            source,
+        },
+    };
+}
 // gpt-5.6-sol promotional rates (live sheet 2026-09-03: $4 / $0.40 cached / $5 write / $20 out,
 // "available at least through November 21, 2026"). Re-verify against the sheet after Nov 21.
 const GPT56_SOL_PROMO_AS_OF = "2026-09-03";
@@ -84,10 +104,10 @@ export const MODEL_RATES = {
     // the longContext block prices the >272K re-tier when per-request turns are recorded).
     // sol = flagship (the shipped CUA default), terra = cost-balanced, luna = high-volume,
     // cyber = the Daybreak frontier tier.
-    "gpt-5.6-sol": rateWithLongContextTier(4, 0.4, 5, 20, GPT56_SOL_PROMO_AS_OF),
+    "gpt-5.6-sol": withFast(rateWithLongContextTier(4, 0.4, 5, 20, GPT56_SOL_PROMO_AS_OF), 8, 0.8, 10, 40, FAST_MODE_GUIDE),
     // "gpt-5.6" is OpenAI's own alias for gpt-5.6-sol (models index); priced identically so a
     // study configured with the alias never reads as unpriced.
-    "gpt-5.6": rateWithLongContextTier(4, 0.4, 5, 20, GPT56_SOL_PROMO_AS_OF),
+    "gpt-5.6": withFast(rateWithLongContextTier(4, 0.4, 5, 20, GPT56_SOL_PROMO_AS_OF), 8, 0.8, 10, 40, FAST_MODE_GUIDE),
     "gpt-5.6-terra": rateWithLongContextTier(2, 0.2, 2.5, 12),
     "gpt-5.6-luna": rateWithLongContextTier(0.2, 0.02, 0.25, 1.2),
     "gpt-5.6-cyber": rateWithLongContextTier(12.5, 1.25, 15.625, 75),
@@ -100,11 +120,11 @@ export const MODEL_RATES = {
     // as the 5.6 family on the sheet: writes at 1.25x, >272K re-tiers at 2x input-side / 1.5x
     // output ($20 / $2 / $25 / $75 long-context columns). These rates cover explicit study
     // model choices and the study-analysis default; the computer-use default is separate.
-    "gpt-6-astra": rateWithLongContextTier(10, 1, 12.5, 50, GPT6_ASTRA_AS_OF, GPT6_ASTRA_SOURCE),
+    "gpt-6-astra": withFast(rateWithLongContextTier(10, 1, 12.5, 50, GPT6_ASTRA_AS_OF, GPT6_ASTRA_SOURCE), 20, 2, 25, 100, FAST_MODE_SHEET),
     // gpt-6.1-sol and gpt-6-luna: the same write and long-context mechanics on the sheet and each
     // model page. 6.1 Sol bills cache reads at 5% of input ($0.10), where the others bill 10%.
-    "gpt-6.1-sol": rateWithLongContextTier(2, 0.1, 2.5, 10, GPT6_SOL_LUNA_AS_OF, GPT6_SOL_LUNA_SOURCE),
-    "gpt-6-luna": rateWithLongContextTier(0.1, 0.01, 0.125, 0.5, GPT6_SOL_LUNA_AS_OF, GPT6_SOL_LUNA_SOURCE),
+    "gpt-6.1-sol": withFast(rateWithLongContextTier(2, 0.1, 2.5, 10, GPT6_SOL_LUNA_AS_OF, GPT6_SOL_LUNA_SOURCE), 4, 0.2, 5, 20, FAST_MODE_SHEET),
+    "gpt-6-luna": withFast(rateWithLongContextTier(0.1, 0.01, 0.125, 0.5, GPT6_SOL_LUNA_AS_OF, GPT6_SOL_LUNA_SOURCE), 0.2, 0.02, 0.25, 1, FAST_MODE_SHEET),
     // Gemini analysis models, paid standard tier. Thinking tokens bill as output. No long-context
     // tier is published for them. Cached input is the implicit context-cache rate. On the free tier
     // these requests bill nothing, so the estimate is the paid-tier cost.
@@ -283,24 +303,41 @@ export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES, at =
     // price every token at the full rate while the session totals sit ignored, overstating spend
     // 3.5-5x and tripping caps early. Inconsistent evidence falls back to the totals path, which
     // honors the declared splits on the base tier.
-    const tiered = rate.longContext !== undefined &&
+    const tiered = (rate.longContext !== undefined || turns.some((turn) => isFastServiceTier(turn.serviceTier))) &&
         turns.length > 0 &&
         sumOf("input") === inTok &&
         sumOf("output") === outTok &&
         sumOf("cachedInput") === (tokenUsage.cachedInput ?? 0) &&
         sumOf("cacheWriteInput") === (tokenUsage.cacheWriteInput ?? 0);
+    // A request served in Fast mode bills at the fast rates. Totals that the ledger does not
+    // decompose price at the fast rate when any request was served fast: the over-estimate direction.
+    const fastTotals = !tiered && turns.some((turn) => isFastServiceTier(turn.serviceTier));
+    // A request served fast on a model with no Fast mode rate has no rate in this table.
+    if (rate.fast === undefined && turns.some((turn) => isFastServiceTier(turn.serviceTier))) {
+        return {
+            schema: ACTOR_ESTIMATED_COST_SCHEMA,
+            estimatedCostUsd: null,
+            reason: "no_rate_for_model",
+            ratesAsOf: null,
+            ...(modelId ? { modelId } : {}),
+        };
+    }
     let inputUsd = 0;
     let outputUsd = 0;
     let cachedTotal = 0;
     let writeTotal = 0;
     let longContextTurns = 0;
+    let fastTurns = 0;
     // Price one request's usage at one tier. Cached input is billed at a fraction of the full rate,
     // and on a session that threads provider state it is the majority of input, and pricing it at the
     // full rate overstates real spend by up to ~10x. Cache writes bill at their own rate (1.25x on
     // OpenAI 5.6+) as the total rate for those tokens; a sheet without a write rate prices writes as
     // plain input (pre-5.6: writes are free-of-extra-fee, i.e. plain input). An unreported piece
     // stays absent: no reported split means no discount and no surcharge assumed.
-    const priceRequest = (usage, tierable) => {
+    const priceRequest = (usage, tierable, fast) => {
+        const sheet = fast && rate.fast !== undefined ? { ...rate, ...rate.fast } : rate;
+        if (fast)
+            fastTurns += 1;
         const reqIn = usage.input ?? 0;
         const reqOut = usage.output ?? 0;
         // Tiering applies only to a real per-request record: session totals crossing the threshold
@@ -310,7 +347,7 @@ export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES, at =
         const outMul = long ? rate.longContext.outputMultiplier : 1;
         if (long)
             longContextTurns += 1;
-        const cached = rate.cachedInputUsdPerToken === undefined
+        const cached = sheet.cachedInputUsdPerToken === undefined
             ? 0
             : Math.min(reqIn, Math.max(0, usage.cachedInput ?? 0));
         const writes = Math.min(reqIn - cached, Math.max(0, usage.cacheWriteInput ?? 0));
@@ -318,14 +355,14 @@ export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES, at =
         cachedTotal += cached;
         writeTotal += writes;
         inputUsd +=
-            full * rate.inputUsdPerToken * inMul +
-                cached * (rate.cachedInputUsdPerToken ?? 0) * inMul +
-                writes * (rate.cacheWriteUsdPerToken ?? rate.inputUsdPerToken) * inMul;
-        outputUsd += reqOut * rate.outputUsdPerToken * outMul;
+            full * sheet.inputUsdPerToken * inMul +
+                cached * (sheet.cachedInputUsdPerToken ?? 0) * inMul +
+                writes * (sheet.cacheWriteUsdPerToken ?? sheet.inputUsdPerToken) * inMul;
+        outputUsd += reqOut * sheet.outputUsdPerToken * outMul;
     };
     if (tiered) {
         for (const turn of turns)
-            priceRequest(turn, true);
+            priceRequest(turn, true, isFastServiceTier(turn.serviceTier));
     }
     else {
         priceRequest({
@@ -335,7 +372,7 @@ export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES, at =
             ...(tokenUsage.cacheWriteInput === undefined
                 ? {}
                 : { cacheWriteInput: tokenUsage.cacheWriteInput }),
-        }, false);
+        }, false, fastTotals);
     }
     inputUsd = round6(inputUsd);
     outputUsd = round6(outputUsd);
@@ -343,7 +380,7 @@ export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES, at =
         schema: ACTOR_ESTIMATED_COST_SCHEMA,
         estimatedCostUsd: round6(inputUsd + outputUsd),
         ratesAsOf: rate.asOf,
-        source: rate.source,
+        source: fastTurns > 0 && rate.fast?.source !== undefined ? rate.fast.source : rate.source,
         ...(modelId ? { modelId } : {}),
         ...(rate.placeholder ? { placeholder: true } : {}),
         breakdown: {
@@ -354,9 +391,15 @@ export function estimateActorCost(tokenUsage, modelId, rates = MODEL_RATES, at =
             ...(cachedTotal > 0 ? { cachedInputTokens: cachedTotal } : {}),
             ...(writeTotal > 0 ? { cacheWriteInputTokens: writeTotal } : {}),
             ...(longContextTurns > 0 ? { longContextTurns } : {}),
+            ...(fastTurns > 0 ? { fastTurns } : {}),
         },
     };
 }
+/** Whether a provider-reported tier bills at Fast mode rates. GPT-5.6 reports `priority` for a
+ *  request that asked for `fast`. */
+function isFastServiceTier(tier) {
+    return tier === "fast" || tier === "priority";
+}
 /**
  * Estimate the E2B desktop-minute cost from a host-side create->teardown span (minutes). The rate
  * is injectable. Returns a declared-absent estimate (null + "no_duration") when no duration was

package/dist/study/config.js

@@ -39,7 +39,7 @@ import { invalid, optionalStr, str } from "./parse/values.js";
 import { isComputerUseComposition, routeOf } from "./routing.js";
 import { declaredParticipantIds } from "./plan-participants.js";
 import { ID_PATTERN, STUDY_SCHEMA, } from "./types.js";
-import { automaticAnalysisRouteReason, desktopMediaValidationReason, networkCaptureValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, smtpValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "./validation.js";
+import { automaticAnalysisRouteReason, desktopMediaValidationReason, networkCaptureValidationReason, outputTokenLimitValidationReason, serviceTierValidationReason, receivingEmailValidationReason, smtpValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "./validation.js";
 import { forwardDeclaredWarnings, inertFieldLabels, inertFieldPaths } from "./warnings.js";
 import { plural } from "../run/text.js";
 /**
@@ -234,6 +234,9 @@ function checkStudyConfig(config) {
     const outputLimitReason = outputTokenLimitValidationReason(config);
     if (outputLimitReason)
         return invalid(outputLimitReason);
+    const serviceTierReason = serviceTierValidationReason(config);
+    if (serviceTierReason)
+        return invalid(serviceTierReason);
     const waitLimitReason = waitLimitValidationReason(config);
     if (waitLimitReason)
         return invalid(waitLimitReason);

package/dist/study/keys.d.ts

@@ -126,6 +126,7 @@ export declare const ACTOR: {
     };
     localAgent: true;
     reasoningEffort: true;
+    serviceTier: true;
     stopWhen: {
         any: {
             id: true;

package/dist/study/keys.js

@@ -106,6 +106,7 @@ export const ACTOR = {
     clock: { timeZone: true },
     localAgent: true,
     reasoningEffort: true,
+    serviceTier: true,
     stopWhen: STOP_WHEN,
     dwell: DWELL,
     tasks: { id: true, goal: true, success: STOP_WHEN },

package/dist/study/parse/actors.js

@@ -112,6 +112,11 @@ export function parseActorFields(entry, path) {
         }
         actor.reasoningEffort = entry.reasoningEffort;
     }
+    if (entry.serviceTier !== undefined) {
+        if (entry.serviceTier !== "fast")
+            return invalid(`${path}.serviceTier must be "fast" (OpenAI Fast mode), or left out for the standard tier.`);
+        actor.serviceTier = entry.serviceTier;
+    }
     const stopWhenResult = parseStopWhen(entry.stopWhen, `${path}.stopWhen`);
     if (!stopWhenResult.ok)
         return stopWhenResult;

package/dist/study/plan-participants.d.ts

@@ -37,6 +37,8 @@ export interface DesktopParticipant extends Participant {
         readonly dwell?: DwellWindow;
         readonly reasoningEffort?: ReasoningEffort;
         readonly maxOutputTokens?: number;
+        /** actor.serviceTier: OpenAI Fast mode on every request. */
+        readonly serviceTier?: "fast";
         /** actor.maxWaitMs: the longest one wait or one turn of only waits lasts. */
         readonly maxWaitMs?: number;
         /**

package/dist/study/plan-participants.js

@@ -13,6 +13,7 @@ function desktopParticipant(config, entry, index, kind, focus) {
     const dwell = entry?.dwell ?? actor?.dwell;
     const reasoningEffort = entry?.reasoningEffort ?? actor?.reasoningEffort;
     const maxOutputTokens = actor?.maxOutputTokens;
+    const serviceTier = actor?.serviceTier;
     const maxWaitMs = actor?.maxWaitMs;
     const idleWaitMs = entry?.idleWaitMs ?? actor?.idleWaitMs;
     const timeZone = entry?.clock?.timeZone ?? actor?.clock?.timeZone;
@@ -35,6 +36,7 @@ function desktopParticipant(config, entry, index, kind, focus) {
             ...(dwell === undefined ? {} : { dwell }),
             ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
             ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+            ...(serviceTier === undefined ? {} : { serviceTier }),
             ...(maxWaitMs === undefined ? {} : { maxWaitMs }),
             ...(idleWaitMs === undefined ? {} : { idleWaitMs }),
             ...(timeZone === undefined ? {} : { timeZone }),

package/dist/study/types.d.ts

@@ -453,6 +453,13 @@ export interface StudyActor {
      * docs/principles/actor-fidelity.md.
      */
     reasoningEffort?: ReasoningEffort;
+    /**
+     * `fast` sends every participant request in OpenAI Fast mode (`service_tier: "fast"`), which
+     * bills at its own per-token rates. Absent sends no tier. `openai-computer-use` only, and only for
+     * a model whose Fast mode rate src/run/pricing.ts carries, so the spend estimate and caps price it.
+     * Each request's trace usage records the tier that served it.
+     */
+    serviceTier?: "fast";
     /**
      * Deterministic completion guard used as the default for CUA participants. A `participants` entry's stopWhen
      * overrides this value.

package/dist/study/validation.d.ts

@@ -44,6 +44,11 @@ export declare function taskProtocolValidationReason(config: StudyConfig, suppor
 export declare function cloneTargetValidationReason(config: StudyConfig): string | null;
 /** Refuse a claimed output bound when the route cannot pass it to the first-party provider. */
 export declare function outputTokenLimitValidationReason(config: StudyConfig): string | null;
+/**
+ * Refuse a Fast mode request humanish cannot send or price: the first-party OpenAI computer-use
+ * route sends it, and the spend estimate needs the model's Fast mode rate.
+ */
+export declare function serviceTierValidationReason(config: StudyConfig): string | null;
 /**
  * Refuse a wait field out of range, or an idle wait longer than the longest wait: the actor's, and
  * each participant's own idleWaitMs under actor.maxWaitMs. On a route whose participants take no

package/dist/study/validation.js

@@ -1,4 +1,6 @@
 import { isMaxOutputTokens } from "../actors/output-token-limit.js";
+import { DEFAULT_OPENAI_CU_MODEL } from "../actors/computer-use/openai-provider.js";
+import { MODEL_RATES, participantRate } from "../run/pricing.js";
 import { MAX_RECEIVING_INBOXES } from "../comms/receiving-types.js";
 import { waitFieldsReason } from "../actors/computer-use/wait.js";
 import { PARTICIPANT_ID_MAX_CHARS, PARTICIPANT_ID_PATTERN } from "./parse/actors.js";
@@ -288,6 +290,27 @@ export function outputTokenLimitValidationReason(config) {
     }
     return null;
 }
+/**
+ * Refuse a Fast mode request humanish cannot send or price: the first-party OpenAI computer-use
+ * route sends it, and the spend estimate needs the model's Fast mode rate.
+ */
+export function serviceTierValidationReason(config) {
+    const actor = config.actor;
+    if (actor?.serviceTier === undefined)
+        return null;
+    if (actor.type !== "openai-computer-use" ||
+        !isComputerUseComposition(config) ||
+        config.subject.source === "local-app")
+        return "actor.serviceTier is supported only by first-party OpenAI computer-use routes; terminal, local-agent, scripted and custom in-process routes do not send it.";
+    const model = actor.model ?? DEFAULT_OPENAI_CU_MODEL;
+    if (participantRate(model)?.fast === undefined) {
+        const priced = Object.keys(MODEL_RATES)
+            .filter((id) => participantRate(id)?.fast !== undefined)
+            .sort();
+        return `actor.serviceTier: fast needs a Fast mode rate for model "${model}", and humanish has none, so it could not price the run. Models with a Fast mode rate: ${priced.join(", ")}. Use one of them, or remove serviceTier.`;
+    }
+    return null;
+}
 /**
  * Refuse a wait field out of range, or an idle wait longer than the longest wait: the actor's, and
  * each participant's own idleWaitMs under actor.maxWaitMs. On a route whose participants take no

package/dist/verify/artifacts.js

@@ -192,7 +192,8 @@ export function streamScreenshotPaths(bundle) {
     return paths;
 }
 function isHarnessScreenshotPath(normalized) {
-    return normalized.startsWith("screenshots/") && normalized.toLowerCase().endsWith(".png");
+    const lower = normalized.toLowerCase();
+    return (normalized.startsWith("screenshots/") && (lower.endsWith(".png") || lower.endsWith(".webp")));
 }
 function isRunRootEvidenceReference(value) {
     return (typeof value === "string" &&

package/docs/contracts/run-bundle.md

@@ -1092,11 +1092,23 @@ an unclaimed frame on a raw, silent or live-only trace, and `ocr_scrubbed`, whic
 the trace contract reserves but no writer produces. An aggregate raw declaration
 wins over every frame claim.
 
-A screenshot is a non-interlaced PNG whose first chunk is a 13-byte IHDR, whose
-IEND is empty, and which holds image data only. A chunk outside IHDR, PLTE, IDAT,
-IEND, tRNS, cHRM, gAMA, sBIT, sRGB, pHYs and bKGD (text chunks, ICC profiles,
-Exif, timestamps, private chunks) fails verification. The harness writers drop
-those chunks before writing a frame.
+A screenshot is a PNG or, at a path ending `.webp`, a lossless WebP. A PNG
+screenshot is non-interlaced, its first chunk is a 13-byte IHDR, its IEND is
+empty, and it holds image data only. A chunk outside IHDR, PLTE, IDAT, IEND,
+tRNS, cHRM, gAMA, sBIT, sRGB, pHYs and bKGD (text chunks, ICC profiles, Exif,
+timestamps, private chunks) fails verification. The harness writers drop those
+chunks before writing a frame. A WebP screenshot is the simple lossless form: a
+RIFF container holding one VP8L chunk that ends the file, with version 0 and
+dimensions under the PNG pixel cap. The extended form (VP8X), which carries Exif,
+XMP, ICC profiles and animation, fails verification. Verify reads a WebP's
+structure without decoding its pixels, so a WebP frame is always full-fidelity
+evidence: only a PNG in the redactor's shape counts as blurred. Earlier humanish
+versions do not accept WebP screenshots. A computer-use participant writes each
+frame as PNG during its session. When the session ends, its trace references
+the lossless WebP of each frame encoded by then in place of its PNG, and the run
+removes those PNGs once its final bundle is written. A study that blurs its
+screenshots keeps PNG frames, and an interrupted run can hold both files of a
+frame, with run.json's live trace naming the PNG.
 
 The public-safety scan classifies a run file by its bytes, not its name. It scans
 a file for secret and path patterns only when the bytes are strict UTF-8 with no
@@ -1175,7 +1187,8 @@ Its `derivation.json` uses schema `humanish.redacted-derivation.v1` and records:
   rows, sorted by path using JavaScript string order;
 - `files[]`: source-relative `path`, `sourceSha256`, action (`copied`, `updated`,
   `blurred`, or `omitted`), and `outputSha256` for retained files or a reason for
-  omission;
+  omission; `outputPath` when the copy holds the file at another path, as it does a
+  WebP frame;
 - `generated[]`: paths and SHA256s of rebuilt Observer projections.
 
 The receipt describes the transformation; it does not attest that a participant's
@@ -1195,11 +1208,16 @@ An id that appears only in free text, in a run with no receipts, is not known to
 export. `sandbox-receipts.ndjson` is omitted, and the source keeps its raw ids,
 which reclaim reads.
 
-PNG files that actor traces reference as stream screenshots are re-encoded as
-blurred thumbnails. A PNG that nothing in `run.json` cites is omitted and
-inventoried. Export refuses a run whose feedback candidates, adapter artifacts or
-stream artifact entries cite a PNG that is not a stream screenshot, since verify
-cannot read that image and dropping it would change the evidence.
+PNG and WebP files that actor traces reference as stream screenshots are
+re-encoded as blurred PNG thumbnails. A WebP frame's thumbnail is written at the
+same path ending `.png`, and the copy's actor traces, stream artifacts, feedback
+evidence and adapter artifacts name that path. Export refuses a run that already
+holds a file at that path, and a run whose other copied text names the WebP frame,
+since the copy could not resolve that reference. An image that nothing in
+`run.json` cites is omitted and inventoried. Export refuses a run whose feedback
+candidates, adapter artifacts or stream artifact entries cite an image that is not
+a stream screenshot, since verify cannot read that image and dropping it would
+change the evidence.
 Known actor screenshot declarations describe export-time blur while retaining the
 original redaction notes. Observer is rebuilt; old feedback outputs, local process
 status and the operational sandbox journal are omitted and inventoried. A derivative

package/docs/contracts/schemas.md

@@ -76,17 +76,17 @@ map each one to its v3 key.
 A study declares its route and composes code primitives; it is not a hardcoded kind. The
 top-level keys:
 
-| Key                                                               | Meaning                                                                                                                                                                       |
-| ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `schema`, `id`, `title`, `description`                            | the document's identity                                                                                                                                                       |
-| `route`                                                           | required: `preview`, `computer-use`, `shared-world`, `terminal` or `scripted`                                                                                                 |
-| `mode`                                                            | `dry-run` (the default) or `live`                                                                                                                                             |
-| `actor`                                                           | who drives it, one object: `type`, `model`, `localAgent`, `persona`, `mission`, `tasks`, `maxOutputTokens`, `maxWaitMs`, `idleWaitMs`, `reasoningEffort`, `stopWhen`, `dwell` |
-| `participants`                                                    | a count, a homogeneous `{ count, instruction }`, or a list of entries (below)                                                                                                 |
-| `surfaces`                                                        | scripted only: `[desktop]` or `[desktop, mobile]`                                                                                                                             |
-| `caps`                                                            | the route's budget (below)                                                                                                                                                    |
-| `scenario`                                                        | scripted only: a committed scenario id or path                                                                                                                                |
-| `subject`, `execution`, `policies`, `review`, `defaults`, `comms` | as below                                                                                                                                                                      |
+| Key                                                               | Meaning                                                                                                                                                                                      |
+| ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `schema`, `id`, `title`, `description`                            | the document's identity                                                                                                                                                                      |
+| `route`                                                           | required: `preview`, `computer-use`, `shared-world`, `terminal` or `scripted`                                                                                                                |
+| `mode`                                                            | `dry-run` (the default) or `live`                                                                                                                                                            |
+| `actor`                                                           | who drives it, one object: `type`, `model`, `localAgent`, `persona`, `mission`, `tasks`, `maxOutputTokens`, `maxWaitMs`, `idleWaitMs`, `reasoningEffort`, `serviceTier`, `stopWhen`, `dwell` |
+| `participants`                                                    | a count, a homogeneous `{ count, instruction }`, or a list of entries (below)                                                                                                                |
+| `surfaces`                                                        | scripted only: `[desktop]` or `[desktop, mobile]`                                                                                                                                            |
+| `caps`                                                            | the route's budget (below)                                                                                                                                                                   |
+| `scenario`                                                        | scripted only: a committed scenario id or path                                                                                                                                               |
+| `subject`, `execution`, `policies`, `review`, `defaults`, `comms` | as below                                                                                                                                                                                     |
 
 The parser reads only the declared route's keys. A key that route never reads is an error that
 names the route, such as "route: computer-use does not read scenario. Remove it.", and an
@@ -1148,6 +1148,14 @@ Core-owned fields:
   is part of who the participant was rather than of how the instrument was tuned
   (docs/principles/actor-fidelity.md), so a trace without it is a result missing
   half its sample description
+- optional `modelSettings.serviceTier`: `fast` when the study declared
+  `actor.serviceTier: fast`, so every first-party OpenAI CUA request carried
+  `service_tier: "fast"` (OpenAI Fast mode). Absent when undeclared. Each
+  `tokenUsage.turns[]` record of such a trace has `serviceTier`, the tier the
+  response says served it: `priority` or `fast` bill at the model's Fast mode rate
+  in `src/run/pricing.ts`, and `default`, which OpenAI serves when Fast mode
+  traffic ramps too fast, bills at the standard rate. `estimatedCost.breakdown.fastTurns`
+  counts the requests priced at the fast rate.
 - optional `modelSettings.maxOutputTokens`: the declared positive integer
   `actor.maxOutputTokens`, passed to every first-party OpenAI CUA response
   request, including reasoning output. Absent when undeclared. The first request

package/docs/contracts/study-analysis.md

@@ -314,8 +314,8 @@ stopped, an operator can remove the empty lock directory and retry.
 
 ## Evidence and findings
 
-Each request's packet admits up to 16 participants, 800 evidence items, 40 PNG
-captures, 160 KiB of text and 20 MiB of images. Individual source files, image
+Each request's packet admits up to 16 participants, 800 evidence items, 40
+captures (PNG or lossless WebP), 160 KiB of text and 20 MiB of images. Individual source files, image
 dimensions and result sizes have separate limits. Analysis reads run.json up to
 16 MiB and each participant's trace up to 32 MiB, as verify and the Observer do.
 It reads the traces one at a time and keeps of each only what selection can

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.146.0",
+  "version": "0.147.0",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",
@@ -105,6 +105,7 @@
     "site:hero:proof": "node scripts/site-hero-wrap-proof.mjs"
   },
   "dependencies": {
+    "@jsquash/webp": "1.5.0",
     "commander": "^15.0.0",
     "parse5": "^8.0.1",
     "playwright-core": "^1.63.0",