humanish 0.145.0 → 0.147.0

package/CHANGELOG.md

@@ -8,6 +8,27 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.147.0: Screenshots take half the space (2026-10-25)
+
+humanish 0.147.0 keeps a computer-use participant's screenshots as lossless WebP, 0.47 to 0.55 of
+the PNG size with the same pixels, and `verify`, study analysis and export read them; earlier
+humanish versions refuse a bundle with WebP screenshots. `actor.serviceTier: fast` runs OpenAI
+computer-use participants in Fast mode. On the Taskly benchmark a Fast mode step took 14% less
+time at 2.15 times the participant cost, and each request is priced at the tier that served it.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.147.0)
+
+## 0.146.0: Studies start and finish sooner (2026-10-23)
+
+humanish 0.146.0 cuts the wait around a hosted study. A Chrome participant starts once its page
+has loaded, in place of a fixed 8 s sleep, and a remote run sets up its runner and returns its
+evidence faster; on a one-participant study, desktop to session start fell from about 29 s to 11
+to 18 s, and a remote run's overhead from 17.8 s to about 10 s. An analysis request that runs out
+of output is sent again once within its cost cap, and a low- or medium-effort analysis asks for an
+output limit sized to its participants, so a runaway request stops sooner.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.146.0)
+
 ## 0.145.0: A remote runner's keys stay in E2B's proxy (2026-10-22)
 
 humanish 0.145.0 keeps the OpenAI, Gemini and E2B keys out of a remote E2B runner's environment.

package/dist/actors/computer-use/loop/spend.js

@@ -58,11 +58,12 @@ export function bookLostRequest(session, turnNumber, lost) {
     }
     const input = session.usage.lastReportedInput();
     session.usage.reserve(input, maxOutputTokens);
+    const serviceTier = session.provider.modelSettings?.serviceTier;
+    const booked = { input, output: maxOutputTokens, cachedInput: 0, cacheWriteInput: input };
     const usd = session.settings.estimateTurnCostUsd?.({
-        input,
-        output: maxOutputTokens,
-        cachedInput: 0,
-        cacheWriteInput: input,
+        ...booked,
+        // A request in Fast mode is booked at the fast rate, which a per-request record selects.
+        ...(serviceTier === undefined ? {} : { turns: [{ ...booked, serviceTier }] }),
     });
     const charge = `${input} input tokens at the highest input rate and ${maxOutputTokens} output tokens${typeof usd === "number" ? ` ($${usd})` : ""}`;
     const over = spendStop(session);

package/dist/actors/computer-use/loop/trace.js

