humanish 0.142.0 → 0.143.0

package/CHANGELOG.md

@@ -8,6 +8,16 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.143.0: Analysis costs about one seventh as much: gpt-6.1-sol at medium effort is the default (2026-10-22)
+
+humanish 0.143.0 analyzes studies with `gpt-6.1-sol` at medium reasoning effort by default, in
+place of `gpt-6-astra` at high. On the same recordings it found what `gpt-6-astra` found, invented
+nothing, and cost about one seventh as much: $0.06 against $0.41 per analysis on the Taskly
+benchmark. A study can set the analysis effort with `review.analysis.reasoningEffort`, and one
+that names its model keeps it at high effort with an unchanged configuration hash.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.143.0)
+
 ## 0.142.0: Remote runs, Gemini and GPT-6 analysis models, and a view-only live stream (2026-10-21)
 
 humanish 0.142.0 can run a study remotely: `humanish run <study> --remote` puts the study's own

package/README.md

@@ -249,7 +249,7 @@ coverage limits, estimated cost controls, corrections and sharing behavior.
 
 Supported live studies generate findings automatically after participants finish.
 A Codex participant's run is analyzed by the same Codex account; every other run uses
-`gpt-6-astra` with high reasoning and a separate $10 cap on the expected cost.
+`gpt-6.1-sol` at medium reasoning effort and a separate $10 cap on the expected cost.
 This is additional to participant execution costs, and is not a hard provider
 billing cap. To disable the extra request:
 

package/dist/analysis/automatic-config.d.ts

@@ -1,7 +1,14 @@
 import type { StudyRoute } from "../study/plan.js";
+import { type ReasoningEffort } from "../actors/reasoning-effort.js";
 import type { AnalysisConfig } from "./types.js";
 export declare const DEFAULT_ANALYSIS_TIMEOUT_MS = 600000;
-export declare const DEFAULT_ANALYSIS_MODEL = "gpt-6-astra";
+/** The OpenAI analyst a study or command gets when it names no model. */
+export declare const DEFAULT_ANALYSIS_MODEL = "gpt-6.1-sol";
+/**
+ * The effort the default OpenAI analyst runs at when no effort is declared. A named model without
+ * an effort runs at high (models.ts), so a study that names its model keeps its configuration hash.
+ */
+export declare const DEFAULT_ANALYSIS_EFFORT = "medium";
 /** The model a Gemini analysis uses when the study or command names none: Google's current
  * stable Flash model. */
 export declare const DEFAULT_GEMINI_ANALYSIS_MODEL = "gemini-3.8-flash";
@@ -15,10 +22,12 @@ export type StudyAnalysis = StudyAnalysisSettings & ({
     provider?: "openai" | "gemini";
     maxCostUsd: number;
     maxOutputTokens?: number;
+    reasoningEffort?: ReasoningEffort;
 } | {
     provider: "codex";
     maxCostUsd?: null;
     maxOutputTokens?: null;
+    reasoningEffort?: never;
 });
 /** The spend cap on an OpenAI analysis the study did not declare. */
 export declare const DEFAULT_ANALYSIS_MAX_COST_USD = 10;
