humanish 0.117.0 → 0.118.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.118.0: Up to 100 participants, E2B concurrent sandboxes, study check plans like run, analysis range (2026-10-09)
+
+humanish 0.118.0 lets a computer-use study have up to 100 participants, up from 16, holds a
+shared-world study to the same 100, and runs them within the number of sandboxes the E2B plan runs
+at once. The new setting `HUMANISH_E2B_MAX_CONCURRENT_SANDBOXES` gives that number (20 when unset,
+E2B Hobby's limit; Pro runs 100). A study with more participants than that runs them in waves, an
+`execution.concurrency` above it is refused before any sandbox is created, and `doctor` shows it. A
+live run of more than 16 participants records its automatic analysis as skipped with
+`AUTOMATIC_ANALYSIS_PARTICIPANT_LIMIT`, because one analysis reads at most 16 participants. `study
+check` now plans a study the way `humanish run` does and fails a study the run refuses, and a
+shared-world or scripted clone study whose sandbox deadline passes the ceiling is refused at plan
+time. The analysis line that `run`, `study check` and the TUI print ends its expected range at the
+largest run admission admits (`$0.75 to $2.83` for one participant at the default $3 cap, where it
+read `$3.79`) and states the rule as admission applies it. An in-process `local-app` run records
+`subject.source: local-app`, a desktop-cli dry run names its product, and `verify` names an unlisted
+folder and the 10,000-entry stop in their own sentences. In `humanish tui`, the key legend says what
+Enter and Esc do while an action is armed, a study's median cost includes its analyses, and Esc
+after entering a key returns to the screen the keys were opened from.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.118.0)
+
 ## 0.117.0: Long participant waits, OpenAI wait length, serve.build fails fast, TUI confirmations (2026-10-09)
 
 humanish 0.117.0 lets a participant wait through a long hosted study, gives an OpenAI

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/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"}`]
             : []),

package/dist/cli/doctor.js

@@ -4,7 +4,7 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import { DOCTOR_KEYS, probeKeySources, } from "../keys/key-resolution.js";
 import { desktopPeerAdvice, humanishInstall, } from "../substrates/e2b/peer-install.js";
-import { describeSandboxCeiling, sandboxCeiling } from "../substrates/e2b/lifetime.js";
+import { concurrentSandboxes, describeConcurrentSandboxes, describeSandboxCeiling, sandboxCeiling, } from "../substrates/e2b/lifetime.js";
 import { nodeSupportsTui, terminalSurfaceMessage, TUI_BUNDLE_URL } from "../tui/contract.js";
 import { detectLocalAgents, localAgentDoctorMessage, localAgentReady, NO_LOCAL_AGENT_MESSAGE, } from "../actors/local-agent/cli.js";
 import { leftoverClaudeTranscripts } from "../actors/local-agent/claude-participant.js";