@@ -127,6 +127,9 @@ export function loopResult(session, stop, debrief) {
                     ...(provider.modelSettings.maxOutputTokens === undefined
                         ? {}
                         : { maxOutputTokens: provider.modelSettings.maxOutputTokens }),
+                    ...(provider.modelSettings.serviceTier === undefined
+                        ? {}
+                        : { serviceTier: provider.modelSettings.serviceTier }),
                 },
             }),
         waitSettings: {

package/dist/actors/computer-use/loop/types.d.ts

@@ -191,12 +191,15 @@ export interface CuaTurn {
         output?: number;
         cachedInput?: number;
         cacheWriteInput?: number;
+        /** The processing tier that served this request, when the session asked for one. */
+        serviceTier?: string;
         /** Per model inference inside this provider interaction. */
         turns?: Array<{
             input?: number;
             output?: number;
             cachedInput?: number;
             cacheWriteInput?: number;
+            serviceTier?: string;
         }>;
     };
     /** True when the model reported a natural endpoint (no further action). */
@@ -234,6 +237,8 @@ export interface CuaProvider {
     readonly modelSettings?: {
         readonly reasoningEffort: ReasoningEffort;
         readonly maxOutputTokens?: number;
+        /** The processing tier every request asks for; absent asks for none. */
+        readonly serviceTier?: "fast";
     };
     readonly capabilities: ActorCapabilities;
     /**

package/dist/actors/computer-use/loop/usage.js

@@ -14,12 +14,19 @@ function normalizedUsageTurns(usage) {
             return undefined;
         if ((raw.cachedInput ?? 0) + (raw.cacheWriteInput ?? 0) > (raw.input ?? 0))
             return undefined;
-        turns.push(Object.fromEntries(fields.flatMap((field) => (raw[field] === undefined ? [] : [[field, raw[field]]]))));
+        turns.push({
+            ...Object.fromEntries(fields.flatMap((field) => (raw[field] === undefined ? [] : [[field, raw[field]]]))),
+            ...servedTier(raw.serviceTier),
+        });
     }
     return fields.every((field) => turns.reduce((sum, turn) => sum + (turn[field] ?? 0), 0) === (usage[field] ?? 0))
         ? turns
         : undefined;
 }
+/** The served-tier field of a usage record, kept only when the provider named one. */
+function servedTier(tier) {
+    return typeof tier === "string" && tier !== "" ? { serviceTier: tier } : {};
+}
 export function isCompleteTurnUsage(usage) {
     return (usage !== undefined &&
         validTokenCount(usage.input) &&
@@ -130,7 +137,7 @@ export class UsageLedger {
         this.cacheWriteInput += usage.cacheWriteInput ?? 0;
         this.output += usage.output ?? 0;
         if (raw.turns === undefined)
-            this.turns.push(usage);
+            this.turns.push({ ...usage, ...servedTier(raw.serviceTier) });
         else if (turns !== undefined)
             this.turns.push(...turns);
     }
@@ -218,6 +225,7 @@ export class UsageLedger {
             output,
             cachedInput: 0,
             cacheWriteInput: input,
+            ...servedTier(this.provider.modelSettings?.serviceTier),
         }));
         const sum = (field) => booked.reduce((total, turn) => total + turn[field], 0);
         const input = (settled.input ?? 0) + sum("input");

package/dist/actors/computer-use/openai-conversation.d.ts

@@ -8,6 +8,8 @@ export interface OpenAiConversationSettings {
     readonly reasoningEffort: ReasoningEffort;
     readonly maxOutputTokens?: number;
     readonly safetyIdentifier?: string;
+    /** OpenAI Fast mode for every request of the session. */
+    readonly serviceTier?: "fast";
     /** The summaries to ask for until the account or model rejects them; undefined asks for none. */
     readonly reasoningSummary: OpenAiReasoningSummary | undefined;
     /** Carry the conversation on the client from the first request (explicit_context). */
@@ -98,6 +100,11 @@ export declare class OpenAiConversation {
      */
     private waitOutcome;
     private context;
+    /**
+     * A reply, parsed. When the session asked for a tier, the reply's usage records the tier that
+     * served it, which is what the request bills at: Fast mode can fall back to `default`.
+     */
+    private parse;
     /**
      * A participant request: the opening request, or a continuation carrying `sent`. A threaded
      * continuation names the previous response; an explicit-context one carries the conversation

package/dist/actors/computer-use/openai-conversation.js

@@ -75,7 +75,7 @@ export class OpenAiConversation {
         if (closing === "impressions")
             this.evidence.requested(this.mode, this.carried, sent, closing);
         const completed = asRecord(reply).status === "completed";
-        const parsed = parseOpenAiResponse(reply);
+        const parsed = this.parse(reply);
         const account = completed ? closingAccount(parsed.turn.message, closing, strict) : undefined;
         // A refusal would most likely stand under the strict schema too, so it is not asked again.
         if (completed && account === undefined && !strict && !refused(reply)) {
@@ -164,6 +164,23 @@ export class OpenAiConversation {
             ...(settings.safetyIdentifier === undefined
                 ? {}
                 : { safetyIdentifier: settings.safetyIdentifier }),
+            ...(settings.serviceTier === undefined ? {} : { serviceTier: settings.serviceTier }),
+        };
+    }
+    /**
+     * A reply, parsed. When the session asked for a tier, the reply's usage records the tier that
+     * served it, which is what the request bills at: Fast mode can fall back to `default`.
+     */
+    parse(reply) {
+        const parsed = parseOpenAiResponse(reply);
+        const { usage } = parsed.turn;
+        if (this.settings.serviceTier === undefined || usage === undefined)
+            return parsed;
+        if (parsed.serviceTier === undefined)
+            return parsed;
+        return {
+            ...parsed,
+            turn: { ...parsed.turn, usage: { ...usage, serviceTier: parsed.serviceTier } },
         };
     }
     /**
@@ -204,7 +221,7 @@ export class OpenAiConversation {
         // Recorded before the reply is accepted: accepting can cut the carried history, and the record
         // counts what this request carried.
         this.evidence.requested(this.mode, this.carried, sent);
-        const parsed = parseOpenAiResponse(reply);
+        const parsed = this.parse(reply);
         if (parsed.turn.interruption === "output_limit")
             return parsed.turn;
         this.moveOn(parsed, sent);

package/dist/actors/computer-use/openai-provider.d.ts

@@ -68,6 +68,8 @@ export interface OpenAiResponsesProviderOptions {
     reasoningEffort?: ReasoningEffort;
     /** Optional positive integer output limit per response, including reasoning. Not a spend cap. */
     maxOutputTokens?: number;
+    /** OpenAI Fast mode on every request; absent sends no `service_tier`. */
+    serviceTier?: "fast";
     /**
      * Reasoning-summary capture. Defaults to "auto" (the provider picks the best
      * summarizer the model supports); "off" never asks. If the account/model rejects the

package/dist/actors/computer-use/openai-provider.js

@@ -418,6 +418,7 @@ export function createOpenAiResponsesProvider(options) {
         ...(options.safetyIdentifier === undefined
             ? {}
             : { safetyIdentifier: options.safetyIdentifier }),
+        ...(options.serviceTier === undefined ? {} : { serviceTier: options.serviceTier }),
         reasoningSummary: options.reasoningSummary === "off" ? undefined : (options.reasoningSummary ?? "auto"),
         zeroDataRetention: options.zeroDataRetention === true,
         now: options.now ?? Date.now,
@@ -471,6 +472,7 @@ export function createOpenAiResponsesProvider(options) {
         modelSettings: {
             reasoningEffort,
             ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+            ...(options.serviceTier === undefined ? {} : { serviceTier: options.serviceTier }),
         },
         capabilities: OPENAI_RESPONSES_CU_CAPABILITIES,
         // This is a vision provider: nextTurn sends the screenshot as the computer_call_output, so

package/dist/actors/computer-use/openai-wire.d.ts

@@ -15,6 +15,8 @@ export interface ParsedOpenAiResponse {
     /** The function calls, in reply order, each owed a function_call_output. */
     functionCalls: FunctionCall[];
     outputItems: unknown[];
+    /** The processing tier the reply says served it (`service_tier`), when it says one. */
+    serviceTier?: string;
 }
 /** A function call a reply made: its id, and its name, which is WAIT_TOOL_NAME unless it erred. */
 export interface FunctionCall {
@@ -52,6 +54,8 @@ export interface OpenAiCuContext {
     /** When set, request provider-sanctioned reasoning summaries. Absent = do not ask. */
     reasoningSummary?: OpenAiReasoningSummary;
     safetyIdentifier?: string;
+    /** OpenAI Fast mode (`service_tier: "fast"`). Absent sends no tier: the project's default. */
+    serviceTier?: "fast";
 }
 /**
  * Build the first-turn request body: the instructions and the first screen, so the first decision

package/dist/actors/computer-use/openai-wire.js

@@ -271,7 +271,14 @@ export function parseOpenAiResponse(raw) {
         ...(message.length > 0 ? { message } : {}),
         ...(usage === undefined ? {} : { usage }),
     };
-    return { turn, callIds, functionCalls, outputItems: output };
+    const serviceTier = optionalString(root.service_tier);
+    return {
+        turn,
+        callIds,
+        functionCalls,
+        outputItems: output,
+        ...(serviceTier === undefined ? {} : { serviceTier }),
+    };
 }
 /**
  * A function the participant names its wait length with; the computer tool's `wait` names none.
@@ -324,6 +331,7 @@ function sharedRequestFields(ctx) {
             ...(ctx.reasoningSummary === undefined ? {} : { summary: ctx.reasoningSummary }),
         },
         ...(ctx.safetyIdentifier === undefined ? {} : { safety_identifier: ctx.safetyIdentifier }),
+        ...(ctx.serviceTier === undefined ? {} : { service_tier: ctx.serviceTier }),
         ...(ctx.stateless === true ? { store: false, include: ["reasoning.encrypted_content"] } : {}),
     };
 }

package/dist/actors/contract.d.ts

@@ -187,6 +187,10 @@ export interface ActorTokenUsage {
         cachedInput?: number;
         cacheWriteInput?: number;
         output?: number;
+        /** The processing tier the provider reported serving this request at (OpenAI `service_tier`:
+         *  `default`, `priority`, `fast`). Recorded when the participant asked for a tier; Fast mode
+         *  can fall back to `default`, which bills the standard rate. */
+        serviceTier?: string;
     }>;
     total?: number;
     costUsd?: number;
@@ -364,6 +368,7 @@ export interface ActorTrace {
     modelSettings?: {
         reasoningEffort: string;
         maxOutputTokens?: number;
+        serviceTier?: string;
     };
     /**
      * Additive + optional: the wait lengths the computer-use loop applied, defaults included. Absent

package/dist/analysis/admission.d.ts

@@ -30,14 +30,19 @@ export interface AnalysisRequests {
     /** The analyst's EXPECTED_OUTPUT_SCALE; 1 when omitted. */
     outputScale?: number;
 }
-export interface AnalysisCostEstimate {
-    inputTokens: number;
-    expectedOutputTokens: number;
+/** What one request is expected to cost, its worst case, and the figure admission compares. */
+export interface RequestCost {
     expectedCostUsd: number;
     worstCaseCostUsd: number;
     /** The expected cost with the margin, never above the worst case: what admission compares. */
     admittedCostUsd: number;
 }
+export interface AnalysisCostEstimate extends RequestCost {
+    inputTokens: number;
+    expectedOutputTokens: number;
+    /** Each request's own costs: the cohorts' in order, then the merge request's. */
+    requests: RequestCost[];
+}
 /**
  * Every request of one analysis, summed. A merge request reads each cohort's report, priced at
  * that request's whole output allowance since the report and its reasoning share it, and is

package/dist/analysis/admission.js

@@ -85,11 +85,15 @@ export function estimateAnalysisCost(rate, requests) {
     return {
         inputTokens: sum("inputTokens"),
         expectedOutputTokens: sum("expectedOutputTokens"),
-        expectedCostUsd,
-        worstCaseCostUsd,
-        admittedCostUsd: Math.min(worstCaseCostUsd, roundUp(expectedCostUsd * ADMISSION_MARGIN)),
+        ...admitted(expectedCostUsd, worstCaseCostUsd),
+        requests: estimates.map((estimate) => admitted(estimate.expectedCostUsd, estimate.worstCaseCostUsd)),
     };
 }
+const admitted = (expectedCostUsd, worstCaseCostUsd) => ({
+    expectedCostUsd,
+    worstCaseCostUsd,
+    admittedCostUsd: Math.min(worstCaseCostUsd, roundUp(expectedCostUsd * ADMISSION_MARGIN)),
+});
 /**
  * Words a cost refusal. `runFlags` are the `analyze` flags that select the run, such as
  * `--run <id>`. `cli` prefixes a humanish command: the CLI passes `cli` from

package/dist/analysis/automatic-config.js

@@ -1,5 +1,6 @@
 import { CODEX_ANALYSIS_MODEL, codexAnalysisIdentity } from "./codex-config.js";
-import { DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS, MAX_ANALYSIS_OUTPUT_TOKENS, analysisCostRange, } from "./execute.js";
+import { analysisCostRange } from "./execute.js";
+import { DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS, MAX_ANALYSIS_OUTPUT_TOKENS } from "./output-limit.js";
 import { analysisEffort, analysisEfforts, isSupportedAnalysisModel } from "./models.js";
 import { isReasoningEffort } from "../actors/reasoning-effort.js";
 import { admissionRule } from "./admission.js";

package/dist/analysis/automatic.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { resolveRunPath } from "../run/locate.js";
 import { refreshObserver, analyzeRun, readCompletedAnalysisSource, resolveAnalysisRun, } from "./service.js";
-import { preferLargerAnalysisOutput, ANALYSIS_PROMPT_VERSION } from "./execute.js";
+import { defaultAnalysisOutput, ANALYSIS_PROMPT_VERSION } from "./execute.js";
 import { captureEvidence } from "./evidence.js";
 import { analysisApiKey } from "../keys/key-resolution.js";
 import { loadRunTraces } from "../run/stream-trace.js";
@@ -103,7 +103,7 @@ async function readAutomaticSource(cwd, prepared, configInput, deps, hasKey) {
             deps.preferLargerOutput &&
             (!deps.defaultRequest || participantEvidence) &&
             hasKey) {
-            config = preferLargerAnalysisOutput(await captureEvidence(prepared, bytes), config);
+            config = defaultAnalysisOutput(await captureEvidence(prepared, bytes), config);
         }
         return { participantEvidence, config };
     }

package/dist/analysis/evidence.js

@@ -348,13 +348,13 @@ function packEvidence(selected, packings, textByEntry, evidence, images) {
                     eventId: source.eventId,
                     path: source.capturePath,
                     sha256: sha256(bytes),
-                    mimeType: "image/png",
+                    mimeType: captureMimeType(source.capturePath),
                 }
                 : null;
-            if (bytes)
+            if (capture)
                 images.push({
                     evidenceId: id,
-                    dataUrl: `data:image/png;base64,${bytes.toString("base64")}`,
+                    dataUrl: `data:${capture.mimeType};base64,${bytes.toString("base64")}`,
                 });
             evidence.push({
                 id,
@@ -448,7 +448,7 @@ export async function validateAnalysisEvidence(prepared, artifact, bundleBytes)
             if (source.capturePath === null ||
                 entry.capture.path !== source.capturePath ||
                 entry.capture.eventId !== source.eventId ||
-                entry.capture.mimeType !== "image/png")
+                entry.capture.mimeType !== captureMimeType(source.capturePath))
                 throw new Error("ANALYSIS_CAPTURE_REFERENCE_INVALID");
             let hash = checkedCaptures.get(source.capturePath);
             if (hash === undefined) {
@@ -474,3 +474,7 @@ export async function validateAnalysisEvidence(prepared, artifact, bundleBytes)
     if (!current?.equals(bundleBytes))
         throw new Error("ANALYSIS_SOURCE_CHANGED");
 }
+/** A capture's image type, from the extension screenshotEvidenceError checked it against. */
+function captureMimeType(capturePath) {
+    return capturePath.toLowerCase().endsWith(".webp") ? "image/webp" : "image/png";
+}

package/dist/analysis/execute.d.ts

@@ -2,10 +2,6 @@ import { type AnalysisArtifact, type AnalysisConfig, type AnalysisInput } from "
 import { type AnalysisFetch, type AnalysisProvider } from "./provider.js";
 import type { RejectedAnalysisOutput } from "./diagnostics.js";
 export declare const ANALYSIS_PROMPT_VERSION = "study-evidence-8";
-/** The API output limit when a study omits maxOutputTokens, and the most it may ask for. Gemini 4
- * returns at most 32,768 output tokens from one generateContent request. */
-export declare const DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS = 16384;
-export declare const MAX_ANALYSIS_OUTPUT_TOKENS = 32768;
 export interface AnalysisAdmission {
     allowed: boolean;
     error: string | null;
@@ -65,14 +61,15 @@ export type AnalysisCostRange = {
  * the image-token ceiling, and the range ends at the largest one admission admits, so it never
  * passes the cap. There is one packet per cohort, each a share of its own limits, and the merge
  * request when there is more than one cohort. With `preferLargerOutput` each request gets the
- * output allowance dispatch would give it (preferLargerAnalysisOutput). Undefined for Codex and
- * for a model without rates.
+ * output allowance dispatch would give it (defaultAnalysisOutput). Undefined for Codex and for a
+ * model without rates.
  */
 export declare function analysisCostRange(config: AnalysisConfig, participants: number, preferLargerOutput?: boolean): AnalysisCostRange | undefined;
-/** Only for an omitted output limit. Preserve the established allowance when
- * more reasoning/report space would refuse a study its declared budget admits.
- * This is one pre-dispatch choice, never a fallback request or a budget increase. */
-export declare function preferLargerAnalysisOutput(input: AnalysisInput, config: AnalysisConfig): AnalysisConfig;
+/** Only for an omitted output limit, which configuration fills with the 16,384-token default.
+ * Gives the analysis the allowance sized to its participants, effort and analyst, and keeps the
+ * default when a larger sized allowance would refuse a study its declared budget admits. This is
+ * one pre-dispatch choice, never a fallback request or a budget increase. */
+export declare function defaultAnalysisOutput(input: AnalysisInput, config: AnalysisConfig): AnalysisConfig;
 export type AnalysisDispatchContext = Pick<AnalysisArtifact, "id" | "runId" | "sourceRunSha256" | "inputDigest" | "configDigest" | "promptVersion">;
 interface RunAnalysisOptions {
     apiKey?: string;

package/dist/analysis/execute.js

@@ -1,6 +1,6 @@
 import { validCodexAnalysisConfig } from "./codex-config.js";
 import { INPUT_IMAGE_DATA_URL, highDetailImageTokens, imageTokenCeiling } from "./image-tokens.js";
-import { EXPECTED_OUTPUT_SCALE, estimateAnalysisCost } from "./admission.js";
+import { EXPECTED_OUTPUT_SCALE, estimateAnalysisCost, } from "./admission.js";
 import { createHash, randomUUID } from "node:crypto";
 import { modelRate } from "../run/pricing.js";
 import { containsSensitive } from "../evidence/redaction.js";
@@ -13,11 +13,9 @@ import { analysisCohorts, analysisRequestCount, EVIDENCE_LIMITS } from "./analys
 import { checkMergedResponse, cohortInputs, mergePacket, mergeResultJsonSchema, } from "./cohorts.js";
 import { checkProviderAnalysis, codexWarnings, httpStatusWarning, recordProviderUsage, } from "./responses.js";
 import { mapWithConcurrency } from "../run/concurrency.js";
+import { outputRetries } from "./output-retry.js";
+import { DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS, defaultOutputTokens } from "./output-limit.js";
 export const ANALYSIS_PROMPT_VERSION = "study-evidence-8";
-/** The API output limit when a study omits maxOutputTokens, and the most it may ask for. Gemini 4
- * returns at most 32,768 output tokens from one generateContent request. */
-export const DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS = 16_384;
-export const MAX_ANALYSIS_OUTPUT_TOKENS = 32_768;
 const MAX_EVIDENCE_BYTES = 1024 * 1024;
 /**
  * Cohort requests in flight at once. OpenAI's lowest paid tier allows gpt-6-astra 1,000,000 tokens
@@ -214,21 +212,7 @@ export function estimateAnalysisAdmission(input, config) {
         !Number.isFinite(rate.outputUsdPerToken) ||
         rate.outputUsdPerToken < 0)
         return denied("analysis_rate_unknown");
-    const { maxOutputTokens } = config;
-    const cost = estimateAnalysisCost(rate, {
-        cohorts: cohortInputs(input).map((cohort) => {
-            const request = cohortRequest(cohort, config);
-            return {
-                textBytes: requestBytes(request),
-                imageTokens: request.images.reduce((sum, image) => sum + highDetailImageTokens(config.model, image.dataUrl), 0),
-                participants: cohort.participants.length,
-                outputAllowance: maxOutputTokens,
-            };
-        }),
-        // Without reports: estimateAnalysisCost prices them at the cohorts' output allowances.
-        mergeTextBytes: requestBytes(mergeRequest(input, config, [])),
-        outputScale: EXPECTED_OUTPUT_SCALE[config.provider ?? "openai"],
-    });
+    const cost = analysisCost(input, config, rate);
     if (!Number.isFinite(cost.worstCaseCostUsd))
         return denied("analysis_rate_unknown");
     const allowed = cost.admittedCostUsd <= config.maxCostUsd;
@@ -245,6 +229,24 @@ export function estimateAnalysisAdmission(input, config) {
         requests,
     };
 }
+/** Every request of an API analysis priced at `rate`: each cohort's, then the merge request's. */
+function analysisCost(input, config, rate) {
+    const { maxOutputTokens } = config;
+    return estimateAnalysisCost(rate, {
+        cohorts: cohortInputs(input).map((cohort) => {
+            const request = cohortRequest(cohort, config);
+            return {
+                textBytes: requestBytes(request),
+                imageTokens: request.images.reduce((sum, image) => sum + highDetailImageTokens(config.model, image.dataUrl), 0),
+                participants: cohort.participants.length,
+                outputAllowance: maxOutputTokens,
+            };
+        }),
+        // Without reports: estimateAnalysisCost prices them at the cohorts' output allowances.
+        mergeTextBytes: requestBytes(mergeRequest(input, config, [])),
+        outputScale: EXPECTED_OUTPUT_SCALE[config.provider ?? "openai"],
+    });
+}
 /** Structure each evidence entry adds to the packet: ids, kind, timestamps and flags. The largest
  * retained packet averaged 200 bytes. A merge packet's participant entry is smaller. */
 const ENTRY_STRUCTURE_BYTES = 256;
@@ -276,8 +278,8 @@ const RANGE_BISECTIONS = 40;
  * the image-token ceiling, and the range ends at the largest one admission admits, so it never
  * passes the cap. There is one packet per cohort, each a share of its own limits, and the merge
  * request when there is more than one cohort. With `preferLargerOutput` each request gets the
- * output allowance dispatch would give it (preferLargerAnalysisOutput). Undefined for Codex and
- * for a model without rates.
+ * output allowance dispatch would give it (defaultAnalysisOutput). Undefined for Codex and for a
+ * model without rates.
  */
 export function analysisCostRange(config, participants, preferLargerOutput = false) {
     if (config.provider === "codex")
@@ -324,13 +326,16 @@ export function analysisCostRange(config, participants, preferLargerOutput = fal
         }
         return admitted;
     };
-    // Dispatch tries the larger allowance first. A smaller allowance costs no more, so it admits at
-    // least the same share, and the packets past the larger one's share get the smaller one.
-    const larger = preferLargerOutput ? largerOutput(config) : undefined;
-    const allowances = [
-        ...(larger === undefined ? [] : [larger.maxOutputTokens]),
-        config.maxOutputTokens,
-    ];
+    // Dispatch tries the sized allowance first. When it is the larger one, the smaller allowance
+    // costs no more, so it admits at least the same share, and the packets past the sized one's
+    // share get the smaller one. A sized allowance below the configured one is never refused where
+    // the configured one is admitted.
+    const sized = preferLargerOutput ? defaultOutput(config, covered) : undefined;
+    const allowances = sized === undefined
+        ? [config.maxOutputTokens]
+        : sized.maxOutputTokens < config.maxOutputTokens
+            ? [sized.maxOutputTokens]
+            : [sized.maxOutputTokens, config.maxOutputTokens];
     const admitted = allowances.filter((allowance) => admits(0, allowance));
     if (admitted.length === 0)
         return { refusedFromUsd: request(0, config.maxOutputTokens).expectedCostUsd };
@@ -341,20 +346,23 @@ export function analysisCostRange(config, participants, preferLargerOutput = fal
         },
     };
 }
-/** The larger output allowance an omitted output limit may get, or undefined when it may not. */
-function largerOutput(config) {
-    if (config.provider === "codex" || config.maxOutputTokens !== DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS)
+/** The output allowance sized for an omitted output limit (output-limit.ts), or undefined when the
+ * limit was declared. */
+function defaultOutput(config, participants) {
+    const tokens = defaultOutputTokens(config, participants);
+    if (config.provider === "codex" ||
+        tokens === undefined ||
+        config.maxOutputTokens !== DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS)
         return undefined;
-    return { ...config, maxOutputTokens: MAX_ANALYSIS_OUTPUT_TOKENS };
+    return { ...config, maxOutputTokens: tokens };
 }
-/** Only for an omitted output limit. Preserve the established allowance when
- * more reasoning/report space would refuse a study its declared budget admits.
- * This is one pre-dispatch choice, never a fallback request or a budget increase. */
-export function preferLargerAnalysisOutput(input, config) {
-    const expanded = largerOutput(config);
-    return expanded !== undefined && estimateAnalysisAdmission(input, expanded).allowed
-        ? expanded
-        : config;
+/** Only for an omitted output limit, which configuration fills with the 16,384-token default.
+ * Gives the analysis the allowance sized to its participants, effort and analyst, and keeps the
+ * default when a larger sized allowance would refuse a study its declared budget admits. This is
+ * one pre-dispatch choice, never a fallback request or a budget increase. */
+export function defaultAnalysisOutput(input, config) {
+    const sized = defaultOutput(config, input.coverage.includedStreamIds.length);
+    return sized !== undefined && estimateAnalysisAdmission(input, sized).allowed ? sized : config;
 }
 /** Check the caller's id, input metadata and admission; throw the stable code a direct caller receives. */
 function admitDirectAnalysis(input, config, analysisId) {
@@ -423,14 +431,15 @@ async function analysisProvider(config, options) {
  * The attempt's requests: one per cohort, `COHORT_CONCURRENCY` at a time (one at a time for Codex),
  * then the merge request for more than one cohort. After one request fails no further request
  * starts, and the first failure in cohort order is the attempt's, with its cohort. `notSent` means
- * cancellation stopped a request from starting.
+ * cancellation stopped a request from starting. `send` gets each request's index: its cohort's,
+ * and the cohort count for the merge request.
  */
 async function requestReport(cohorts, input, config, send, signal) {
     let stopped = false;
-    const outcomes = await mapWithConcurrency([...cohorts], config.provider === "codex" ? 1 : COHORT_CONCURRENCY, async (cohort) => {
+    const outcomes = await mapWithConcurrency([...cohorts], config.provider === "codex" ? 1 : COHORT_CONCURRENCY, async (cohort, index) => {
         if (stopped || signal?.aborted)
             return undefined;
-        const outcome = await send(cohortRequest(cohort, config), cohort);
+        const outcome = await send(cohortRequest(cohort, config), cohort, index);
         if (!outcome.ok)
             stopped = true;
         return outcome;
@@ -446,7 +455,16 @@ async function requestReport(cohorts, input, config, send, signal) {
     if (signal?.aborted)
         return { ok: false, notSent: true };
     // The merge request sends the cohort reports, no evidence entries or captures.
-    return send(mergeRequest(input, config, reports), { ...input, evidence: [], images: [] });
+    return send(mergeRequest(input, config, reports), { ...input, evidence: [], images: [] }, cohorts.length);
+}
+/** Request `index` of an attempt at the start of a sentence, numbered as requestReport numbers it. */
+function requestName(cohorts, index) {
+    if (cohorts.length === 1)
+        return "The analysis request";
+    if (index === cohorts.length)
+        return `The request that merges the ${cohorts.length} cohort reports`;
+    const total = cohorts.reduce((sum, cohort) => sum + cohort.participants.length, 0);
+    return `The request for one cohort (${cohorts[index].participants.length} of the ${total} participants)`;
 }
 /**
  * Why a run analysed in cohorts has no report, for the attempt's warnings. Null for one request,
@@ -520,7 +538,10 @@ export async function runAnalysis(input, config, options) {
     const provider = await analysisProvider(config, options);
     const cohorts = cohortInputs(input);
     const responses = [];
-    const send = async (request, part) => {
+    const retries = config.provider === "codex"
+        ? undefined
+        : outputRetries(config, analysisCost(input, config, modelRate(config.model)).requests, (index) => requestName(cohorts, index), options.warnings);
+    const dispatch = async (request, part) => {
         progress("requesting", part);
         const response = await provider({
             model: config.model,
@@ -538,6 +559,14 @@ export async function runAnalysis(input, config, options) {
         for (const warning of [...codexWarnings(config, response), httpStatusWarning(config, response)])
             if (warning !== undefined && !options.warnings?.includes(warning))
                 options.warnings?.push(warning);
+        return response;
+    };
+    const send = async (request, part, index) => {
+        let response = await dispatch(request, part);
+        // A request that ran out of output is sent once more while the cap admits it.
+        while (!options.signal?.aborted && retries?.retry(index, response, artifact.usage))
+            response = await dispatch(request, part);
+        retries?.settle(index);
         if (response.status !== "completed")
             return {
                 ok: false,
@@ -569,11 +598,12 @@ export async function runAnalysis(input, config, options) {
     artifact.result = outcome.result;
     artifact.status = input.coverage.complete ? "complete" : "partial";
     artifact.error = null;
-    // A bill above the expected cost is a normal outcome. Only one above the worst case or the cap
-    // shows the estimate was wrong.
+    // A bill above the expected cost is a normal outcome. Only one above the worst case, with the
+    // worst case of each request sent again, or above the cap shows the estimate was wrong.
+    const worstCaseUsd = (admission.worstCaseCostUsd ?? config.maxCostUsd ?? 0) + (retries?.worstCaseUsd() ?? 0);
     if (config.provider !== "codex" &&
         (responses.some((response) => (response.usage?.output ?? 0) > config.maxOutputTokens) ||
-            (artifact.usage.estimatedCostUsd ?? 0) > (admission.worstCaseCostUsd ?? config.maxCostUsd) ||
+            (artifact.usage.estimatedCostUsd ?? 0) > worstCaseUsd ||
             (artifact.usage.estimatedCostUsd ?? 0) > config.maxCostUsd)) {
         artifact.status = "partial";
         artifact.error = "analysis_admission_estimate_exceeded";