humanish 0.142.0 → 0.144.0

package/CHANGELOG.md

@@ -8,6 +8,27 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.144.0: Hosted studies run remotely by default (2026-10-22)
+
+humanish 0.144.0 runs a hosted computer-use study remotely by default. A study on
+`e2b-desktop` or `modal-desktop` with a public `app-url` runs its own process in a sandbox in your
+E2B or Modal account, so it keeps going when this machine sleeps; the command follows it, serves
+the live Observer here and copies the evidence back. Before the runner starts, the command names
+the keys it sends. Pass `--local` for one run, or set `execution.remote: false` in a study, to keep
+it on this machine.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.144.0)
+
+## 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/commands/run-command.js

@@ -20,7 +20,8 @@ export function addRunOptions(command) {
         .option("--dotenv <path>", DOTENV_OPTION_DESCRIPTION)
         .addOption(envFileAliasOption())
         .option("--run-id <id>", "Explicit run id for deterministic fixture tests; refused when that run already exists.")
-        .option("--remote", "Run the study's own process in a sandbox on its participants' provider (E2B or Modal), so it keeps going when this machine sleeps. This machine follows it, serves its live Observer and copies the run back. Computer-use studies with hosted desktops and an app-url subject.")
+        .addOption(new Option("--remote", "Require a remote run: the study's own process runs in a sandbox on its participants' provider, so it keeps going when this machine sleeps. A study that can is run this way by default; this refuses one that cannot, with the reason.").conflicts("local"))
+        .option("--local", "Run the study on this machine even when it could run remotely. It then stops if this machine sleeps.")
         .addOption(ownerKeyOption())
         .option("--json", JSON_OPTION_DESCRIPTION);
 }

package/dist/cli/commands/study-remote.d.ts

@@ -1,13 +1,45 @@
 import type { Command } from "commander";
 import { type RemoteOutcome } from "../../remote/launch.js";
+import { type RemotePlan } from "../../remote/plan.js";
+import type { RunResult } from "../../run/results.js";
 import type { StudyConfig } from "../../study/types.js";
 import { type CliIo, type StudyCommandOptions } from "../io.js";
+type RemoteErrorCode = "HUMANISH_REMOTE_REFUSED" | "HUMANISH_REMOTE_FAILED";
+/** Where a study's run executes, decided before anything is created. */
+export type RunPlacement = {
+    kind: "local";
+    note?: string;
+} | {
+    kind: "remote";
+    plan: RemotePlan;
+} | {
+    kind: "refused";
+    message: string;
+};
+/**
+ * Whether this run executes here or in a runner sandbox. A hosted study runs remotely by default
+ * when it can; `--local` or `execution.remote: false` keeps it here, and `--remote` or
+ * `execution.remote: true` requires a remote run, refused with the reason when the study cannot
+ * have one. `--local` and `--remote` win over the study's field.
+ */
+export declare function placeRun(args: {
+    options: StudyCommandOptions;
+    config: StudyConfig;
+    studyPath: string;
+    env?: Readonly<Record<string, string | undefined>>;
+    /** Whether this humanish is a built package a runner can install; read from the module when absent. */
+    packaged?: boolean;
+}): RunPlacement;
+/** A refused placement as the command's result. */
+export declare function refuseRemote(command: Command, io: CliIo, cwd: string, message: string, code?: RemoteErrorCode, forwarded?: NonNullable<RunResult["remote"]>): void;
+/** Launch `remote` in a runner sandbox and report how it ended. */
 export declare function runRemoteStudy(args: {
     command: Command;
     io: CliIo;
     options: StudyCommandOptions;
-    config: StudyConfig;
     studyPath: string;
+    remote: RemotePlan;
 }): Promise<void>;
 /** The command's result and exit code for a remote run that ended, stopped or detached. */
-export declare function reportRemoteOutcome(command: Command, io: CliIo, cwd: string, outcome: RemoteOutcome): void;
+export declare function reportRemoteOutcome(command: Command, io: CliIo, cwd: string, outcome: RemoteOutcome, forwarded?: NonNullable<RunResult["remote"]>): void;
+export {};