humanish 0.144.0 → 0.146.0

package/CHANGELOG.md

@@ -8,6 +8,28 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 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.
+E2B's egress proxy adds each key to the runner's requests on its fixed host, and the runner holds
+placeholders; code in the runner can still read the keys back through the E2B API, and a Modal
+runner still receives them as environment variables. Study analysis with `gpt-6-luna` sends low
+text verbosity, which made it about four times faster on the benchmark recordings, and an
+observation of what a participant said may now also cite the capture they spoke about.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.145.0)
+
 ## 0.144.0: Hosted studies run remotely by default (2026-10-22)
 
 humanish 0.144.0 runs a hosted computer-use study remotely by default. A study on

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/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";

package/dist/analysis/models.d.ts

@@ -1,6 +1,8 @@
 import type { ReasoningEffort } from "../actors/reasoning-effort.js";
 import type { AnalysisApiVendor } from "./provider.js";
 import type { AnalysisConfig } from "./types.js";
+/** The `text.verbosity` an OpenAI analysis with `model` asks for, or undefined for the default. */
+export declare const openaiTextVerbosity: (model: string) => "low" | undefined;
 export declare const SUPPORTED_ANALYSIS_MODELS: readonly string[];
 export declare const GEMINI_ANALYSIS_MODELS: readonly string[];
 /** Whether the API analyst `provider` (omitted is OpenAI) analyzes with `model`. */

package/dist/analysis/models.js

@@ -14,6 +14,21 @@ const OPENAI_MODELS = {
     "gpt-5.6-terra": ["none", "low", "medium", "high", "xhigh", "max"],
     "gpt-5.6-luna": ["none", "low", "medium", "high", "xhigh", "max"],
 };
+/**
+ * The `text.verbosity` the OpenAI wire sends for a model; a model not listed gets the API default,
+ * `medium`. The Responses API takes `low`, `medium` or `high` beside a json_schema `text.format`
+ * (developers.openai.com/api/reference/resources/responses/methods/create, read 2026-10-22). On
+ * the benchmark recordings, gpt-6-luna at low verbosity decoded about three times faster and its
+ * analyses passed the evidence checks more often, with the same findings: see
+ * docs/evidence/benchmark/2026-10-22-luna-verbosity.md.
+ */
+const OPENAI_TEXT_VERBOSITY = {
+    "gpt-6-luna": "low",
+};
+/** The `text.verbosity` an OpenAI analysis with `model` asks for, or undefined for the default. */
+export const openaiTextVerbosity = (model) => Object.hasOwn(OPENAI_TEXT_VERBOSITY, model)
+    ? OPENAI_TEXT_VERBOSITY[model]
+    : undefined;
 /**
  * Gemini models that completed a live analysis, with the `thinkingLevel` values the thinking guide
  * lists for each (ai.google.dev/gemini-api/docs/generate-content/thinking, read 2026-10-21):

package/dist/analysis/openai-wire.d.ts

@@ -2,5 +2,5 @@ import type { AnalysisProviderResult, AnalysisWire } from "./provider.js";
 /** Text and usage wire shapes reuse the captured closing-report contract; refusal fails closed. */
 export declare function parseAnalysisResponse(raw: unknown): AnalysisProviderResult;
 /** One stateless request: no stored response, no tools, the analysis's reasoning effort, strict
- * schema. */
+ * schema, and the model's text verbosity from models.ts. */
 export declare const openaiWire: AnalysisWire;

package/dist/analysis/openai-wire.js

@@ -2,6 +2,7 @@
 // a response becomes an AnalysisProviderResult. provider.ts owns the transport around it.
 import { OPENAI_RESPONSES_URL } from "../actors/openai-endpoint.js";
 import { isRecord } from "../run/type-guards.js";
