humanish 0.116.0 → 0.118.0

package/dist/actors/contract.d.ts

@@ -256,6 +256,15 @@ export interface ActorConversation {
         estimatedInputTokens?: number;
     }>;
 }
+/** How long a computer-use participant's waits lasted, in milliseconds. */
+export interface ActorWaitSettings {
+    /** The longest one wait action lasts (actor.maxWaitMs). A longer wait is shortened to it. */
+    maxWaitMs: number;
+    /** A wait with no duration in a turn that only waits or takes screenshots (actor.idleWaitMs). */
+    idleWaitMs: number;
+    /** A wait with no duration after the participant acts in the same turn. */
+    settleWaitMs: number;
+}
 export interface ActorTrace {
     schema: typeof ACTOR_TRACE_SCHEMA;
     provider: string;
@@ -303,6 +312,11 @@ export interface ActorTrace {
         reasoningEffort: string;
         maxOutputTokens?: number;
     };
+    /**
+     * Additive + optional: the wait lengths the computer-use loop applied, defaults included. Absent
+     * on other producers and on bundles written before it was recorded.
+     */
+    waitSettings?: ActorWaitSettings;
     counts: Record<string, number>;
     /**
      * Additive + optional affordance record (humanish.affordance-use.v1): which kind of route

package/dist/analysis/admission.d.ts

@@ -1,6 +1,11 @@
 import type { ModelRate } from "../run/pricing.js";
-/** Admission compares the expected cost times this margin with the cap. */
-export declare const ADMISSION_MARGIN = 1.1;
+/**
+ * When admission refuses a request, in words, for the cap as the sentence names it: `$3`, or `this`
+ * in the help of the option that sets it. Admission compares the smaller of the worst case and the
+ * expected cost with the margin, so it refuses only when both are over the cap. Every text that
+ * states the rule reads it here.
+ */
+export declare function admissionRule(cap: string): string;
 export interface AnalysisRequestSize {
     /** UTF-8 bytes of the instructions, the evidence packet and the result schema. */
     textBytes: number;

package/dist/analysis/admission.js

@@ -16,7 +16,17 @@ const FRAMING_TOKENS = 2048;
 const EXPECTED_OUTPUT_TOKENS = 12_000;
 const EXPECTED_OUTPUT_TOKENS_PER_PARTICIPANT = 1_000;
 /** Admission compares the expected cost times this margin with the cap. */
-export const ADMISSION_MARGIN = 1.1;
+const ADMISSION_MARGIN = 1.1;
+const MARGIN_PERCENT = Math.round((ADMISSION_MARGIN - 1) * 100);
+/**
+ * When admission refuses a request, in words, for the cap as the sentence names it: `$3`, or `this`
+ * in the help of the option that sets it. Admission compares the smaller of the worst case and the
+ * expected cost with the margin, so it refuses only when both are over the cap. Every text that
+ * states the rule reads it here.
+ */
+export function admissionRule(cap) {
+    return `both its worst case and its expected cost plus a ${MARGIN_PERCENT}% margin are over ${cap}`;
+}
 /** Rounded up to the micro-dollar, so a small positive boundary never rounds into admission. */
 const roundUp = (usd) => Math.ceil(usd * 1e6) / 1e6;
 /** One request's cost. Input is priced at the highest input rate the model bills, cache writes
@@ -47,9 +57,8 @@ export function estimateAnalysisCost(rate, size) {
  * This module keeps only type imports, so the Observer can bundle it.
  */
 export function costRefusal(cost, runFlags, cli) {
-    const margin = Math.round((ADMISSION_MARGIN - 1) * 100);
     return {
-        text: `The expected cost is $${cost.expectedCostUsd.toFixed(2)} and the worst case is $${cost.worstCaseCostUsd.toFixed(2)}. With a ${margin}% margin the expected cost is over the $${cost.maxCostUsd} cap, so no request was sent. To run it, raise the cap:`,
+        text: `The expected cost is $${cost.expectedCostUsd.toFixed(2)} and the worst case is $${cost.worstCaseCostUsd.toFixed(2)}. With a ${MARGIN_PERCENT}% margin the expected cost is over the $${cost.maxCostUsd} cap, so no request was sent. To run it, raise the cap:`,
         command: cli(`analyze ${runFlags} --max-cost ${Math.max(1, Math.ceil(cost.worstCaseCostUsd))}`),
     };
 }

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

@@ -36,11 +36,16 @@ export interface AutomaticAnalysisBudget {
     trigger: "default" | "explicit";
     /** The participants the expected cost range is for. */
     participants?: number;
-    /** The expected cost, from a run that keeps no evidence to one at the evidence limits. */
+    /**
+     * The expected cost of the analysis admission would start, from a run that keeps no evidence to
+     * one that keeps the most evidence admission admits, at most the evidence limits.
+     */
     expectedCostUsd?: {
         low: number;
         high: number;
     };
+    /** In place of the range when admission refuses even a run that keeps no evidence: its cost. */
+    refusedFromUsd?: number;
 }
 /** Metadata only: resolving the future live-run budget never reads keys or dispatches. With a
  * participant count it also gives the expected cost range for that many participants. */

package/dist/analysis/automatic-config.js

@@ -1,6 +1,6 @@
 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 { ADMISSION_MARGIN } from "./admission.js";
+import { admissionRule } from "./admission.js";
 import { plural } from "../run/text.js";
 import { containsSensitive } from "../evidence/redaction.js";
 export const DEFAULT_ANALYSIS_TIMEOUT_MS = 600_000;
@@ -123,11 +123,9 @@ export function automaticAnalysisBudget(raw, route, participants) {
     if (!resolved.ok || !resolved.config)
         return undefined;
     const { config } = resolved;
-    const range = participants === undefined || config.provider === "codex"
+    const range = participants === undefined
         ? undefined
-        : analysisCostRange(resolved.preferLargerOutput
-            ? { ...config, maxOutputTokens: MAX_ANALYSIS_OUTPUT_TOKENS }
-            : config, participants);
+        : analysisCostRange(config, participants, resolved.preferLargerOutput === true);
     return {
         ...(config.provider === "codex"
             ? { provider: "codex", billing: "account-unknown" }
@@ -135,16 +133,19 @@ export function automaticAnalysisBudget(raw, route, participants) {
         model: config.model,
         maxCostUsd: config.maxCostUsd,
         trigger: raw === undefined ? "default" : "explicit",
-        ...(range === undefined || participants === undefined
-            ? {}
-            : { participants, expectedCostUsd: range }),
+        ...(range === undefined || participants === undefined ? {} : { participants, ...range }),
     };
 }
 export function formatAutomaticAnalysisBudget(budget) {
     if (budget.provider === "codex")
         return `After live runs: 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.`;
-    const range = budget.expectedCostUsd === undefined || budget.participants === undefined
+    const rule = admissionRule(`$${budget.maxCostUsd}`);
+    const who = budget.participants === undefined ? undefined : plural(budget.participants, "participant");
+    const range = budget.expectedCostUsd === undefined || who === undefined
         ? ""
-        : ` · expected $${budget.expectedCostUsd.low.toFixed(2)} to $${budget.expectedCostUsd.high.toFixed(2)} for ${plural(budget.participants, "participant")}, depending on how much evidence the run keeps`;
-    return `After live runs: ${budget.trigger} analysis · ${budget.model}${range} · refused before it starts if the expected cost plus a ${Math.round((ADMISSION_MARGIN - 1) * 100)}% margin is over $${budget.maxCostUsd}; this is not a billing cap. Set review.analysis: false to disable.`;
+        : ` · expected $${budget.expectedCostUsd.low.toFixed(2)} to $${budget.expectedCostUsd.high.toFixed(2)} for ${who}, depending on how much evidence the run keeps`;
+    const refused = budget.refusedFromUsd === undefined || who === undefined
+        ? `refused before it starts if ${rule}`
+        : `refused before it starts for ${who} even with no evidence (expected $${budget.refusedFromUsd.toFixed(2)}), since ${rule}`;
+    return `After live runs: ${budget.trigger} analysis · ${budget.model}${range} · ${refused}; this is not a billing cap. Set review.analysis: false to disable.`;
 }

package/dist/analysis/execute.d.ts

@@ -43,14 +43,26 @@ export interface AnalysisProgress {
  */
 export declare function estimateAnalysisAdmission(input: AnalysisInput, config: AnalysisConfig): AnalysisAdmission;
 /**
- * The expected cost of an analysis for this many participants before any evidence exists: from a
- * packet with no evidence to one at the evidence limits with every capture at the image-token
- * ceiling. Undefined for Codex and for a model without rates.
+ * The expected cost of the analysis admission would start, before any evidence exists: from a
+ * packet with no evidence to the largest packet admission admits. When admission refuses even a
+ * packet with no evidence, `refusedFromUsd` is that packet's expected cost.
  */
-export declare function analysisCostRange(config: AnalysisConfig, participants: number): {
-    low: number;
-    high: number;
-} | undefined;
+export type AnalysisCostRange = {
+    expectedCostUsd: {
+        low: number;
+        high: number;
+    };
+} | {
+    refusedFromUsd: number;
+};
+/**
+ * The expected cost of the analysis admission would start for this many participants, before any
+ * evidence exists. Packets grow from no evidence toward the evidence limits with every capture at
+ * the image-token ceiling, and the range ends at the largest one admission admits, so it never
+ * passes the cap. With `preferLargerOutput` each packet gets the output allowance dispatch would
+ * give it (preferLargerAnalysisOutput). 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. */

package/dist/analysis/execute.js

@@ -217,12 +217,16 @@ export function estimateAnalysisAdmission(input, config) {
 /** Structure each evidence entry adds to the packet: ids, kind, timestamps and flags. The largest
  * retained packet averaged 200 bytes. */
 const ENTRY_STRUCTURE_BYTES = 256;
+/** How much a range bisection narrows the share of the evidence limits: 2^-40 of them. */
+const RANGE_BISECTIONS = 40;
 /**
- * The expected cost of an analysis for this many participants before any evidence exists: from a
- * packet with no evidence to one at the evidence limits with every capture at the image-token
- * ceiling. Undefined for Codex and for a model without rates.
+ * The expected cost of the analysis admission would start for this many participants, before any
+ * evidence exists. Packets grow from no evidence toward the evidence limits with every capture at
+ * the image-token ceiling, and the range ends at the largest one admission admits, so it never
+ * passes the cap. With `preferLargerOutput` each packet gets the output allowance dispatch would
+ * give it (preferLargerAnalysisOutput). Undefined for Codex and for a model without rates.
  */
-export function analysisCostRange(config, participants) {
+export function analysisCostRange(config, participants, preferLargerOutput = false) {
     if (config.provider === "codex")
         return undefined;
     const rate = MODEL_RATES[config.model];
@@ -230,26 +234,60 @@ export function analysisCostRange(config, participants) {
         return undefined;
     const prompt = Buffer.byteLength(instructions(config)) +
         Buffer.byteLength(JSON.stringify(analysisResultJsonSchema));
-    const size = {
+    /** The request for a share of the evidence limits, from none (0) to all of them (1). */
+    const request = (share, outputAllowance) => estimateAnalysisCost(rate, {
         participants: Math.min(participants, EVIDENCE_LIMITS.participants),
-        outputAllowance: config.maxOutputTokens,
-    };
-    const low = estimateAnalysisCost(rate, { ...size, textBytes: prompt, imageTokens: 0 });
-    const high = estimateAnalysisCost(rate, {
-        ...size,
-        textBytes: prompt + EVIDENCE_LIMITS.textBytes + EVIDENCE_LIMITS.evidence * ENTRY_STRUCTURE_BYTES,
-        imageTokens: EVIDENCE_LIMITS.captures * HIGH_DETAIL_IMAGE_TOKEN_CEILING,
+        outputAllowance,
+        textBytes: prompt +
+            share * (EVIDENCE_LIMITS.textBytes + EVIDENCE_LIMITS.evidence * ENTRY_STRUCTURE_BYTES),
+        imageTokens: share * EVIDENCE_LIMITS.captures * HIGH_DETAIL_IMAGE_TOKEN_CEILING,
     });
-    return { low: low.expectedCostUsd, high: high.expectedCostUsd };
+    const admits = (share, allowance) => request(share, allowance).admittedCostUsd <= config.maxCostUsd;
+    // Cost grows with the share, so admission admits each allowance up to one share of the limits.
+    const largestAdmitted = (allowance) => {
+        if (admits(1, allowance))
+            return 1;
+        let [admitted, refused] = [0, 1];
+        for (let step = 0; step < RANGE_BISECTIONS; step += 1) {
+            const share = (admitted + refused) / 2;
+            if (admits(share, allowance))
+                admitted = share;
+            else
+                refused = share;
+        }
+        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,
+    ];
+    const admitted = allowances.filter((allowance) => admits(0, allowance));
+    if (admitted.length === 0)
+        return { refusedFromUsd: request(0, config.maxOutputTokens).expectedCostUsd };
+    return {
+        expectedCostUsd: {
+            low: request(0, admitted[0]).expectedCostUsd,
+            high: Math.max(...admitted.map((allowance) => request(largestAdmitted(allowance), allowance).expectedCostUsd)),
+        },
+    };
+}
+/** 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)
+        return undefined;
+    return { ...config, maxOutputTokens: MAX_ANALYSIS_OUTPUT_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) {
-    if (config.provider === "codex" || config.maxOutputTokens !== DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS)
-        return config;
-    const expanded = { ...config, maxOutputTokens: MAX_ANALYSIS_OUTPUT_TOKENS };
-    return estimateAnalysisAdmission(input, expanded).allowed ? expanded : config;
+    const expanded = largerOutput(config);
+    return expanded !== undefined && estimateAnalysisAdmission(input, expanded).allowed
+        ? expanded
+        : config;
 }
 /** Scrub only generated prose. Source evidence, provenance and integrity hashes remain exact. A
  * known value is found as written and in its encoded forms. */

package/dist/browser-control/protocol.d.ts

@@ -26,7 +26,7 @@ export interface BrowserControlIdentity {
     challenge: string;
     runtimeRevision: string;
 }
-export declare const browserOnlyControlActionSchema: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
+export declare const participantActionSchema: z.ZodPipe<z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
     x: z.ZodNumber;
     y: z.ZodNumber;
     kind: z.ZodLiteral<"click">;
@@ -66,8 +66,88 @@ export declare const browserOnlyControlActionSchema: z.ZodDiscriminatedUnion<rea
     ms: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"screenshot">;
-}, z.core.$strict>], "kind">;
-export declare const browserControlActionSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
+}, z.core.$strict>], "kind">, z.ZodTransform<{
+    kind: "click";
+    x: number;
+    y: number;
+    button?: "left" | "right" | "middle";
+    heldKeys?: string[];
+} | {
+    kind: "double_click";
+    x: number;
+    y: number;
+    heldKeys?: string[];
+} | {
+    kind: "move";
+    x: number;
+    y: number;
+    heldKeys?: string[];
+} | {
+    kind: "scroll";
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+    heldKeys?: string[];
+} | {
+    kind: "type";
+    text: string;
+} | {
+    kind: "keypress";
+    keys: string[];
+} | {
+    kind: "drag";
+    path: Array<{
+        x: number;
+        y: number;
+    }>;
+    heldKeys?: string[];
+} | {
+    kind: "wait";
+    ms?: number;
+} | {
+    kind: "speak";
+    text: string;
+} | {
+    kind: "screenshot";
+}, {
+    kind: "type";
+    text: string;
+} | {
+    kind: "keypress";
+    keys: string[];
+} | {
+    kind: "screenshot";
+} | {
+    x: number;
+    y: number;
+    kind: "click";
+    button?: "left" | "middle" | "right" | undefined;
+} | {
+    x: number;
+    y: number;
+    kind: "double_click";
+} | {
+    x: number;
+    y: number;
+    kind: "move";
+} | {
+    x: number;
+    y: number;
+    kind: "scroll";
+    dx: number;
+    dy: number;
+} | {
+    kind: "drag";
+    path: {
+        x: number;
+        y: number;
+    }[];
+} | {
+    kind: "wait";
+    ms?: number | undefined;
+}>>;
+export declare const participantSpeechActionSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
     x: z.ZodNumber;
     y: z.ZodNumber;
     kind: z.ZodLiteral<"click">;
@@ -160,9 +240,6 @@ export declare const browserControlActionSchema: z.ZodPipe<z.ZodDiscriminatedUni
 } | {
     kind: "keypress";
     keys: string[];
-} | {
-    kind: "wait";
-    ms?: number | undefined;
 } | {
     kind: "screenshot";
 } | {
@@ -193,6 +270,9 @@ export declare const browserControlActionSchema: z.ZodPipe<z.ZodDiscriminatedUni
         x: number;
         y: number;
     }[];
+} | {
+    kind: "wait";
+    ms?: number | undefined;
 }>>;
 declare const observationSchema: z.ZodObject<{
     png: z.ZodString;

package/dist/browser-control/protocol.js

@@ -64,13 +64,18 @@ const dragAction = z.strictObject({
 });
 const typeAction = z.strictObject({ kind: z.literal("type"), text });
 const keypressAction = z.strictObject({ kind: z.literal("keypress"), keys: chord });
+const waitMs = z.number().finite().min(0);
+// One request carries one wait, so the wire bounds it by the request deadline.
 const waitAction = z.strictObject({
     kind: z.literal("wait"),
-    ms: z.number().finite().min(0).max(BROWSER_CONTROL_LIMITS.waitMs).optional(),
+    ms: waitMs.max(BROWSER_CONTROL_LIMITS.waitMs).optional(),
 });
+// A participant may ask for any wait: the loop shortens it to the study's longest and sends it in
+// steps the wire accepts.
+const participantWaitAction = z.strictObject({ kind: z.literal("wait"), ms: waitMs.optional() });
 const screenshotAction = z.strictObject({ kind: z.literal("screenshot") });
 const speakAction = z.strictObject({ kind: z.literal("speak"), text: speechText });
-const browserActionSchemas = [
+const participantActionSchemas = [
     clickAction,
     doubleClickAction,
     moveAction,
@@ -78,13 +83,15 @@ const browserActionSchemas = [
     typeAction,
     keypressAction,
     dragAction,
-    waitAction,
+    participantWaitAction,
     screenshotAction,
 ];
 // The Codex participant's tool schema: no held keys, so its tool surface stays as published.
-export const browserOnlyControlActionSchema = z.discriminatedUnion("kind", browserActionSchemas);
-export const browserControlActionSchema = z
-    .discriminatedUnion("kind", [...browserActionSchemas, speakAction])
+export const participantActionSchema = z
+    .discriminatedUnion("kind", participantActionSchemas)
+    .transform(toCuaAction);
+export const participantSpeechActionSchema = z
+    .discriminatedUnion("kind", [...participantActionSchemas, speakAction])
     .transform(toCuaAction);
 // What crosses the host-guest wire: the participant actions plus held keys on pointer actions,
 // which the OpenAI provider maps from its computer tool.

package/dist/cli/commands/analyze.js

@@ -2,6 +2,7 @@ import { resolveAutomaticAnalysis, DEFAULT_ANALYSIS_MODEL, DEFAULT_ANALYSIS_TIME
 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 { listAnalyses } from "../../analysis/store.js";
 import { listAnalysisExecutions } from "../../analysis/store-executions.js";
 import { resolveRunPath } from "../../run/locate.js";
@@ -30,7 +31,7 @@ export function registerAnalyzeCommand(parent, io) {
         .option("--run <id>", RUN_OPTION_DESCRIPTION, "latest")
         .option("--cwd <path>", CWD_OPTION_DESCRIPTION, ".")
         .option("--provider <name>", "Analyst: openai (default) or restricted codex account. No provider fallback.")
-        .option("--max-cost <usd>", "Required for OpenAI, also with --dry-run: send nothing when the expected cost in USD, plus a 10% margin, is above this. It does not limit billing. Unsupported for Codex.")
+        .option("--max-cost <usd>", `Required for OpenAI, 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>", "Supported vision model. OpenAI uses high effort; qualified Codex account analysis uses low effort.", DEFAULT_ANALYSIS_MODEL)
         .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))

package/dist/cli/commands/study-format.js

@@ -1,5 +1,6 @@
 import { participantCaption } from "../../run/participant-caption.js";
 import { formatCuaDiagnostics, formatCuaStopCause } from "../../routes/computer-use/diagnostics.js";
+import { subjectName } from "../../run/subject-name.js";
 /**
  * A run's first lines: the command that ran, whether it was a dry run, how it ended, and its route.
  * `runOk` is the run's own ok, which automaticAnalysisEnvelope keeps when an analysis that did not
@@ -38,16 +39,12 @@ function sandboxIdsLine(result) {
         : [];
 }
 /**
- * How a run's output names its subject: by the URL its participants open. A product studied at a
- * desktop has no URL, so it is named with its source, as in `humanish (desktop-cli)`. A refusal
- * made before the route resolved a URL has none either, so it names the URL the study declares.
+ * The `subject:` line's name for the study's declared subject. A refusal made before the route
+ * resolved a URL has none, so it names the URL the study declares.
  */
-function subjectName(appUrl, subject) {
-    if (appUrl !== "")
-        return appUrl;
-    if (subject.product !== undefined)
-        return `${subject.product.name} (${subject.source})`;
-    return subject.appUrl ?? subject.serve?.url ?? subject.source;
+function subjectLine(appUrl, subject) {
+    const named = subjectName(appUrl, { source: subject.source, product: subject.product?.name });
+    return named !== "" ? named : (subject.appUrl ?? subject.serve?.url ?? subject.source);
 }
 /** A participant's status in words: a dry run's placeholder status says that nothing ran live. */
 function participantStatus(status) {
@@ -107,7 +104,7 @@ export function formatScriptedStudyHuman(result, subject) {
         ...runHeader(result, "scripted"),
         `run: ${result.runId}`,
         `actor: ${result.actor}`,
-        `subject: ${subjectName(result.appUrl, subject)}`,
+        `subject: ${subjectLine(result.appUrl, subject)}`,
         ...(result.scenario
             ? [
                 `scenario: ${result.scenario.id} @ ${result.scenario.sourceDigest.slice(0, 12)} (${result.scenario.source}, ${result.scenario.steps} step${result.scenario.steps === 1 ? "" : "s"})`,
@@ -133,7 +130,7 @@ export function formatCuaStudyHuman(result, subject) {
         ...runHeader(result, "computer-use"),
         `run: ${result.runId}`,
         `actor: ${result.actor}`,
-        `subject: ${subjectName(result.appUrl, subject)}`,
+        `subject: ${subjectLine(result.appUrl, subject)}`,
         ...(result.subject?.source === "clone"
             ? [
                 `repo: ${result.subject.repo}${result.subject.commit ? `@${result.subject.commit.slice(0, 12)}` : ""}${result.subject.envNames && result.subject.envNames.length > 0 ? ` env=[${result.subject.envNames.join(", ")}]` : ""}`,

package/dist/cli/commands/study-route-computer-use.js

@@ -1,4 +1,4 @@
-import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
+import { studyAnalysisSucceeded } from "../../study/automatic-analysis-plan.js";
 import { Command } from "commander";
 import {} from "../../run-study.js";
 import { resolveStudyDryRun } from "../../study/plan.js";
@@ -237,7 +237,7 @@ async function reportCuaRun(args, prepared, result, live) {
         };
     }
     writeResult(args.command, args.io, output, (value) => formatCuaStudyHuman(value, args.config.subject));
-    args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
+    args.io.setExitCode(result.ok && studyAnalysisSucceeded(result) ? 0 : 2);
     await writeRunFindings(args.command, args.io, args.options.cwd, result);
     if (server && (result.observer?.ok || attachedObserver)) {
         const followResult = output.observer?.ok

package/dist/cli/commands/study-route-scripted.js

@@ -1,4 +1,4 @@
-import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
+import { studyAnalysisSucceeded } from "../../study/automatic-analysis-plan.js";
 import { Command } from "commander";
 import { cliAnalysisOptions } from "./analysis-signals.js";
 import { wantsJson, writeResult } from "../io.js";
@@ -35,7 +35,7 @@ export function scriptedRouteRun(args) {
             }
             const result = outcome.result;
             writeResult(args.command, args.io, result, (value) => formatScriptedStudyHuman(value, args.config.subject));
-            args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
+            args.io.setExitCode(result.ok && studyAnalysisSucceeded(result) ? 0 : 2);
             await writeRunFindings(args.command, args.io, args.options.cwd, result);
             // Watch mode serves the Observer the route rendered through its finished run.
             if (finishedPlan !== undefined && result.ok && result.observer !== undefined) {

package/dist/cli/commands/study-route-shared-world.js

@@ -1,4 +1,4 @@
-import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
+import { studyAnalysisSucceeded } from "../../study/automatic-analysis-plan.js";
 import { Command } from "commander";
 import { resolveStudyDryRun } from "../../study/plan.js";
 import { serveObserver } from "../../observer/render.js";
@@ -39,7 +39,9 @@ export function sharedWorldRouteRun(args) {
             topology: "shared-world",
             topologyMode: "concurrent",
             roleCount: participantList(args.config)?.length ?? 0,
-            concurrency: args.config.execution?.concurrency ?? 1,
+            // Refused before it planned: the declared cap, else every participant.
+            concurrency: args.config.execution?.concurrency ??
+                Math.max(1, participantList(args.config)?.length ?? 0),
             dryRun,
             runId: runId ?? args.options.runId ?? "not-created",
             roles: [],
@@ -119,7 +121,7 @@ export function sharedWorldRouteRun(args) {
                 };
             }
             writeResult(args.command, args.io, output, formatConcurrentSharedWorldStudyHuman);
-            args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
+            args.io.setExitCode(result.ok && studyAnalysisSucceeded(result) ? 0 : 2);
             await writeRunFindings(args.command, args.io, args.options.cwd, result);
             if (server && output.observer?.ok) {
                 await followObserver(args.io, output.observer, server);

package/dist/cli/commands/study-route-terminal.js

@@ -1,4 +1,4 @@
-import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
+import { studyAnalysisSucceeded } from "../../study/automatic-analysis-plan.js";
 import { Command } from "commander";
 import { cliAnalysisOptions } from "./analysis-signals.js";
 import { wantsJson, writeResult } from "../io.js";
@@ -35,7 +35,7 @@ export function terminalRouteRun(args) {
             }
             const result = outcome.result;
             writeResult(args.command, args.io, result, formatTerminalStudyHuman);
-            args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
+            args.io.setExitCode(result.ok && studyAnalysisSucceeded(result) ? 0 : 2);
             await writeRunFindings(args.command, args.io, args.options.cwd, result);
             if (finishedPlan !== undefined && result.ok && result.observer !== undefined) {
                 await showObserver({

package/dist/cli/commands/study-run.js

@@ -1,8 +1,8 @@
-import { automaticAnalysisBudget, formatAutomaticAnalysisBudget, } from "../../analysis/automatic-config.js";
 import { resolve } from "node:path";
 import { Command } from "commander";
 import { deriveRunFacts } from "../telemetry.js";
 import { resolveStudyManifest } from "../../study/discover.js";
+import { formatStudyAnalysisBudget, studyAnalysisBudget, } from "../../study/automatic-analysis-plan.js";
 import { warnAndQueue } from "../deprecations.js";
 import { planStudy, resolveStudyDryRun } from "../../study/plan.js";
 import { keyNamesOf } from "../../study/requirements.js";
@@ -131,9 +131,9 @@ export async function runStudyCommand(args) {
                 // Surface it so the invoker (who may not be the manifest author) knows executable code ran.
                 args.io.writeErr(`warning: review scorer ${scorer.provenance.ref} (${scorer.provenance.source}) is code that humanish loaded and ran in this process. Review it as you would any code you run.\n`);
             }
-            const analysisBudget = automaticAnalysisBudget(config.review?.analysis, route, computerUseParticipantCount(config));
+            const analysisBudget = studyAnalysisBudget(config.review?.analysis, route, computerUseParticipantCount(config));
             if (analysisBudget && resolveStudyDryRun(config, args.options.dryRun, true) === false) {
-                args.io.writeErr(`${formatAutomaticAnalysisBudget(analysisBudget)}\n`);
+                args.io.writeErr(`${formatStudyAnalysisBudget(analysisBudget)}\n`);
             }
             return scorer === undefined ? {} : { scorer };
         }, 

package/dist/cli/commands/study.js

@@ -1,4 +1,4 @@
-import { formatAutomaticAnalysisBudget } from "../../analysis/automatic-config.js";
+import { formatStudyAnalysisBudget } from "../../study/automatic-analysis-plan.js";
 import { resolve } from "node:path";
 import { Command, Option } from "commander";
 import { inspectStudyManifest, listStudyManifests } from "../../study/discover.js";
@@ -136,7 +136,7 @@ function formatStudyCheckHuman(result) {
         `targets: ${checkedTargets.length ? `${reachableTargets.length}/${checkedTargets.length} reachable` : `${result.targets.length} declared, not checked`}`,
         ...(blockedTargets.length ? [`blocked-targets: ${blockedTargets.length}`] : []),
         `spend: ${result.spend.e2bDesktop ? "one e2b desktop, no model calls" : "none"}`,
-        ...(result.analysis ? [formatAutomaticAnalysisBudget(result.analysis)] : []),
+        ...(result.analysis ? [formatStudyAnalysisBudget(result.analysis)] : []),
         ...(result.sandbox.created
             ? [`sandbox: created=yes killed=${result.sandbox.killed === true ? "yes" : "no"}`]
             : []),