@@ -43,6 +52,8 @@ export interface AutomaticAnalysisBudget {
     provider?: "openai" | "gemini" | "codex";
     billing?: "api-estimate" | "account-unknown";
     model: string;
+    /** The reasoning effort the analysis runs at. */
+    effort: ReasoningEffort;
     maxCostUsd: number | null;
     trigger: "default" | "explicit";
     /** The participants the expected cost range is for. */

package/dist/analysis/automatic-config.js

@@ -1,12 +1,20 @@
 import { CODEX_ANALYSIS_MODEL, codexAnalysisIdentity } from "./codex-config.js";
-import { DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS, MAX_ANALYSIS_OUTPUT_TOKENS, analysisCostRange, isSupportedAnalysisModel, } from "./execute.js";
+import { DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS, MAX_ANALYSIS_OUTPUT_TOKENS, analysisCostRange, } from "./execute.js";
+import { analysisEffort, analysisEfforts, isSupportedAnalysisModel } from "./models.js";
+import { isReasoningEffort } from "../actors/reasoning-effort.js";
 import { admissionRule } from "./admission.js";
 import { analysisRequestCount, EVIDENCE_LIMITS } from "./analysis-limits.js";
 import { plural } from "../run/text.js";
 import { scanEncodedText } from "../evidence/encoded-text.js";
 export const DEFAULT_ANALYSIS_TIMEOUT_MS = 600_000;
 const MAX_ANALYSIS_TIMEOUT_MS = 600_000;
-export const DEFAULT_ANALYSIS_MODEL = "gpt-6-astra";
+/** The OpenAI analyst a study or command gets when it names no model. */
+export const DEFAULT_ANALYSIS_MODEL = "gpt-6.1-sol";
+/**
+ * The effort the default OpenAI analyst runs at when no effort is declared. A named model without
+ * an effort runs at high (models.ts), so a study that names its model keeps its configuration hash.
+ */
+export const DEFAULT_ANALYSIS_EFFORT = "medium";
 /** The model a Gemini analysis uses when the study or command names none: Google's current
  * stable Flash model. */
 export const DEFAULT_GEMINI_ANALYSIS_MODEL = "gemini-3.8-flash";
@@ -17,6 +25,7 @@ const FIELDS = new Set([
     "question",
     "timeoutMs",
     "maxOutputTokens",
+    "reasoningEffort",
 ]);
 const validTimeout = (value) => typeof value === "number" &&
     Number.isSafeInteger(value) &&
@@ -59,7 +68,7 @@ export function resolveAutomaticAnalysis(raw, participant) {
         Object.keys(raw).some((key) => !FIELDS.has(key))) {
         return {
             ok: false,
-            message: "review.analysis must be false or a mapping containing only provider, maxCostUsd, model, question, timeoutMs and maxOutputTokens.",
+            message: "review.analysis must be false or a mapping containing only provider, maxCostUsd, model, question, timeoutMs, maxOutputTokens and reasoningEffort.",
         };
     }
     const value = raw;
@@ -70,6 +79,11 @@ export function resolveAutomaticAnalysis(raw, participant) {
         return { ok: false, message: "review.analysis.provider must be openai, gemini or codex." };
     }
     if (value.provider === "codex") {
+        if (value.reasoningEffort !== undefined)
+            return {
+                ok: false,
+                message: "Codex account analysis runs at its fixed low reasoning effort, so it takes no reasoningEffort. Omit it, or choose provider openai or gemini to set one.",
+            };
         const model = value.model === undefined ? CODEX_ANALYSIS_MODEL : value.model;
         const timeoutMs = value.timeoutMs === undefined ? DEFAULT_ANALYSIS_TIMEOUT_MS : value.timeoutMs;
         const question = value.question === undefined ? null : value.question;
@@ -127,18 +141,32 @@ export function resolveAutomaticAnalysis(raw, participant) {
             message: `review.analysis requires a positive maxCostUsd up to 1000, a supported ${vendor === "gemini" ? "Gemini" : "OpenAI"} analysis model, timeoutMs 1–${MAX_ANALYSIS_TIMEOUT_MS}, maxOutputTokens 256–${MAX_ANALYSIS_OUTPUT_TOKENS}, and an optional question of at most 4000 characters.`,
         };
     }
+    // Only the default model gets the default effort, written out because an omitted effort is high.
+    const reasoningEffort = value.reasoningEffort === undefined && value.model === undefined && vendor === "openai"
+        ? DEFAULT_ANALYSIS_EFFORT
+        : value.reasoningEffort;
+    const efforts = analysisEfforts(model, vendor);
+    if (reasoningEffort !== undefined &&
+        (!isReasoningEffort(reasoningEffort) || !efforts.includes(reasoningEffort)))
+        return {
+            ok: false,
+            message: `review.analysis.reasoningEffort for ${model} must be ${efforts.slice(0, -1).join(", ")} or ${efforts.at(-1)}, the efforts its provider documents for it.`,
+        };
     if (question !== null && scanEncodedText(question).sensitive)
         return SENSITIVE_QUESTION;
     return {
         ok: true,
         config: {
-            // An omitted provider stays omitted: it is the OpenAI contract, and its hash predates the field.
+            // An omitted provider, or an omitted effort on a named model, stays omitted, so the
+            // configuration keeps the hash it had before the field existed. An omitted provider is the
+            // OpenAI contract.
             ...(value.provider === undefined ? {} : { provider: vendor }),
             model,
             maxCostUsd,
             timeoutMs,
             maxOutputTokens,
             question: question,
+            ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
         },
         ...(value.maxOutputTokens === undefined ? { preferLargerOutput: true } : {}),
     };
@@ -164,6 +192,7 @@ export function automaticAnalysisBudget(raw, route, participants, participant) {
                 ? { provider: "gemini" }
                 : {}),
         model: config.model,
+        effort: analysisEffort(config),
         maxCostUsd: config.maxCostUsd,
         trigger: raw === undefined ? "default" : "explicit",
         ...(range === undefined || participants === undefined ? {} : { participants, ...range }),
@@ -180,7 +209,7 @@ export function analysisRequestsText(requests) {
 }
 export function formatAutomaticAnalysisBudget(budget) {
     if (budget.provider === "codex")
-        return `After live runs: ${budget.trigger === "default" ? "default " : ""}Codex account analysis · ${budget.model} · separate restricted analyst with remote inference. Account limits apply; dollar cost and output-token ceiling are unknown. Set review.analysis: false to disable.`;
+        return `After live runs: ${budget.trigger === "default" ? "default " : ""}Codex account analysis · ${budget.model} at ${budget.effort} effort · separate restricted analyst with remote inference. Account limits apply; dollar cost and output-token ceiling are unknown. Set review.analysis: false to disable.`;
     const rule = admissionRule(`$${budget.maxCostUsd}`);
     // The participants, and the requests that analyse them when there is more than one.
     const requests = analysisRequestsText(analysisRequestCount(Math.min(budget.participants ?? 0, EVIDENCE_LIMITS.participants)));
@@ -194,5 +223,5 @@ export function formatAutomaticAnalysisBudget(budget) {
         ? `refused before it starts if ${rule}`
         : `refused before it starts for ${who} even with no evidence (expected $${budget.refusedFromUsd.toFixed(2)}), since ${rule}`;
     const where = budget.provider === "gemini" ? " on Gemini, which sends the evidence to Google" : "";
-    return `After live runs: ${budget.trigger} analysis${where} · ${budget.model}${range} · ${refused}; this is not a billing cap. Set review.analysis: false to disable.`;
+    return `After live runs: ${budget.trigger} analysis${where} · ${budget.model} at ${budget.effort} effort${range} · ${refused}; this is not a billing cap. Set review.analysis: false to disable.`;
 }

package/dist/analysis/execute.d.ts

@@ -1,17 +1,7 @@
 import { type AnalysisArtifact, type AnalysisConfig, type AnalysisInput } from "./types.js";
-import { type AnalysisApiVendor, type AnalysisFetch, type AnalysisProvider } from "./provider.js";
+import { type AnalysisFetch, type AnalysisProvider } from "./provider.js";
 import type { RejectedAnalysisOutput } from "./diagnostics.js";
 export declare const ANALYSIS_PROMPT_VERSION = "study-evidence-8";
-export declare const SUPPORTED_ANALYSIS_MODELS: readonly string[];
-/**
- * Gemini models that completed a live analysis. Each model's page under
- * ai.google.dev/gemini-api/docs/models (read 2026-10-21) also lists image input and JSON-schema
- * output for gemini-3.5-flash-lite, gemini-3-flash-preview and gemini-4-argon; they join this list
- * once a live analysis on each completes.
- */
-export declare const GEMINI_ANALYSIS_MODELS: readonly string[];
-/** Whether the API analyst `provider` (omitted is OpenAI) analyzes with `model`. */
-export declare const isSupportedAnalysisModel: (model: string, provider?: AnalysisApiVendor) => boolean;
 /** 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;

package/dist/analysis/execute.js

@@ -6,6 +6,7 @@ import { modelRate } from "../run/pricing.js";
 import { containsSensitive } from "../evidence/redaction.js";
 import { scanEncodedText } from "../evidence/encoded-text.js";
 import { ANALYSIS_ID_PATTERN, ANALYSIS_SCHEMA, } from "./types.js";
+import { analysisEffort, analysisEfforts, isSupportedAnalysisModel } from "./models.js";
 import { createAnalysisProvider, } from "./provider.js";
 import { hashAnalysisValue, analysisResultJsonSchema, validateAnalysisInputMetadata, } from "./validation.js";
 import { analysisCohorts, analysisRequestCount, EVIDENCE_LIMITS } from "./analysis-limits.js";
@@ -13,27 +14,6 @@ import { checkMergedResponse, cohortInputs, mergePacket, mergeResultJsonSchema,
 import { checkProviderAnalysis, codexWarnings, httpStatusWarning, recordProviderUsage, } from "./responses.js";
 import { mapWithConcurrency } from "../run/concurrency.js";
 export const ANALYSIS_PROMPT_VERSION = "study-evidence-8";
-export const SUPPORTED_ANALYSIS_MODELS = Object.freeze([
-    "gpt-6-astra",
-    "gpt-6.1-sol",
-    "gpt-6-luna",
-    "gpt-5.5",
-    "gpt-5.6",
-    "gpt-5.6-sol",
-    "gpt-5.6-terra",
-    "gpt-5.6-luna",
-]);
-const SUPPORTED_MODELS = new Set(SUPPORTED_ANALYSIS_MODELS);
-/**
- * Gemini models that completed a live analysis. Each model's page under
- * ai.google.dev/gemini-api/docs/models (read 2026-10-21) also lists image input and JSON-schema
- * output for gemini-3.5-flash-lite, gemini-3-flash-preview and gemini-4-argon; they join this list
- * once a live analysis on each completes.
- */
-export const GEMINI_ANALYSIS_MODELS = Object.freeze(["gemini-3.8-flash"]);
-const GEMINI_MODELS = new Set(GEMINI_ANALYSIS_MODELS);
-/** Whether the API analyst `provider` (omitted is OpenAI) analyzes with `model`. */
-export const isSupportedAnalysisModel = (model, provider = "openai") => (provider === "gemini" ? GEMINI_MODELS : SUPPORTED_MODELS).has(model);
 /** 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;
@@ -192,6 +172,8 @@ export function estimateAnalysisAdmission(input, config) {
             config.provider !== "openai" &&
             config.provider !== "gemini") ||
             !isSupportedAnalysisModel(config.model, config.provider) ||
+            (config.reasoningEffort !== undefined &&
+                !analysisEfforts(config.model, config.provider).includes(config.reasoningEffort)) ||
             !Number.isFinite(config.maxCostUsd) ||
             config.maxCostUsd <= 0 ||
             config.maxCostUsd > 1000 ||
@@ -547,6 +529,7 @@ export async function runAnalysis(input, config, options) {
             images: request.images,
             schema: request.schema,
             maxOutputTokens: config.maxOutputTokens,
+            reasoningEffort: analysisEffort(config),
             timeoutMs: config.timeoutMs,
             ...(options.signal === undefined ? {} : { signal: options.signal }),
         });

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

@@ -1,6 +1,7 @@
 import type { AnalysisWire } from "./provider.js";
 /**
- * One stateless request: no tools, high thinking, JSON constrained to the schema, the standard
+ * One stateless request: no tools, the analysis's reasoning effort as its thinking level (the
+ * ThinkingLevel enum spells the same names in capitals), JSON constrained to the schema, the standard
  * service tier, and `store: false` so the request stays out of the project's request logs. Each
  * capture goes at MEDIA_RESOLUTION_HIGH, the setting the media-resolution guide recommends for
  * image analysis, after a text part naming its evidence key.

package/dist/analysis/gemini-wire.js

@@ -116,7 +116,8 @@ function parseGenerateContent(raw) {
     }
 }
 /**
- * One stateless request: no tools, high thinking, JSON constrained to the schema, the standard
+ * One stateless request: no tools, the analysis's reasoning effort as its thinking level (the
+ * ThinkingLevel enum spells the same names in capitals), JSON constrained to the schema, the standard
  * service tier, and `store: false` so the request stays out of the project's request logs. Each
  * capture goes at MEDIA_RESOLUTION_HIGH, the setting the media-resolution guide recommends for
  * image analysis, after a text part naming its evidence key.
@@ -152,7 +153,7 @@ export const geminiWire = {
             generationConfig: {
                 candidateCount: 1,
                 maxOutputTokens: request.maxOutputTokens,
-                thinkingConfig: { thinkingLevel: "HIGH" },
+                thinkingConfig: { thinkingLevel: request.reasoningEffort.toUpperCase() },
                 responseFormat: {
                     text: { mimeType: "APPLICATION_JSON", schema },
                 },

package/dist/analysis/models.d.ts

@@ -0,0 +1,12 @@
+import type { ReasoningEffort } from "../actors/reasoning-effort.js";
+import type { AnalysisApiVendor } from "./provider.js";
+import type { AnalysisConfig } from "./types.js";
+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`. */
+export declare const isSupportedAnalysisModel: (model: string, provider?: AnalysisApiVendor) => boolean;
+/** The reasoning efforts `model` accepts from `provider`, least first; empty for an unknown model. */
+export declare const analysisEfforts: (model: string, provider?: AnalysisApiVendor) => readonly ReasoningEffort[];
+/** The effort an analysis runs at: the declared one, high for an API analysis that declares none,
+ * and the Codex account's fixed effort. */
+export declare function analysisEffort(config: AnalysisConfig): ReasoningEffort;

package/dist/analysis/models.js

@@ -0,0 +1,47 @@
+// The models each API analyst runs, and the reasoning efforts each model accepts. Config parsing,
+// admission, the CLI help and the wire formats all read this one table.
+/**
+ * `reasoning.effort` values from each model's page under developers.openai.com/api/docs/models
+ * (read 2026-10-21). None of them lists `minimal`; gpt-6-astra and gpt-6.1-sol also refuse `none`.
+ */
+const OPENAI_MODELS = {
+    "gpt-6-astra": ["low", "medium", "high", "xhigh", "max"],
+    "gpt-6.1-sol": ["low", "medium", "high", "xhigh", "max"],
+    "gpt-6-luna": ["none", "low", "medium", "high", "xhigh", "max"],
+    "gpt-5.5": ["none", "low", "medium", "high", "xhigh"],
+    "gpt-5.6": ["none", "low", "medium", "high", "xhigh", "max"],
+    "gpt-5.6-sol": ["none", "low", "medium", "high", "xhigh", "max"],
+    "gpt-5.6-terra": ["none", "low", "medium", "high", "xhigh", "max"],
+    "gpt-5.6-luna": ["none", "low", "medium", "high", "xhigh", "max"],
+};
+/**
+ * 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):
+ * gemini-3.8-flash answers `minimal` with an error. Each model's page under
+ * ai.google.dev/gemini-api/docs/models also lists image input and JSON-schema output for
+ * gemini-3.5-flash-lite, gemini-3-flash-preview and gemini-4-argon; they join this table once a
+ * live analysis on each completes.
+ */
+const GEMINI_MODELS = {
+    "gemini-3.8-flash": ["low", "medium", "high"],
+};
+const MODELS = { openai: OPENAI_MODELS, gemini: GEMINI_MODELS };
+export const SUPPORTED_ANALYSIS_MODELS = Object.freeze(Object.keys(OPENAI_MODELS));
+export const GEMINI_ANALYSIS_MODELS = Object.freeze(Object.keys(GEMINI_MODELS));
+/** Whether the API analyst `provider` (omitted is OpenAI) analyzes with `model`. */
+export const isSupportedAnalysisModel = (model, provider = "openai") => Object.hasOwn(MODELS[provider], model);
+/** The reasoning efforts `model` accepts from `provider`, least first; empty for an unknown model. */
+export const analysisEfforts = (model, provider = "openai") => Object.hasOwn(MODELS[provider], model) ? MODELS[provider][model] : [];
+/**
+ * The effort an API analysis runs at when its configuration declares none. Every saved analysis
+ * without `reasoningEffort` ran at this effort, so it stays high: a different default must be
+ * written into the configuration it resolves, where it also changes the configuration's hash.
+ */
+const UNDECLARED_EFFORT = "high";
+/** The effort an analysis runs at: the declared one, high for an API analysis that declares none,
+ * and the Codex account's fixed effort. */
+export function analysisEffort(config) {
+    if (config.provider === "codex")
+        return config.identity.reasoningEffort;
+    return config.reasoningEffort ?? UNDECLARED_EFFORT;
+}

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

@@ -1,5 +1,6 @@
 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, high reasoning effort, strict schema. */
+/** One stateless request: no stored response, no tools, the analysis's reasoning effort, strict
+ * schema. */
 export declare const openaiWire: AnalysisWire;

package/dist/analysis/openai-wire.js

@@ -67,7 +67,8 @@ export function parseAnalysisResponse(raw) {
         return { ...base, status: "failed", errorCode: "invalid_response" };
     }
 }
-/** One stateless request: no stored response, no tools, high reasoning effort, strict schema. */
+/** One stateless request: no stored response, no tools, the analysis's reasoning effort, strict
+ * schema. */
 export const openaiWire = {
     url: () => OPENAI_RESPONSES_URL,
     headers: (apiKey) => ({ Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" }),
@@ -91,7 +92,7 @@ export const openaiWire = {
         tool_choice: "none",
         truncation: "disabled",
         service_tier: "default",
-        reasoning: { effort: "high" },
+        reasoning: { effort: request.reasoningEffort },
         max_output_tokens: request.maxOutputTokens,
         text: {
             format: { type: "json_schema", name: "study_analysis", strict: true, schema: request.schema },

package/dist/analysis/provider.d.ts

@@ -1,4 +1,5 @@
 import { type Dispatcher } from "undici";
+import type { ReasoningEffort } from "../actors/reasoning-effort.js";
 /** Deliberately separate from the stateful computer-use actor: one request, no tools or retries. */
 export interface AnalysisProviderRequest {
     model: string;
@@ -10,6 +11,9 @@ export interface AnalysisProviderRequest {
     }[];
     schema: Record<string, unknown>;
     maxOutputTokens: number | null;
+    /** The effort the analysis runs at (models.ts analysisEffort). The Codex account analyst runs
+     * its fixed low effort, which this then names. */
+    reasoningEffort: ReasoningEffort;
     timeoutMs: number;
     signal?: AbortSignal;
 }

package/dist/analysis/types.d.ts

@@ -1,5 +1,6 @@
 import type { ActorStatus, ActorCompletionReason, ActorStopCause, ParticipantDeclaredOutcome } from "../actors/contract.js";
 import type { CuaEndpointSource } from "../actors/goal-source.js";
+import type { ReasoningEffort } from "../actors/reasoning-effort.js";
 import type { AutomaticAnalysisView } from "./job.js";
 import type { RunAnalysisCost } from "../run/run-cost.js";
 /** Independent interpretation of retained evidence; never a participant or harness verdict. */
@@ -160,6 +161,9 @@ interface OpenAIAnalysisConfig {
     maxCostUsd: number;
     timeoutMs: number;
     maxOutputTokens: number;
+    /** Present only when the study or command declared it, so an omitted effort keeps the hash of
+     * every configuration before the field. An analysis without it ran at high (models.ts). */
+    reasoningEffort?: ReasoningEffort | undefined;
 }
 /** The Gemini API analyst: the same billed, capped request as OpenAI's, sent to Google. */
 interface GeminiAnalysisConfig extends Omit<OpenAIAnalysisConfig, "provider"> {

package/dist/analysis/validation.js

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ACTOR_STATUSES, ACTOR_STOP_CAUSES } from "../actors/contract.js";
 import { CUA_ENDPOINT_SOURCES } from "../actors/goal-source.js";
+import { REASONING_EFFORTS } from "../actors/reasoning-effort.js";
 import { ANALYSIS_LIMITS, EVIDENCE_LIMITS, MAX_ANALYSIS_COHORTS, hasControlCharacter, hasRevisionFields, } from "./analysis-limits.js";
 import { SHA256_HEX_PATTERN, ACTION_CAPTURE_VERSION, ANALYSIS_SCHEMA, ANALYSIS_CORRECTION_SCHEMA, } from "./types.js";
 const text = (max) => z
@@ -204,6 +205,7 @@ const apiAnalysisConfigSchema = z.object({
     maxCostUsd: z.number().positive().max(1000),
     timeoutMs: z.number().int().positive().max(3600000),
     maxOutputTokens: z.number().int().positive().max(128000),
+    reasoningEffort: z.enum(REASONING_EFFORTS).optional(),
 });
 const analysisArtifactSchema = z
     .object({
@@ -361,8 +363,7 @@ export function checkAnalysisResult(input, value) {
         if (!distinct(observation.evidenceIds) ||
             refs.some((ref) => !ref || !included.has(ref.streamId)))
             errors.add("ANALYSIS_OBSERVATION_REFERENCE_INVALID");
-        if (observation.basis === "visual" &&
-            !refs.some((ref) => ref?.capture !== null && ref?.capture !== undefined))
+        if (observation.basis === "visual" && !refs.some((ref) => ref?.capture))
             errors.add("ANALYSIS_VISUAL_WITHOUT_CAPTURE");
         if (observation.basis === "action" &&
             !refs.some((ref) => ref &&
@@ -394,7 +395,7 @@ export function checkAnalysisResult(input, value) {
         const refs = finding.evidenceIds.map((ref) => evidence.get(ref));
         if (!distinct(finding.evidenceIds) || refs.some((ref) => !ref || !included.has(ref.streamId)))
             errors.add("ANALYSIS_DESIGN_REFERENCE_INVALID");
-        if (!refs.some((ref) => ref?.capture !== null && ref?.capture !== undefined))
+        if (!refs.some((ref) => ref?.capture))
             errors.add("ANALYSIS_DESIGN_WITHOUT_CAPTURE");
         // Seen by means a cited capture of that participant shows the problem.
         const captured = new Set(refs.flatMap((ref) => (ref?.capture ? [ref.streamId] : [])));

package/dist/cli/commands/analyze.js

@@ -1,9 +1,9 @@
-import { analysisRequestsText, resolveAutomaticAnalysis, DEFAULT_ANALYSIS_MODEL, DEFAULT_ANALYSIS_TIMEOUT_MS, DEFAULT_GEMINI_ANALYSIS_MODEL, } from "../../analysis/automatic-config.js";
+import { analysisRequestsText, resolveAutomaticAnalysis, DEFAULT_ANALYSIS_EFFORT, DEFAULT_ANALYSIS_MODEL, DEFAULT_ANALYSIS_TIMEOUT_MS, DEFAULT_GEMINI_ANALYSIS_MODEL, } from "../../analysis/automatic-config.js";
 import { Command, Option } from "commander";
 import { forTerminal } from "../../routes/terminal/encoding.js";
 import { analyzeRun, correctAnalysis, dryRunBundleRefusal, showAnalysis, } from "../../analysis/service.js";
 import { admissionRule } from "../../analysis/admission.js";
-import { GEMINI_ANALYSIS_MODELS, SUPPORTED_ANALYSIS_MODELS, } from "../../analysis/execute.js";
+import { GEMINI_ANALYSIS_MODELS, SUPPORTED_ANALYSIS_MODELS } from "../../analysis/models.js";
 import { CODEX_ANALYSIS_MODEL } from "../../analysis/codex-config.js";
 import { listAnalyses } from "../../analysis/store.js";
 import { listAnalysisExecutions } from "../../analysis/store-executions.js";
@@ -34,7 +34,8 @@ export function registerAnalyzeCommand(parent, io) {
         .option("--cwd <path>", CWD_OPTION_DESCRIPTION, ".")
         .option("--provider <name>", "Analyst: openai (default), gemini (sends the evidence and captures to Google), or restricted codex account. No provider fallback.")
         .option("--max-cost <usd>", `Required for OpenAI and Gemini, also with --dry-run: an analysis is refused before it sends anything if ${admissionRule("this")}. It does not limit billing. Unsupported for Codex.`)
-        .option("--model <id>", `OpenAI analysis model, at high effort: ${SUPPORTED_ANALYSIS_MODELS.join(", ")}; ${DEFAULT_ANALYSIS_MODEL} when omitted. Gemini analysis model, at high thinking: ${GEMINI_ANALYSIS_MODELS.join(", ")}; ${DEFAULT_GEMINI_ANALYSIS_MODEL} when omitted. Codex account analysis runs ${CODEX_ANALYSIS_MODEL} at low effort.`)
+        .option("--model <id>", `OpenAI analysis model: ${SUPPORTED_ANALYSIS_MODELS.join(", ")}; ${DEFAULT_ANALYSIS_MODEL} at ${DEFAULT_ANALYSIS_EFFORT} effort when omitted. Gemini analysis model: ${GEMINI_ANALYSIS_MODELS.join(", ")}; ${DEFAULT_GEMINI_ANALYSIS_MODEL} when omitted. Codex account analysis runs ${CODEX_ANALYSIS_MODEL} at low effort.`)
+        .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.")
@@ -84,6 +85,7 @@ async function handleAnalyze(io, options, command) {
         ...(options.maxOutputTokens === undefined
             ? {}
             : { maxOutputTokens: Number(options.maxOutputTokens) }),
+        ...(options.reasoningEffort === undefined ? {} : { reasoningEffort: options.reasoningEffort }),
     });
     if (!selected.ok || !selected.config) {
         const refusal = await dryRunBundleRefusal(await resolvePhysicalCwd(options.cwd), options.run, options.dryRun === true);

package/dist/cli/findings.d.ts

@@ -158,10 +158,11 @@ interface LiveStudy {
 }
 /** ` --cwd <dir>`, or "" when `cwd` is the current directory. */
 export declare function cwdFlag(cwd: string): string;
-/** An analysis provider and model, as a study or an analysis record names them. */
+/** An analysis provider, model and effort, as a study or an analysis record names them. */
 interface Analyst {
     provider?: string | undefined;
     model?: string;
+    reasoningEffort?: string | undefined;
 }
 /** The findings view of a run's selected analysis, or why it has none. */
 export declare function analysisFindings(source: FindingsSource): AnalysisFindings;

package/dist/cli/findings.js

@@ -5,7 +5,7 @@
 // starts an analysis.
 import path from "node:path";
 import { costRefusal } from "../analysis/admission.js";
-import { DEFAULT_ANALYSIS_MAX_COST_USD, resolveAutomaticAnalysis, } from "../analysis/automatic-config.js";
+import { DEFAULT_ANALYSIS_EFFORT, DEFAULT_ANALYSIS_MAX_COST_USD, DEFAULT_ANALYSIS_MODEL, resolveAutomaticAnalysis, } from "../analysis/automatic-config.js";
 import { ANALYSIS_USUALLY_TAKES } from "../analysis/analysis-limits.js";
 import { bySeverity } from "../analysis/finding-lead.js";
 import { loadAnalysis } from "../analysis/load.js";
@@ -35,15 +35,25 @@ const KEY_MISSING_REASONS = new Set([
     "AUTOMATIC_ANALYSIS_KEY_MISSING",
     "AUTOMATIC_ANALYSIS_GEMINI_KEY_MISSING",
 ]);
+/** The effort an analysis configuration declares; Codex configurations declare none. */
+const declaredEffort = (config) => "reasoningEffort" in config ? config.reasoningEffort : undefined;
 /** The `analyze` command that runs `analyst` on the run; undefined is the OpenAI default. */
 function analyzeCommand(source, analyst) {
     const run = cli(`analyze --run ${source.runId}${source.cwdFlag}`);
     if (analyst?.provider === "codex")
         return `${run} --provider codex`;
-    const gemini = analyst?.provider === "gemini"
-        ? ` --provider gemini${analyst.model === undefined ? "" : ` --model ${analyst.model}`}`
-        : "";
-    return `${run}${gemini} --max-cost ${DEFAULT_ANALYSIS_MAX_COST_USD}`;
+    if (analyst?.provider === "gemini") {
+        const model = analyst.model === undefined ? "" : ` --model ${analyst.model}`;
+        return `${run} --provider gemini${model} --max-cost ${DEFAULT_ANALYSIS_MAX_COST_USD}`;
+    }
+    // A named model or effort stays in the command, so the rerun is the same analyst. The default
+    // analyst needs neither: `analyze` without flags runs it.
+    const isDefault = (analyst?.model ?? DEFAULT_ANALYSIS_MODEL) === DEFAULT_ANALYSIS_MODEL &&
+        (analyst?.model === undefined || analyst.reasoningEffort === DEFAULT_ANALYSIS_EFFORT);
+    const flags = isDefault
+        ? ""
+        : ` --model ${analyst.model}${analyst.reasoningEffort === undefined ? "" : ` --reasoning-effort ${analyst.reasoningEffort}`}`;
+    return `${run}${flags} --max-cost ${DEFAULT_ANALYSIS_MAX_COST_USD}`;
 }
 /** The cited items the analysis evidence resolves, each once, in citation order. */
 function citedEvidence(ids, analysis, runRoot) {
@@ -180,7 +190,7 @@ function missingKeyFindings(source, reason) {
         }));
     const opening = "The automatic analysis was skipped because OPENAI_API_KEY is not set.";
     if (source.codexSignedIn !== true)
-        return withoutFindings(source, "skipped", reason, `${opening} Set it with ${cli("keys set openai")}, then run the next command.`, analyzeCommand(source, undefined));
+        return withoutFindings(source, "skipped", reason, `${opening} Set it with ${cli("keys set openai")}, then run the next command.`, analyzeCommand(source, source.analyst?.provider === "gemini" ? undefined : source.analyst));
     const file = source.study?.path === undefined ? "the study file" : source.study.path;
     return withoutFindings(source, "skipped", reason, `${opening} Codex is signed in on this machine, so its ChatGPT account can analyze the run instead, sending the evidence to OpenAI under that account. The next command does it once; review.analysis.provider: codex in ${file} makes it this study's analyst.`, analyzeCommand(source, { provider: "codex" }));
 }
@@ -234,7 +244,11 @@ async function studyAnalyst(cwd, study) {
         return undefined;
     const analysis = resolveAutomaticAnalysis(resolved.config.review?.analysis, resolved.config.actor);
     return analysis.ok && analysis.config !== undefined
-        ? { provider: analysis.config.provider, model: analysis.config.model }
+        ? {
+            provider: analysis.config.provider,
+            model: analysis.config.model,
+            reasoningEffort: declaredEffort(analysis.config),
+        }
         : undefined;
 }
 /** The findings view of a run's selected analysis, or why it has none. */
@@ -255,7 +269,11 @@ export function analysisFindings(source) {
                 ? `The run's evidence changed after analysis ${analysis.id}, so its findings may not match the run.`
                 : `Analysis ${analysis.id} is ${analysis.status}, with ${plural(result.findings.length, "finding")}.`,
             next: stale
-                ? analyzeCommand(source, { provider: analysis.provider, model: analysis.config.model })
+                ? analyzeCommand(source, {
+                    provider: analysis.provider,
+                    model: analysis.config.model,
+                    reasoningEffort: declaredEffort(analysis.config),
+                })
                 : null,
             analysisId: analysis.id,
             status: analysis.status,
@@ -279,7 +297,11 @@ export function analysisFindings(source) {
     if (pending !== undefined)
         return pending;
     if (analysis && analysis.result === null)
-        return withoutFindings(source, "failed", analysis.error, `Analysis attempt ${analysis.id} ${analysis.status === "cancelled" ? "was cancelled" : "failed"}${analysis.error ? ` (${analysis.error})` : ""} and left no findings.`, analyzeCommand(source, { provider: analysis.provider, model: analysis.config.model }));
+        return withoutFindings(source, "failed", analysis.error, `Analysis attempt ${analysis.id} ${analysis.status === "cancelled" ? "was cancelled" : "failed"}${analysis.error ? ` (${analysis.error})` : ""} and left no findings.`, analyzeCommand(source, {
+            provider: analysis.provider,
+            model: analysis.config.model,
+            reasoningEffort: declaredEffort(analysis.config),
+        }));
     if (job?.state === "failed" || job?.state === "cancelled") {
         const outcome = analysisOutcomeText(job);
         return withoutFindings(source, "failed", job.reason, `The automatic analysis ${outcome.startsWith("failed") ? "" : "was "}${outcome}.`, analyzeCommand(source, job.reason === "AUTOMATIC_ANALYSIS_CODEX_UNAVAILABLE" ? { provider: "codex" } : undefined));

package/dist/remote/launch.d.ts

@@ -38,7 +38,10 @@ export declare function followRemoteRun(args: {
     signals: Signals;
     proxyUrl: string;
 }): Promise<RemoteOutcome>;
-/** Two sandbox journals as one: every line of each, in order, one per line. */
+/**
+ * Two sandbox journals as one: every line of each, in order, once. A copy that runs again adds
+ * nothing it already added.
+ */
 export declare function joinJournals(...journals: string[]): string;
 export interface Signals {
     readonly requested: "stop" | "detach" | undefined;

package/dist/remote/launch.js

@@ -2,7 +2,7 @@
 // participants' provider, follow it from here, and copy the finished run back. This machine only
 // plans, launches and watches, so it may sleep or lose its network while the study goes on.
 import { execFile } from "node:child_process";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
@@ -18,13 +18,19 @@ import { e2bConnection } from "../substrates/e2b/connection.js";
 import { acquireE2BShellSandbox } from "../substrates/e2b/sandbox.js";
 import { loadModalShellModule } from "../substrates/modal/sandbox.js";
 import { serveObserverProxy } from "./observer-proxy.js";
-import { installHumanish, listRemoteRun, readRemoteFile, readRemoteRun, RUNNER_OBSERVER_PORT, runnerOf, startRemoteRun, stopRemoteRun, uploadProject, } from "./runner.js";
+import { installHumanish, listRemoteRun, listSettledEvidence, readRemoteBytes, readRemoteFile, readRemoteRun, RUNNER_OBSERVER_PORT, runnerOf, startRemoteRun, stopRemoteRun, uploadProject, } from "./runner.js";
 /** How often the launcher reads the runner's run while it follows it. */
 const POLL_MS = 5_000;
 /** Reads in a row the runner may leave unanswered before the launcher gives it up. */
 const UNANSWERED_LIMIT = 24;
 /** How long the run has to write its status record after it is started. */
 const START_DEADLINE_MS = 3 * 60_000;
+/** How often the launcher copies the run's settled evidence while it goes on. */
+const SYNC_EVERY_MS = 30_000;
+/** How long a screenshot or recording must be unchanged before it is copied mid-run. */
+const SETTLED_SECONDS = 10;
+/** The largest file read back to compare digests: a recording's own limit, with room. */
+const LARGEST_FILE_BYTES = 256 * 1024 * 1024;
 /** How long a stopped run has to end and write its result. */
 const STOP_DEADLINE_MS = 2 * 60_000;
 /** Launch, follow and copy back one remote run. */
@@ -117,7 +123,15 @@ async function acquireRunner(launch, paths) {
 export async function followRemoteRun(args) {
     const { launch, runner, paths, runId, signals } = args;
     const { say } = launch;
-    const copy = () => copyRunBack(runner, paths, runId);
+    // Evidence already copied while the run went on, by path, with its size then.
+    const copied = new Map();
+    const copy = async () => {
+        const { files, alreadyHere } = await copyRunBack(runner, paths, runId);
+        if (alreadyHere > 0)
+            say(`${alreadyHere} of its ${files} files were already here.`);
+        return files;
+    };
+    let syncAt = Date.now() + SYNC_EVERY_MS;
     let state;
     let stopAt;
     let unanswered = 0;
@@ -188,6 +202,11 @@ export async function followRemoteRun(args) {
                 ...("files" in copied ? { files: copied.files } : {}),
             });
         }
+        if (state === "running" && Date.now() >= syncAt) {
+            syncAt = Date.now() + SYNC_EVERY_MS;
+            // Best effort: what this misses, the copy at the end takes.
+            await copySettledEvidence(runner, paths, runId, copied).catch(() => undefined);
+        }
         await new Promise((resolve) => setTimeout(resolve, POLL_MS));
     }
 }
@@ -198,9 +217,16 @@ export async function followRemoteRun(args) {
  */
 async function copyRunBack(runner, paths, runId) {
     const files = await listRemoteRun(runner, runId);
+    let alreadyHere = 0;
     for (const file of files) {
         if (file.path === "owner-key")
             continue;
+        // Already here with the same bytes, copied while the run went on or by an earlier attempt.
+        if (file.path !== SANDBOX_RECEIPTS_ARTIFACT &&
+            (await localDigest(paths, file.path)) === file.sha256) {
+            alreadyHere += 1;
+            continue;
+        }
         const bytes = await readRemoteFile(runner, runId, file);
         if (file.path === SANDBOX_RECEIPTS_ARTIFACT) {
             const local = await readContainedRegularFile(paths, file.path, 16 * 1024 * 1024);
@@ -211,13 +237,32 @@ async function copyRunBack(runner, paths, runId) {
         await writeContainedOutputFile(paths, file.path, bytes);
     }
     await pointLatestRunAt(paths, runId);
-    return files.length;
+    return { files: files.length, alreadyHere };
+}
+/**
+ * Copy the run's screenshots and recordings that have settled and are not here yet, while the run
+ * goes on, so the copy at its end is only what is left.
+ */
+async function copySettledEvidence(runner, paths, runId, copied) {
+    for (const file of await listSettledEvidence(runner, runId, SETTLED_SECONDS)) {
+        if (copied.get(file.path) === file.size)
+            continue;
+        await writeContainedOutputFile(paths, file.path, await readRemoteBytes(runner, runId, file.path));
+        copied.set(file.path, file.size);
+    }
 }
-/** Two sandbox journals as one: every line of each, in order, one per line. */
+async function localDigest(paths, file) {
+    const read = await readContainedRegularFile(paths, file, LARGEST_FILE_BYTES);
+    return read.status === "read" ? createHash("sha256").update(read.bytes).digest("hex") : undefined;
+}
+/**
+ * Two sandbox journals as one: every line of each, in order, once. A copy that runs again adds
+ * nothing it already added.
+ */
 export function joinJournals(...journals) {
-    const lines = journals
-        .flatMap((journal) => journal.split("\n"))
-        .filter((line) => line.trim() !== "");
+    const lines = [
+        ...new Set(journals.flatMap((journal) => journal.split("\n")).filter((line) => line.trim() !== "")),
+    ];
     return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
 }
 /**

package/dist/remote/runner.d.ts

@@ -59,6 +59,22 @@ export interface RemoteFile {
 export declare function listRemoteRun(runner: Runner, runId: string): Promise<RemoteFile[]>;
 /** sha256sum lines, `<hex>  ./<path>`, as RemoteFiles with paths relative to the directory. */
 export declare function parseDigests(output: string): RemoteFile[];
+/**
+ * The screenshots and recordings of the runner's run that have not changed for `settledSeconds`,
+ * with their sizes. A run writes each of them once, so one that has settled can be copied while
+ * the run goes on; files whose name starts with a dot are still being written.
+ */
+export declare function listSettledEvidence(runner: Runner, runId: string, settledSeconds: number): Promise<{
+    path: string;
+    size: number;
+}[]>;
+/** `find -printf '%p\t%s\n'` lines as paths and sizes; a path that leaves the directory is dropped. */
+export declare function parseSizes(output: string): {
+    path: string;
+    size: number;
+}[];
+/** The bytes of one file of the runner's run directory, as they are now. */
+export declare function readRemoteBytes(runner: Runner, runId: string, file: string): Promise<Uint8Array>;
 /** The bytes of one file of the runner's run directory, checked against its listed digest. */
 export declare function readRemoteFile(runner: Runner, runId: string, file: RemoteFile): Promise<Uint8Array>;
 /**

package/dist/remote/runner.js

@@ -189,16 +189,41 @@ export function parseDigests(output) {
     }
     return files;
 }
-/** The bytes of one file of the runner's run directory, checked against its listed digest. */
-export async function readRemoteFile(runner, runId, file) {
+/**
+ * The screenshots and recordings of the runner's run that have not changed for `settledSeconds`,
+ * with their sizes. A run writes each of them once, so one that has settled can be copied while
+ * the run goes on; files whose name starts with a dot are still being written.
+ */
+export async function listSettledEvidence(runner, runId, settledSeconds) {
+    const dir = `${RUNNER_PROJECT}/.humanish/runs/${runId}`;
+    const listed = await runner.shell.run(`cd ${shellQuote(dir)} 2>/dev/null && find screenshots recordings -type f ! -name '.*' ! -newermt '${settledSeconds} seconds ago' -printf '%p\\t%s\\n' 2>/dev/null`, { timeoutMs: 120_000 });
+    return parseSizes(listed.stdout);
+}
+/** `find -printf '%p\t%s\n'` lines as paths and sizes; a path that leaves the directory is dropped. */
+export function parseSizes(output) {
+    const files = [];
+    for (const line of output.split("\n")) {
+        const match = /^((?:screenshots|recordings)\/[^\t]+)\t(\d+)$/.exec(line);
+        if (match === null || match[1].split("/").includes(".."))
+            continue;
+        files.push({ path: match[1], size: Number(match[2]) });
+    }
+    return files;
+}
+/** The bytes of one file of the runner's run directory, as they are now. */
+export async function readRemoteBytes(runner, runId, file) {
     const read = runner.sandbox.files.read;
     if (read === undefined)
         throw new Error("This sandbox cannot read files back.");
-    const stream = await read.call(runner.sandbox.files, `${RUNNER_PROJECT}/.humanish/runs/${runId}/${file.path}`, { format: "stream", requestTimeoutMs: 300_000 });
+    const stream = await read.call(runner.sandbox.files, `${RUNNER_PROJECT}/.humanish/runs/${runId}/${file}`, { format: "stream", requestTimeoutMs: 300_000 });
     const parts = [];
     for await (const chunk of stream)
         parts.push(chunk);
-    const bytes = Buffer.concat(parts);
+    return Buffer.concat(parts);
+}
+/** The bytes of one file of the runner's run directory, checked against its listed digest. */
+export async function readRemoteFile(runner, runId, file) {
+    const bytes = await readRemoteBytes(runner, runId, file.path);
     const digest = createHash("sha256").update(bytes).digest("hex");
     if (digest !== file.sha256)
         throw new Error(`${file.path} changed or arrived damaged while it was copied from the runner.`);

package/docs/contracts/study-analysis.md

@@ -25,7 +25,8 @@ study's input and admission estimate without credentials, a provider request,
 or a new analysis artifact. It prints the expected cost, the worst case and the
 cap; a refused dry run says why, and names the `--max-cost` that admits it.
 
-The default provider is `openai`; its default model is `gpt-6-astra`, with high reasoning effort. A request sends selected retained text and
+The default provider is `openai`; its default model is `gpt-6.1-sol`, at medium reasoning effort
+([reasoning effort](#reasoning-effort)). A request sends selected retained text and
 captures to OpenAI, without tools, redirects, provider-side response storage, or
 automatic retries. `--question` adds a reviewer question; it never changes the
 participant assignment. For OpenAI API analysis, `--max-cost` is required, including for dry-run
@@ -118,6 +119,37 @@ the current merge instructions, billed $1.92, most of its input served from the
 provider's prompt cache, and each of its 466 citations resolved. Two runs do not
 calibrate the merge request's estimate.
 
+## Reasoning effort
+
+`review.analysis.reasoningEffort`, or `analyze --reasoning-effort <level>`, sets how long an API
+analyst reasons before it answers. OpenAI receives it as `reasoning.effort`, and Gemini as
+`generationConfig.thinkingConfig.thinkingLevel` in capitals. Each model takes the levels its
+provider documents for it (OpenAI's model pages and Gemini's thinking guide, read 2026-10-21):
+
+| Model                                                                   | Levels                                          |
+| ----------------------------------------------------------------------- | ----------------------------------------------- |
+| `gpt-6-astra`, `gpt-6.1-sol`                                            | `low`, `medium`, `high`, `xhigh`, `max`         |
+| `gpt-6-luna`, `gpt-5.6`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna` | `none`, `low`, `medium`, `high`, `xhigh`, `max` |
+| `gpt-5.5`                                                               | `none`, `low`, `medium`, `high`, `xhigh`        |
+| `gemini-3.8-flash`                                                      | `low`, `medium`, `high`                         |
+
+Any other level is refused before a request, with a message naming the levels the model takes.
+The Codex account analyst runs at its fixed low effort, and a declared effort with
+`provider: codex` is refused.
+
+The default analyst, an OpenAI analysis that names no model and declares no effort, is
+`gpt-6.1-sol` at `medium`, and its resolved configuration writes `reasoningEffort: medium`. A study
+or command that names a model but no effort runs that model at `high`; only the default analyst
+runs at medium. That analysis's configuration has no `reasoningEffort` field, so its configuration
+hash, and with it reuse of an earlier analysis, is what it was before the field existed. A declared effort is stored in the analysis artifact's
+`config`, `high` included, and gives the configuration its own hash. An artifact whose config has
+no `reasoningEffort` ran at `high`.
+
+Admission expects the same output at every effort, from analyses billed at `high`. No billed
+analysis at a lower effort calibrates a smaller expectation yet, so a lower effort's expected cost
+is likely over its bill: on 24 one-participant Taskly analyses on 2026-10-22, `gpt-6.1-sol` at
+medium wrote a mean 3,747 output tokens against the 13,000 admission expects. The worst case spends the whole output allowance at any effort.
+
 ## Gemini API analysis
 
 `review.analysis.provider: gemini`, or `analyze --provider gemini`, sends the same request to
@@ -131,7 +163,8 @@ humanish analyze --run latest --provider gemini --model gemini-3.8-flash --max-c
 
 The request goes to `generativelanguage.googleapis.com/v1beta/models/<model>:generateContent`
 with the key in the `x-goog-api-key` header. It carries the same instructions, packet and
-captures, with each capture at `MEDIA_RESOLUTION_HIGH`, thinking level `HIGH`, one candidate,
+captures, with each capture at `MEDIA_RESOLUTION_HIGH`, the analysis's reasoning effort as its
+thinking level (`HIGH` unless declared), one candidate,
 the standard service tier, no tools and `store: false`. The key is `GEMINI_API_KEY` when set,
 else `GOOGLE_API_KEY`. Google's client libraries prefer `GOOGLE_API_KEY`; humanish does not, so a
 `GOOGLE_API_KEY` exported for another Google API never replaces the stored Gemini key. Key

package/docs/product/automatic-analysis.md

@@ -10,8 +10,12 @@ Every other participant, including a Claude Code `local-agent` participant, gets
 analyst. humanish never moves a study to the other analyst because a key is missing: the account
 that pays for analysis is the one the study names or its participant implies.
 
-The OpenAI default is `gpt-6-astra` with high reasoning effort, a separate $10 cap on its
-expected cost and a 600-second timeout. When no output limit is specified,
+The OpenAI default is `gpt-6.1-sol` at medium reasoning effort (`review.analysis.reasoningEffort`
+sets another), a separate $10 cap on its
+expected cost and a 600-second timeout. A study or command that names a model but no effort runs
+that model at high; only the default analyst, with no model named, runs at medium. On the same
+recordings it matched `gpt-6-astra` at high, the earlier default, at about one seventh of the cost
+([analysis models on fixed recordings](https://github.com/danielgwilson/humanish/blob/main/docs/evidence/benchmark/2026-10-22-analysis-models.md)). When no output limit is specified,
 humanish selects 32,768 tokens if the exact input's expected cost still fits that
 cap; otherwise it keeps the established 16,384-token allowance. This preserves
 previously admitted studies without increasing their spending limit. To customize it:
@@ -21,7 +25,9 @@ review:
   analysis:
     maxCostUsd: 10
     # Optional overrides. Omit maxOutputTokens for budget-aware selection.
-    model: gpt-6-astra
+    # A named model without reasoningEffort runs at high.
+    model: gpt-6.1-sol
+    reasoningEffort: medium
     timeoutMs: 600000
     # maxOutputTokens: 32768
     # question: Where did participants need to recover?
@@ -41,9 +47,12 @@ the cap admits no analysis at all, it says so instead. A study of more than 16 p
 analysed in cohorts of at most 16, one request each, and one more request merges their reports;
 the range covers every request and the analysis line names them (see
 [runs with more than 16 participants](../contracts/study-analysis.md#runs-with-more-than-16-participants)).
-The default $10 cap admits a single request at the evidence limits ($3.79 expected for one
-participant, $4.54 for 16) and the analysis of 17 to 40 participants from $4.60 to $7.05 with no
-evidence; a run that keeps more evidence can still be refused, and its skip names the
+The default $10 cap admits the default analyst up to the evidence limits: a single request at
+$0.76 expected for one participant and $0.91 for 16, and 17 to 40 participants at $0.92 to $3.24
+from no evidence to the limits. Admission expects 13,000 output tokens for one participant at any
+effort; on 24 Taskly analyses `gpt-6.1-sol` at medium wrote a mean 3,747 and cost a mean $0.06.
+`gpt-6-astra` at high expects $3.79 for one participant at the limits and $4.60 to $7.05 for 17 to
+40 with no evidence, so a run that keeps more evidence can be refused, and its skip names the
 `--max-cost` that admits it. Use `analyze --dry-run --max-cost <usd>` on retained
 evidence to inspect the expected cost, the worst case and the selected token
 allowance before deliberately choosing a larger budget. Explicit
@@ -89,7 +98,8 @@ review:
     maxCostUsd: 2
 ```
 
-Gemini analysis sends the same evidence packet and captures to Google, at high thinking level,
+Gemini analysis sends the same evidence packet and captures to Google, at the high thinking level
+unless the study declares a `reasoningEffort`,
 with each capture at high media resolution. It reads `GEMINI_API_KEY`, which `humanish keys set
 gemini` stores, and `GOOGLE_API_KEY` only when `GEMINI_API_KEY` is unset. Key discovery treats
 the two names as one key: a project's `.humanish/local/provider.env` or the user store never adds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.142.0",
+  "version": "0.143.0",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",

package/skills/humanish/SKILL.md

@@ -98,7 +98,8 @@ exact returned path, not a basename that could resolve to another manifest.
 Analysis is separate from the participant. A study that declares no analyst
 gets one from its participant: a Codex `local-agent` participant, local or
 hosted, defaults to a separate Codex account analyst; every other participant,
-Claude Code included, defaults to the OpenAI API with a $10 admission budget.
+Claude Code included, defaults to the OpenAI API (`gpt-6.1-sol` at medium
+reasoning effort) with a $10 admission budget.
 Without `OPENAI_API_KEY` that OpenAI analysis is skipped, and the run output
 names the next command: `analyze --provider codex` when Codex is signed in. To
 select the restricted Codex ChatGPT account analyst on any supported study,
@@ -118,6 +119,12 @@ and a missing Gemini key never falls back to OpenAI. On a free-tier key, Google
 may use the content to improve its products; tell the user before a study with
 private evidence runs on one.
 
+`review.analysis.reasoningEffort` (or `analyze --reasoning-effort <level>`)
+sets an OpenAI or Gemini analyst's reasoning effort. When unset it is `medium`
+for the default analyst, which names no model, and `high` for a named model.
+Each model takes only the levels its provider documents, and `analyze` refuses
+the others before any request with the levels the model takes.
+
 When post-run analysis is refused for its cost, the run output and `humanish
 review` give its expected cost, its worst case and the command that runs it,
 `humanish analyze --run <id> --max-cost <n>`. Show the user those costs and run