+import { openaiTextVerbosity } from "./models.js";
 const record = (value) => (isRecord(value) ? value : {});
 const count = (value) => Number.isSafeInteger(value) && value >= 0 && value <= 1e12;
 function usageOf(raw) {
@@ -68,35 +69,44 @@ export function parseAnalysisResponse(raw) {
     }
 }
 /** One stateless request: no stored response, no tools, the analysis's reasoning effort, strict
- * schema. */
+ * schema, and the model's text verbosity from models.ts. */
 export const openaiWire = {
     url: () => OPENAI_RESPONSES_URL,
     headers: (apiKey) => ({ Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" }),
-    body: (request) => ({
-        model: request.model,
-        instructions: request.instructions,
-        input: [
-            {
-                role: "user",
-                content: [
-                    { type: "input_text", text: request.evidence },
-                    ...request.images.flatMap((image) => [
-                        { type: "input_text", text: JSON.stringify({ captureEvidenceId: image.evidenceId }) },
-                        { type: "input_image", image_url: image.dataUrl, detail: "high" },
-                    ]),
-                ],
+    body: (request) => {
+        const verbosity = openaiTextVerbosity(request.model);
+        return {
+            model: request.model,
+            instructions: request.instructions,
+            input: [
+                {
+                    role: "user",
+                    content: [
+                        { type: "input_text", text: request.evidence },
+                        ...request.images.flatMap((image) => [
+                            { type: "input_text", text: JSON.stringify({ captureEvidenceId: image.evidenceId }) },
+                            { type: "input_image", image_url: image.dataUrl, detail: "high" },
+                        ]),
+                    ],
+                },
+            ],
+            store: false,
+            tools: [],
+            tool_choice: "none",
+            truncation: "disabled",
+            service_tier: "default",
+            reasoning: { effort: request.reasoningEffort },
+            max_output_tokens: request.maxOutputTokens,
+            text: {
+                format: {
+                    type: "json_schema",
+                    name: "study_analysis",
+                    strict: true,
+                    schema: request.schema,
+                },
+                ...(verbosity === undefined ? {} : { verbosity }),
             },
-        ],
-        store: false,
-        tools: [],
-        tool_choice: "none",
-        truncation: "disabled",
-        service_tier: "default",
-        reasoning: { effort: request.reasoningEffort },
-        max_output_tokens: request.maxOutputTokens,
-        text: {
-            format: { type: "json_schema", name: "study_analysis", strict: true, schema: request.schema },
-        },
-    }),
+        };
+    },
     parse: parseAnalysisResponse,
 };

package/dist/analysis/output-limit.d.ts

@@ -0,0 +1,12 @@
+import type { AnalysisConfig } from "./types.js";
+/** 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;
+/**
+ * The output limit an analysis of `participants` asks for when its study declares none, or
+ * undefined for Codex, which takes no limit. A high-effort or Gemini analysis, and one analysed in
+ * cohorts, gets the most the analysts return: at those efforts one finished report of three
+ * participants used up to 26,439 tokens.
+ */
+export declare function defaultOutputTokens(config: AnalysisConfig, participants: number): number | undefined;

package/dist/analysis/output-limit.js

@@ -0,0 +1,34 @@
+// The output limit an API analysis asks for when its study declares none. A request that runs
+// away writes until it reaches the limit, so the limit is sized to what a finished report of the
+// packet needs, with room to spare.
+import { analysisCohortCount } from "./analysis-limits.js";
+import { analysisEffort } from "./models.js";
+/** 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;
+/**
+ * The limit of a low- or medium-effort OpenAI request: this many tokens, and this many more for
+ * each participant. On the 2026-10-22 and 2026-10-23 benchmark recordings the longest finished
+ * report at those efforts used 8,354 tokens for one participant and 11,313 for three (gpt-6-luna at
+ * medium; gpt-6.1-sol at medium used at most 5,659 and 9,000), so the limit is 1.7 and 1.6 times
+ * those. docs/contracts/study-analysis.md has the table.
+ */
+const LIMIT_BASE_TOKENS = 12_288;
+const LIMIT_TOKENS_PER_PARTICIPANT = 2_048;
+const SIZED_EFFORTS = new Set(["none", "low", "medium"]);
+/**
+ * The output limit an analysis of `participants` asks for when its study declares none, or
+ * undefined for Codex, which takes no limit. A high-effort or Gemini analysis, and one analysed in
+ * cohorts, gets the most the analysts return: at those efforts one finished report of three
+ * participants used up to 26,439 tokens.
+ */
+export function defaultOutputTokens(config, participants) {
+    if (config.provider === "codex")
+        return undefined;
+    if (config.provider === "gemini" ||
+        !SIZED_EFFORTS.has(analysisEffort(config)) ||
+        analysisCohortCount(participants) > 1)
+        return MAX_ANALYSIS_OUTPUT_TOKENS;
+    return Math.min(MAX_ANALYSIS_OUTPUT_TOKENS, LIMIT_BASE_TOKENS + LIMIT_TOKENS_PER_PARTICIPANT * participants);
+}

package/dist/analysis/output-retry.d.ts

@@ -0,0 +1,20 @@
+import type { RequestCost } from "./admission.js";
+import type { AnalysisProviderResult } from "./provider.js";
+import type { AnalysisConfig, AnalysisUsage } from "./types.js";
+export interface OutputRetries {
+    /**
+     * Whether to send request `index` again after `response`, given the attempt's usage with that
+     * response counted. Adds a warning that says what ran out and what humanish did.
+     */
+    retry(index: number, response: AnalysisProviderResult, usage: AnalysisUsage): boolean;
+    /** Request `index` has its final answer, so its cost is no longer held against the cap. */
+    settle(index: number): void;
+    /** The summed worst case of every request sent again, which admission did not price. */
+    worstCaseUsd(): number;
+}
+/**
+ * The retries of one attempt. `costs` are each request's costs from admission (the cohorts', then
+ * the merge request's), `describe` names request `index` at the start of a sentence, and warnings
+ * receive what happened.
+ */
+export declare function outputRetries(config: AnalysisConfig, costs: readonly RequestCost[], describe: (index: number) => string, warnings: string[] | undefined): OutputRetries;

package/dist/analysis/output-retry.js

@@ -0,0 +1,63 @@
+// One more request when an API analyst runs out of output before it finishes its report. The same
+// request is sent again, at most once, and only while the analysis's cost cap still admits it
+// after counting what every request so far cost. Codex account analysis has no dollar cap to
+// check, so it is never sent again.
+import { estimateActorCost } from "../run/pricing.js";
+const usd = (value) => `$${value.toFixed(2)}`;
+/**
+ * The retries of one attempt. `costs` are each request's costs from admission (the cohorts', then
+ * the merge request's), `describe` names request `index` at the start of a sentence, and warnings
+ * receive what happened.
+ */
+export function outputRetries(config, costs, describe, warnings) {
+    // What each request without a final answer may still cost: admission's figure for it.
+    const held = new Map(costs.map((cost, index) => [index, cost.admittedCostUsd]));
+    const retried = new Set();
+    let worstCase = 0;
+    const warn = (text) => {
+        warnings?.push(text);
+    };
+    return {
+        retry(index, response, usage) {
+            if (response.errorCode !== "output_incomplete" || config.maxCostUsd === null)
+                return false;
+            const which = describe(index);
+            if (retried.has(index)) {
+                warn(`${which} ran out of output again, so this attempt has no report.`);
+                return false;
+            }
+            const cap = config.maxCostUsd;
+            const tokens = response.usage;
+            const cost = tokens === null
+                ? null
+                : estimateActorCost({ ...tokens, turns: [tokens] }, config.model).estimatedCostUsd;
+            if (tokens === null ||
+                cost === null ||
+                !usage.usageComplete ||
+                usage.estimatedCostUsd === null) {
+                warn(`${which} ran out of output before it finished its report and did not report its usage, so humanish cannot tell whether a second request fits the $${cap} cap. It was not sent again.`);
+                return false;
+            }
+            const ranOut = `${which} ran out of output before it finished its report: ${tokens.output} of ${config.maxOutputTokens} output tokens, ${tokens.input} input tokens, ${usd(cost)}.`;
+            const again = costs[index];
+            let others = 0;
+            for (const [other, amount] of held)
+                if (other !== index)
+                    others += amount;
+            const total = usage.estimatedCostUsd + others + again.admittedCostUsd;
+            if (total > cap) {
+                const running = others > 0 ? `, the ${usd(others)} admission holds for requests still running,` : "";
+                warn(`${ranOut} humanish did not send it again: the ${usd(usage.estimatedCostUsd)} spent so far${running} plus ${usd(again.admittedCostUsd)} for one more request at admission's estimate is over the $${cap} cap. To retry, run the analysis again; a higher cost cap leaves room for a second request.`);
+                return false;
+            }
+            retried.add(index);
+            worstCase += again.worstCaseCostUsd;
+            warn(`${ranOut} humanish sent the same request once more; the attempt's usage counts both requests.`);
+            return true;
+        },
+        settle(index) {
+            held.delete(index);
+        },
+        worstCaseUsd: () => worstCase,
+    };
+}

package/dist/analysis/provider.d.ts

@@ -73,7 +73,7 @@ export interface AnalysisWire {
     body(request: AnalysisProviderRequest): unknown;
     parse(raw: unknown): AnalysisProviderResult;
 }
-/** One request to the vendor's fixed endpoint, never retried and never sent elsewhere. */
+/** One request to the vendor's fixed endpoint, sent once and never elsewhere. */
 export declare function createAnalysisProvider(options: {
     apiKey: string;
     /** Omitted is OpenAI, the analyst humanish has always called. */