@@ -97,6 +97,7 @@ export async function doctor(cwdInput, options = {}) {
         ...(await projectChecks(projectRoot)),
         await desktopSdkCheck(setup),
         sandboxCeilingCheck(env),
+        concurrentSandboxesCheck(env),
         terminalSurfaceCheck(),
         ...versionCheck(env),
         ...localAgentChecks(agents),
@@ -198,6 +199,15 @@ function sandboxCeilingCheck(env) {
     const ceiling = sandboxCeiling(env);
     return { name: "e2b sandbox ceiling", ok: ceiling.ok, message: describeSandboxCeiling(ceiling) };
 }
+/** How many sandboxes the E2B planners run at once, and where that number came from. */
+function concurrentSandboxesCheck(env) {
+    const limit = concurrentSandboxes(env);
+    return {
+        name: "e2b concurrent sandboxes",
+        ok: limit.ok,
+        message: describeConcurrentSandboxes(limit),
+    };
+}
 /**
  * The optional peer dep every live browser and terminal route needs. `npx -y humanish` does not
  * pull optional peers, so without this check an adopter's first live run fails on it, safely and at

package/dist/cli/io.js

@@ -1,10 +1,10 @@
-import { automaticAnalysisSucceeded, } from "../analysis/automatic-completion.js";
 import { costRefusal, refusedCost } from "../analysis/admission.js";
 import { Command, Option } from "commander";
 import { loadEnvFile, recordDotenvNames } from "../keys/env-file.js";
 import { discoverProviderKeys } from "../keys/key-resolution.js";
 import { deriveRunFacts } from "./telemetry.js";
 import { warnAndQueue, withQueuedWarnings } from "./deprecations.js";
+import { PARTICIPANT_LIMIT_SKIP, PARTICIPANT_LIMIT_SKIP_TEXT, studyAnalysisSucceeded, } from "../study/automatic-analysis-plan.js";
 import { forTerminal } from "../routes/terminal/encoding.js";
 import { cli } from "./invocation.js";
 export const CLI_RESPONSE_SCHEMA = "humanish.cli-response.v1";
@@ -295,6 +295,7 @@ const ANALYSIS_REASON_TEXT = {
     AUTOMATIC_ANALYSIS_BUSY: "skipped because another analysis is running",
     AUTOMATIC_ANALYSIS_ADMISSION_REFUSED: "refused before it started: its configuration, question, evidence or cost did not pass admission",
     AUTOMATIC_ANALYSIS_CLEANUP_UNCONFIRMED: "not started because the run's cleanup was not confirmed",
+    [PARTICIPANT_LIMIT_SKIP]: PARTICIPANT_LIMIT_SKIP_TEXT,
     AUTOMATIC_ANALYSIS_REUSED: "complete, reusing an earlier analysis of the same evidence",
     AUTOMATIC_ANALYSIS_LIMITATIONS: "partial, because it covered only part of the evidence",
     AUTOMATIC_ANALYSIS_ADMISSION_EXCEEDED: "partial, because it went over its estimated cost or output",
@@ -320,5 +321,5 @@ export function automaticAnalysisEnvelope(result) {
         !("ok" in result))
         return result;
     const run = result;
-    return { ...run, runOk: run.ok, ok: run.ok && automaticAnalysisSucceeded(run) };
+    return { ...run, runOk: run.ok, ok: run.ok && studyAnalysisSucceeded(run) };
 }

package/dist/comms/lease-store.d.ts

@@ -1,4 +1,4 @@
-import type { ReceivingIdentity, ReceivingLease } from "./receiving-types.js";
+import { type ReceivingIdentity, type ReceivingLease } from "./receiving-types.js";
 declare const SCHEMA = "humanish.comms-lease-journal.v1";
 type PhysicalIdentity = {
     path: string;

package/dist/comms/lease-store.js

@@ -6,6 +6,7 @@ import { homedir, hostname } from "node:os";
 import path from "node:path";
 import { isRecord } from "../run/type-guards.js";
 import { isReceivingProviderId } from "./providers.js";
+import { MAX_RECEIVING_INBOXES, } from "./receiving-types.js";
 const SCHEMA = "humanish.comms-lease-journal.v1";
 const MAX_BYTES = 1_048_576;
 const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
@@ -117,7 +118,7 @@ function parseJournal(text) {
         !safeString(value.updatedAt) ||
         !Array.isArray(value.leases) ||
         value.leases.length < 1 ||
-        value.leases.length > 64)
+        value.leases.length > MAX_RECEIVING_INBOXES)
         fail();
     const participants = new Set();
     const leaseIds = new Set();
@@ -470,7 +471,7 @@ export class CommsLeaseStore {
             !KEY_ENV.test(options.apiKeyEnv) ||
             !validReceivingIdentity(options.identity) ||
             options.participants.length < 1 ||
-            options.participants.length > 64 ||
+            options.participants.length > MAX_RECEIVING_INBOXES ||
             new Set(options.participants).size !== options.participants.length ||
             options.participants.some((id) => !LOCAL_ID.test(id)))
             fail();

package/dist/comms/receiving-types.d.ts

@@ -3,6 +3,8 @@ import type { ReceivingProviderId } from "./providers.js";
 import type { CommsInlineImage } from "./types.js";
 /** authenticate() rejects with this code when the credential cannot acquire fresh inboxes. */
 export declare const RECEIVING_SCOPE_UNSUPPORTED = "comms_scope_unsupported";
+/** The most inboxes one run leases, one per participant; the lease journal holds this many. */
+export declare const MAX_RECEIVING_INBOXES = 64;
 export interface ReceivingContext {
     signal?: AbortSignal;
     timeoutMs?: number;

package/dist/comms/receiving-types.js

@@ -1,3 +1,5 @@
 /** authenticate() rejects with this code when the credential cannot acquire fresh inboxes. */
 export const RECEIVING_SCOPE_UNSUPPORTED = "comms_scope_unsupported";
+/** The most inboxes one run leases, one per participant; the lease journal holds this many. */
+export const MAX_RECEIVING_INBOXES = 64;
 export const COMMS_RECEIVING_SCHEMA = "humanish.comms-receiving.v2";