humanish 0.145.0 → 0.146.0

package/CHANGELOG.md

@@ -8,6 +8,17 @@ 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.

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/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. */

package/dist/analysis/provider.js

@@ -1,8 +1,8 @@
 // The analysis provider seam and the HTTP transport its API adapters share. Each API vendor owns
 // only its wire format (gemini-wire.ts, openai-wire.ts): the endpoint, the request body, and how a
 // response becomes a result. The transport owns what must hold for every vendor: one fixed endpoint
-// per vendor, request and response byte caps, the caller's wall-clock deadline, no retry, and a
-// closed error vocabulary that never carries provider error prose. The Codex account analyst is
+// per vendor, request and response byte caps, the caller's wall-clock deadline, one send per call
+// (runAnalysis decides whether to call again, in output-retry.ts), and a closed error vocabulary that never carries provider error prose. The Codex account analyst is
 // the third adapter at the same seam (restricted-codex.ts).
 import { Agent, fetch as undiciFetch } from "undici";
 import { isRecord } from "../run/type-guards.js";
@@ -49,7 +49,7 @@ const WIRES = {
     openai: openaiWire,
     gemini: geminiWire,
 };
-/** 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 function createAnalysisProvider(options) {
     const fetchFn = options.fetchFn ?? undiciFetch;
     const wire = WIRES[options.vendor ?? "openai"];

package/dist/analysis/responses.js

@@ -202,7 +202,7 @@ export function httpStatusWarning(config, response) {
         return undefined;
     const api = config.provider === "gemini" ? "Gemini" : "OpenAI";
     const meaning = HTTP_STATUS_MEANINGS[response.httpStatus];
-    return `The ${api} API answered HTTP ${response.httpStatus}${meaning === undefined ? "" : ` (${meaning})`}. humanish does not retry an analysis request; run the command again to retry.`;
+    return `The ${api} API answered HTTP ${response.httpStatus}${meaning === undefined ? "" : ` (${meaning})`}. humanish sends a request again only when it ran out of output; run the command again to retry.`;
 }
 /** The warnings a Codex response carries about its CLI release and protocol. */
 export function codexWarnings(config, response) {

package/dist/analysis/service.js

@@ -17,7 +17,7 @@ import { withAnalysisLock } from "./analysis-lock.js";
 import { captureEvidence, EVIDENCE_LIMITS } from "./evidence.js";
 import { AnalysisSourceRefusedError, runFileTooLarge, throwAsAnalysisRefusal } from "./source.js";
 import { pathMissing, readBoundedFile, readBoundedFileResult } from "../run/evidence-files.js";
-import { estimateAnalysisAdmission, preferLargerAnalysisOutput, runAnalysis, ANALYSIS_PROMPT_VERSION, } from "./execute.js";
+import { estimateAnalysisAdmission, defaultAnalysisOutput, runAnalysis, ANALYSIS_PROMPT_VERSION, } from "./execute.js";
 import { appendAnalysisCorrection, assertAnalysisPublicationCapacity, listAnalyses, writeAnalysis, } from "./store.js";
 import { beginAnalysisExecution, writeAnalysisExecutionReceipt } from "./store-executions.js";
 import { keepRejectedAnalysisOutput } from "./diagnostics.js";
@@ -261,7 +261,7 @@ async function executeAnalysis(attempt) {
     if (input.evidence.length === 0)
         return fail(input.runId, dryRun, "ANALYSIS_NO_PARTICIPANTS");
     if (options.preferLargerOutput)
-        config = preferLargerAnalysisOutput(input, config);
+        config = defaultAnalysisOutput(input, config);
     const admission = estimateAnalysisAdmission(input, config);
     const base = {
         schema: ANALYZE_RESULT_SCHEMA,

package/dist/cli/commands/analyze.js

@@ -38,7 +38,7 @@ export function registerAnalyzeCommand(parent, io) {
         .option("--reasoning-effort <level>", `OpenAI reasoning.effort or Gemini thinking level, from none, minimal, low, medium, high, xhigh and max; each model takes only the levels its provider documents for it, and others are refused before any request. When omitted: ${DEFAULT_ANALYSIS_EFFORT} for the default OpenAI analyst, high with --model or --provider gemini. Unsupported for Codex.`)
         .option("--question <text>", "Additional reviewer question; does not change participant instructions.")
         .option("--timeout-ms <ms>", "Request timeout, at most 600000 ms.", String(DEFAULT_ANALYSIS_TIMEOUT_MS))
-        .option("--max-output-tokens <n>", "OpenAI or Gemini response-token limit including reasoning, 256–32768. Omit for admission-based sizing. Unsupported for Codex.")
+        .option("--max-output-tokens <n>", "OpenAI or Gemini response-token limit including reasoning, 256–32768. Omit for a limit sized to the participants and effort. Unsupported for Codex.")
         .option("--dry-run", "Capture and validate local input and estimate admission; no request or analysis artifact.")
         .option("--rerun", "Create a new immutable version even when the same input and configuration were analyzed.")
         .option("--json", JSON_OPTION_DESCRIPTION)

package/dist/cli/io.js

@@ -208,6 +208,8 @@ export function writeResult(command, io, result, formatHuman, analysisLines) {
                 io.writeOut(`analysis: refused before it started. ${refusal.text} ${refusal.command}\n`);
             else if (analysis)
                 io.writeOut(`analysis: ${analysisOutcomeText(analysis)}\n`);
+            for (const warning of analysis?.result?.warnings ?? [])
+                io.writeOut(`analysis: ${warning}\n`);
             const rejected = analysis?.result?.rejectedOutputPath;
             if (rejected)
                 io.writeOut(`analysis: ${analysis.result?.error?.code ?? "rejected"}; the rejected output is kept locally at ${rejected}\n`);

package/dist/cli/run-findings.js

@@ -33,10 +33,12 @@ async function readRunReport(cwd, result, deps) {
     if (outcome === undefined || result.runId === undefined || result.runId === "not-created")
         return undefined;
     const outcomeLine = `analysis: ${analysisOutcomeText(outcome)}`;
+    // What the attempt warned about, such as a request sent again after it ran out of output.
+    const warningLines = (outcome.result?.warnings ?? []).map((warning) => `analysis: ${warning}`);
     const plain = {
         message: `The automatic analysis was ${analysisOutcomeText(outcome)}.`,
         nextCommand: null,
-        lines: [outcomeLine],
+        lines: [outcomeLine, ...warningLines],
     };
     // A dry run left no evidence, and its own output names the live run.
     if (outcome.reason === "AUTOMATIC_ANALYSIS_DRY_RUN")
@@ -61,7 +63,12 @@ async function readRunReport(cwd, result, deps) {
         return {
             message: view.message,
             nextCommand: review,
-            lines: [outcomeLine, ...rejectedLine, ...formatFindingsSummary(view, review)],
+            lines: [
+                outcomeLine,
+                ...warningLines,
+                ...rejectedLine,
+                ...formatFindingsSummary(view, review),
+            ],
             findings: findingsSummary(view, review, result.observer?.observerPath),
         };
     // The line reads "analysis: skipped because ...", as it does without the view.
@@ -71,6 +78,7 @@ async function readRunReport(cwd, result, deps) {
         nextCommand: view.next,
         lines: [
             `analysis: ${said}`,
+            ...warningLines,
             ...rejectedLine,
             ...(view.next === null ? [] : [`next: ${view.next}`]),
         ],