humanish 0.126.0 → 0.127.1

package/dist/routes/computer-use/fanout-bundle.js

@@ -1,6 +1,7 @@
 import { e2bDesktopTemplate } from "../../substrates/e2b/sandbox.js";
 import { receivingPublication } from "../../comms/receiving-runtime.js";
 import { actorEnding } from "../../actors/stop-cause.js";
+import { cuaGoalSource } from "../../actors/goal-source.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, gapsListClause, withCuaReviewProvenance, } from "../../run/outcomes.js";
@@ -36,14 +37,18 @@ function fanoutPlanEvents(args) {
 }
 /**
  * The run's summary in plain sentences: who took part, what happened to them with the denominator
- * attached, and that the gaps list the participants who did not pass.
+ * attached, and that the gaps list the participants who did not pass. A participant the run
+ * skipped before its session started never used the app, so it is counted in a sentence of its
+ * own.
  */
 function fanoutSummary(args, facts) {
     const count = args.specs.length;
     const people = plural(count, "participant");
     const rerun = args.rerun === undefined ? "" : `Rerun from ${args.rerun.sourceRunId}: `;
+    // The live summary is written once, before any participant starts, so it names the plan: by
+    // the time it is read a participant may still be waiting, or skipped.
     if (args.inProgress === true) {
-        return `${people} ${count === 1 ? "is" : "are"} each using their own copy of the app. The run is still going, so nothing here is final.`;
+        return `${people} ${count === 1 ? "is planned, in its own copy" : "are planned, each in their own copy"} of the app. The run is still going, so nothing here is final.`;
     }
     if (args.dryRun) {
         return `${rerun}Dry run: ${people} would each use their own copy of ${subjectName(publicSafeAppUrlLabel(args.appUrl), args.aggregateSubject)}. No desktops were launched and $0 was spent.`;
@@ -51,7 +56,20 @@ function fanoutSummary(args, facts) {
     const tasks = facts.tasks === undefined ? "" : ` Tasks: ${facts.tasks}.`;
     // A host suspension comes first: it may explain everything after it.
     const host = args.hostSuspension === undefined ? "" : `${args.hostSuspension.summary} `;
-    return `${host}${rerun}${people} took part, each in their own copy of the app: ${facts.outcomes}${gapsListClause(count - facts.passed, count)}.${tasks}`;
+    const tookPart = count - facts.skipped;
+    const outcomes = facts.outcomes ?? `0/${tookPart} finished a session`;
+    const gaps = gapsListClause(tookPart - facts.passed, tookPart);
+    const sentences = [];
+    // A run where every participant was skipped has no one to describe in this sentence.
+    if (tookPart > 0)
+        sentences.push(`${plural(tookPart, "participant")} took part, ${tookPart === 1 ? "in its own copy" : "each in their own copy"} of the app: ${outcomes}${gaps}.`);
+    // The gaps are pointed at once: here only when the sentence before did not.
+    const why = gaps === "" ? "; the gaps say why" : "";
+    if (facts.skipped === 1)
+        sentences.push(`1 participant was skipped before its session started${why}.`);
+    if (facts.skipped > 1)
+        sentences.push(`${facts.skipped} participants were skipped before their sessions started${why}.`);
+    return `${host}${rerun}${sentences.join(" ")}${tasks}`;
 }
 /**
  * The review's gaps: one line for the participants a host suspension likely failed, then a line
@@ -74,6 +92,7 @@ function fanoutReview(args, streams, judgment) {
     // The judge's verdict: live fan-out must prove every participant (judgeParticipants).
     const verdict = args.verdict;
     const passedParticipants = judgment.participants.filter((participant) => participant.judgedStatus === "passed").length;
+    const skippedParticipants = (outcomes ?? []).filter((outcome) => outcome?.skippedReason !== undefined).length;
     // What happened to the participants, with the denominator attached. The verdict above has to
     // collapse the run to one word; this does not (docs/principles/three-roles.md).
     const terminalOutcomes = (outcomes ?? []).filter((outcome) => outcome?.session?.status !== undefined);
@@ -86,9 +105,11 @@ function fanoutReview(args, streams, judgment) {
     const runTasks = args.inProgress === true ? undefined : aggregateTaskFunnels(participantFunnels);
     const participantEndings = terminalOutcomes.map((outcome) => {
         const ending = actorEnding(outcome.session.trace);
+        const goalSource = cuaGoalSource(outcome.session.trace);
         return {
             status: outcome.session.status,
             ...(ending === undefined ? {} : { label: ending.label }),
+            ...(goalSource === undefined ? {} : { goalSource }),
         };
     });
     const review = withCuaReviewProvenance({
@@ -100,9 +121,10 @@ function fanoutReview(args, streams, judgment) {
         // sandbox, so the summary carries its digest, which verify accepts in a shared run.
         summary: fanoutSummary(args, {
             passed: passedParticipants,
-            outcomes: participants === undefined
-                ? `0/${args.specs.length} finished a session`
-                : formatParticipantOutcomes(participants, participantEndings),
+            skipped: skippedParticipants,
+            ...(participants === undefined
+                ? {}
+                : { outcomes: formatParticipantOutcomes(participants, participantEndings) }),
             ...(runTasks === undefined ? {} : { tasks: formatRunTaskFunnel(runTasks) }),
         }),
         gaps: args.inProgress === true

package/dist/routes/computer-use/fanout-records.js

@@ -72,7 +72,7 @@ function fanoutParticipantRecord(args, spec, index, view) {
         updatedAt: args.run.createdAt,
         ...(args.participantPlan.schedule === undefined
             ? {}
-            : { arrival: arrivalRecord(spec.planned.startAfterMs, outcome?.arrival) }),
+            : { arrival: arrivalRecord(spec.planned.schedule.startAfterMs, outcome?.arrival) }),
     });
 }
 function fanoutParticipantStream(args, spec, view) {

package/dist/routes/computer-use/participant-execution.js

@@ -4,7 +4,7 @@ import { createE2BParticipantDesktop } from "./e2b-desktop/desktop.js";
 import { createInProcessDesktop } from "./in-process-desktop.js";
 import path from "node:path";
 import { cuaParticipantDiagnostics } from "./diagnostics.js";
-import { runOnSchedule } from "../../study/arrivals.js";
+import { pastEndReason, runOnSchedule } from "../../study/arrivals.js";
 import { assertScreenshotEvidence, stripPngMetadataChunks } from "../../evidence/image.js";
 import { redactText, toErrorMessage } from "../../evidence/redaction.js";
 import { assertSafeOutputPathSegment, writeContainedOutputFile, } from "../../run/contained-output.js";
@@ -59,6 +59,10 @@ export async function runCuaParticipant(spec, deps) {
     if (crossed !== undefined) {
         return skippedOutcome(spec, `skipped: study budget reached before this participant started: ${crossed}; no desktop was created`);
     }
+    // One that waited for a slot until its scheduled end would only be asked for its closing report.
+    const pastEnd = pastEndReason(deps.end, deps.now());
+    if (pastEnd !== undefined)
+        return skippedOutcome(spec, pastEnd);
     let model = {};
     const warnings = [];
     const screenshots = [];
@@ -207,7 +211,7 @@ export async function runCuaParticipants(runs, deps, concurrency, runParticipant
     // An app-url subject is only opened, so one participant's start says nothing about another's.
     const gate = pipelineGate(deps.subject.kind === "app-url", () => stopping.abort());
     return runOnSchedule(runs, {
-        startAfterMs: (spec) => spec.planned.startAfterMs,
+        startAfterMs: (spec) => spec.planned.schedule.startAfterMs,
         slots: concurrency,
         now: deps.now,
         signal: stopping.signal,

package/dist/routes/computer-use/participant-facts.js

@@ -1,11 +1,13 @@
 // A participant run outcome's facts for the judge (src/run/judge.ts), and the pass check built on
 // them. The bundle builders, the result, the participant runner and shared-world all read these,
-// so they sit in a file that imports only the judge and the types.
+// so they sit in a file that imports only the judge, the clock-end rule and the types.
+import { ranUntilClockEnd } from "../../actors/goal-source.js";
 import { participantHarnessFailed, participantPassed, sandboxCleanupFailure, } from "../../run/judge.js";
 /** A participant outcome's facts for the judge. */
 export function participantFactsOf(outcome) {
     if (outcome === undefined)
         return { skipped: false, noEngagement: false, selfReportedBlocker: false };
+    const ranUntil = outcome.session === undefined ? undefined : ranUntilClockEnd(outcome.session.trace);
     return {
         id: outcome.spec.planned.id,
         ...(outcome.skippedReason === undefined ? {} : { skippedReason: outcome.skippedReason }),
@@ -21,6 +23,7 @@ export function participantFactsOf(outcome) {
         skipped: outcome.skippedReason !== undefined,
         noEngagement: outcome.noEngagement === true,
         selfReportedBlocker: outcome.selfReportedBlocker === true,
+        ...(ranUntil === undefined ? {} : { ranUntil }),
     };
 }
 /** Whether a participant passed. A dry-run participant passes as a contract. */

package/dist/routes/computer-use/participant-runs.d.ts

@@ -4,7 +4,7 @@ import { type ResolvedPersona } from "../../study/persona.js";
 import { type RunRerunLineage } from "../../run/bundle.js";
 import type { PreparedSelectedOutputDirectory } from "../../run/contained-output.js";
 import { type CuaActorStudyErrorCode, type CuaParticipantDeps, type CuaParticipantPlan, type CuaParticipantPlanEntry, type DesktopParticipantRun, type ParticipantRunsAndPlan } from "./types.js";
-import { type ParticipantWindow } from "../../study/arrivals.js";
+import { type ParticipantSchedule } from "../../study/arrivals.js";
 /**
  * The session budget of a study that declares no execution.timeoutMs. On a provisioned route it is
  * what the `ceilingMs` sandbox ceiling leaves after provisioning, seeding and the teardown buffer.
@@ -19,10 +19,12 @@ export declare function defaultSessionTimeoutMs(config: StudyConfig, ceilingMs:
 export declare function resolveParticipantSandboxMs(config: StudyConfig, ceilingMs: number): number;
 /**
  * The deps one participant runs with once its start comes: its own session budget and sandbox
- * deadline, and with a declared end or cap, how its session ends (`scheduledAt` is when it was
- * due, from runOnSchedule).
+ * deadline (participantSession), and with a declared end or cap, how its session ends
+ * (`scheduledAt` is when it was due, from runOnSchedule).
  */
-export declare function scheduledParticipantDeps(participant: ParticipantWindow, deps: {
+export declare function scheduledParticipantDeps(participant: {
+    readonly schedule: ParticipantSchedule;
+}, deps: {
     readonly timeoutMs: number;
     readonly sandboxMs: number;
 }, scheduledAt: number): Pick<CuaParticipantDeps, "timeoutMs" | "sandboxMs" | "end">;
@@ -31,16 +33,15 @@ export declare function scheduledParticipantDeps(participant: ParticipantWindow,
  * declared participant runs at once, because a throttle nobody asked for silently turns "N actors
  * live" into waves; total session count and spend are the same either way, only wall-clock
  * and simultaneity differ. A declared execution.concurrency is a cap, clamped to [1, participants].
- * The planner records it; the route may only lower it from the environment.
+ * participantsAtOnce then lowers it to what the E2B plan and HUMANISH_CUA_MAX_CONCURRENCY allow.
  */
 export declare function boundedConcurrency(declared: number | undefined, participantCount: number): number;
 /**
  * Build the participant runs and the public plan from a computer-use plan (pure). The same plan
- * appears in dry-run and live, marked $0 for a dry run. `env` may lower the planned concurrency;
- * `personas` are the compiled committed personas the prompts carry.
+ * appears in dry-run and live, marked $0 for a dry run. `personas` are the compiled committed
+ * personas the prompts carry.
  */
 export declare function participantRunsAndPlan(plan: ComputerUsePlan, opts?: {
-    env?: Record<string, string | undefined>;
     personas?: Map<string, ResolvedPersona>;
 }): ParticipantRunsAndPlan;
 /** Print the participant plan to stderr before any sandbox/provider call (public-safe: ids, devices,
@@ -63,7 +64,6 @@ export declare function loadCuaParticipants(args: {
     plan: ComputerUsePlan;
     cwd: string;
     projectRoot: PreparedSelectedOutputDirectory;
-    env: Record<string, string | undefined>;
 }): Promise<{
     ok: true;
     participantRuns: DesktopParticipantRun[];

package/dist/routes/computer-use/participant-runs.js

@@ -10,15 +10,14 @@ import { redactText } from "../../evidence/redaction.js";
 import {} from "../../run/bundle.js";
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { resolveCommittedPersonas } from "../../study/persona-resolve.js";
-import { CUA_FANOUT_STRATEGY, CUA_MAX_CONCURRENCY_ENV, DEFAULT_APP_URL_SESSION_TIMEOUT_MS, MIN_DERIVED_SESSION_TIMEOUT_MS, } from "./types.js";
-import { sandboxHeadroomMs } from "../../substrates/e2b/lifetime.js";
-import { readPositiveInt } from "../../study/parse/values.js";
+import { CUA_FANOUT_STRATEGY, DEFAULT_APP_URL_SESSION_TIMEOUT_MS, MIN_DERIVED_SESSION_TIMEOUT_MS, } from "./types.js";
+import { CUA_MAX_CONCURRENCY_ENV, sandboxHeadroomMs } from "../../substrates/e2b/lifetime.js";
 import { digestUrl } from "./bundle-parts.js";
 import { composeParticipantInstructions, DEFAULT_MISSION } from "./participant-prompt.js";
 import { resolveCuaRerunSelection } from "./rerun-selection.js";
 import { plural } from "../../run/text.js";
 import { formatDuration } from "../../run/projection.js";
-import { describeArrivals, participantEnd, participantSessionMs, planArrivals, } from "../../study/arrivals.js";
+import { describeArrivals, participantEnd, participantSession, } from "../../study/arrivals.js";
 /**
  * The session budget of a study that declares no execution.timeoutMs. On a provisioned route it is
  * what the `ceilingMs` sandbox ceiling leaves after provisioning, seeding and the teardown buffer.
@@ -45,27 +44,20 @@ export function resolveParticipantSandboxMs(config, ceilingMs) {
         timeoutMs +
             sandboxHeadroomMs(provisionedRoute ? { seed: config.subject.state?.seed ?? [] } : undefined));
 }
-/**
- * A participant's own session budget and sandbox deadline: the study's, or with a declared end or
- * cap its window or cap plus room for the closing report (participantSessionMs), with the same
- * setup and teardown headroom the study's sandbox has over its session.
- */
-function participantWindow(participant, study) {
-    const timeoutMs = participantSessionMs(participant, study.sessionBudgetMs);
-    return { timeoutMs, sandboxMs: study.sandboxMs - study.sessionBudgetMs + timeoutMs };
-}
 /**
  * The deps one participant runs with once its start comes: its own session budget and sandbox
- * deadline, and with a declared end or cap, how its session ends (`scheduledAt` is when it was
- * due, from runOnSchedule).
+ * deadline (participantSession), and with a declared end or cap, how its session ends
+ * (`scheduledAt` is when it was due, from runOnSchedule).
  */
 export function scheduledParticipantDeps(participant, deps, scheduledAt) {
-    const end = participantEnd(participant, scheduledAt);
+    const own = participantSession(participant.schedule, {
+        sessionMs: deps.timeoutMs,
+        sandboxMs: deps.sandboxMs,
+    });
+    const end = participantEnd(participant.schedule, scheduledAt);
     return {
-        ...participantWindow(participant, {
-            sessionBudgetMs: deps.timeoutMs,
-            sandboxMs: deps.sandboxMs,
-        }),
+        timeoutMs: own.sessionMs,
+        sandboxMs: own.sandboxMs,
         ...(end === undefined ? {} : { end }),
     };
 }
@@ -74,33 +66,17 @@ export function scheduledParticipantDeps(participant, deps, scheduledAt) {
  * declared participant runs at once, because a throttle nobody asked for silently turns "N actors
  * live" into waves; total session count and spend are the same either way, only wall-clock
  * and simultaneity differ. A declared execution.concurrency is a cap, clamped to [1, participants].
- * The planner records it; the route may only lower it from the environment.
+ * participantsAtOnce then lowers it to what the E2B plan and HUMANISH_CUA_MAX_CONCURRENCY allow.
  */
 export function boundedConcurrency(declared, participantCount) {
     return Math.max(1, declared === undefined ? participantCount : Math.min(Math.max(1, declared), participantCount));
 }
-/**
- * The planned bound, lowered by the env override. The override may only lower it (never raise
- * concurrent paid desktops), and a lowering is reported via envLoweredFrom so the
- * plan never silently disagrees with the manifest.
- */
-function envLoweredConcurrency(planned, participantCount, env) {
-    const envLower = readPositiveInt(env[CUA_MAX_CONCURRENCY_ENV], 0);
-    if (envLower > 0 && envLower < planned) {
-        return {
-            bound: Math.max(1, Math.min(planned, envLower, participantCount)),
-            envLoweredFrom: planned,
-        };
-    }
-    return { bound: planned };
-}
 /**
  * Build the participant runs and the public plan from a computer-use plan (pure). The same plan
- * appears in dry-run and live, marked $0 for a dry run. `env` may lower the planned concurrency;
- * `personas` are the compiled committed personas the prompts carry.
+ * appears in dry-run and live, marked $0 for a dry run. `personas` are the compiled committed
+ * personas the prompts carry.
  */
 export function participantRunsAndPlan(plan, opts = {}) {
-    const env = opts.env ?? {};
     // Who each participant is (id, persona, focus, device, limits) comes from the plan; this adds
     // what the route derives from it: the prompt, bundle ids and artifact paths.
     const { participants } = plan.runner;
@@ -136,61 +112,54 @@ export function participantRunsAndPlan(plan, opts = {}) {
             traceArtifactPath: participantCount === 1 ? "actor.json" : `actors/${run.streamId}.json`,
         };
     });
-    const resolved = envLoweredConcurrency(plan.concurrency, participantCount, env);
-    const concurrency = resolved.bound;
-    const { sessionBudgetMs } = plan;
-    const schedule = resolved.envLoweredFrom === undefined
-        ? plan.arrivals
-        : planArrivals(participants.map((participant) => participant.startAfterMs), { slots: concurrency, sessionMs: sessionBudgetMs }, participants.map((participant) => participantSessionMs(participant, sessionBudgetMs)));
-    const sandboxesMs = participants.reduce((sum, participant) => sum + participantWindow(participant, plan).sandboxMs, 0);
+    const { concurrency, sessionBudgetMs, arrivals: schedule, envLoweredConcurrencyFrom } = plan;
+    const study = { sessionMs: sessionBudgetMs, sandboxMs: plan.sandboxMs };
+    const sandboxesMs = participants.reduce((sum, participant) => sum + participantSession(participant.schedule, study).sandboxMs, 0);
     const participantPlan = {
         strategy: CUA_FANOUT_STRATEGY,
         laneCount: participantCount,
         concurrency,
-        ...(resolved.envLoweredFrom === undefined
-            ? {}
-            : { envLoweredConcurrencyFrom: resolved.envLoweredFrom }),
+        ...(envLoweredConcurrencyFrom === undefined ? {} : { envLoweredConcurrencyFrom }),
         waves: Math.ceil(participantCount / concurrency),
         perLaneSessionBudgetMs: sessionBudgetMs,
         worstCaseSandboxMinutes: Math.round(sandboxesMs / 60_000),
         ...(schedule.declared ? { schedule } : {}),
         dryRun: plan.dryRun,
-        lanes: runs.map((spec) => ({
-            id: spec.planned.id,
-            ...(spec.planned.labels.actorType === undefined
-                ? {}
-                : { actorType: spec.planned.labels.actorType }),
-            ...(spec.planned.labels.surface === undefined
-                ? {}
-                : { surface: spec.planned.labels.surface }),
-            ...(spec.planned.labels.caseGroup === undefined
-                ? {}
-                : { caseGroup: spec.planned.labels.caseGroup }),
-            index: spec.planned.index + 1,
-            persona: spec.persona.id,
-            device: spec.planned.device.name,
-            resolution: spec.planned.device.resolution,
-            instructionDigest: spec.persona.promptDigest,
-            ...(spec.planned.limits.reasoningEffort === undefined
-                ? {}
-                : { reasoningEffort: spec.planned.limits.reasoningEffort }),
-            ...(spec.planned.limits.maxOutputTokens === undefined
-                ? {}
-                : { maxOutputTokens: spec.planned.limits.maxOutputTokens }),
-            ...(spec.planned.targetUrl === undefined
-                ? {}
-                : { targetDigest: digestUrl(spec.planned.targetUrl) }),
-            ...(spec.planned.startAfterMs === undefined
-                ? {}
-                : { startAfterMs: spec.planned.startAfterMs }),
-            ...(spec.planned.endAfterMs === undefined ? {} : { endAfterMs: spec.planned.endAfterMs }),
-            ...(spec.planned.maxSessionMs === undefined
-                ? {}
-                : { maxSessionMs: spec.planned.maxSessionMs }),
-        })),
+        lanes: runs.map((spec) => planEntry(spec)),
     };
     return { runs, participantPlan };
 }
+/** One participant's row in the plan: ids, labels, device, digests and its declared times. */
+function planEntry(spec) {
+    const { startAfterMs, end } = spec.planned.schedule;
+    return {
+        id: spec.planned.id,
+        ...(spec.planned.labels.actorType === undefined
+            ? {}
+            : { actorType: spec.planned.labels.actorType }),
+        ...(spec.planned.labels.surface === undefined ? {} : { surface: spec.planned.labels.surface }),
+        ...(spec.planned.labels.caseGroup === undefined
+            ? {}
+            : { caseGroup: spec.planned.labels.caseGroup }),
+        index: spec.planned.index + 1,
+        persona: spec.persona.id,
+        device: spec.planned.device.name,
+        resolution: spec.planned.device.resolution,
+        instructionDigest: spec.persona.promptDigest,
+        ...(spec.planned.limits.reasoningEffort === undefined
+            ? {}
+            : { reasoningEffort: spec.planned.limits.reasoningEffort }),
+        ...(spec.planned.limits.maxOutputTokens === undefined
+            ? {}
+            : { maxOutputTokens: spec.planned.limits.maxOutputTokens }),
+        ...(spec.planned.targetUrl === undefined
+            ? {}
+            : { targetDigest: digestUrl(spec.planned.targetUrl) }),
+        ...(startAfterMs === undefined ? {} : { startAfterMs }),
+        ...(end?.kind === "scheduled_end" ? { endAfterMs: end.endAfterMs } : {}),
+        ...(end?.kind === "session_cap" ? { maxSessionMs: end.windowMs } : {}),
+    };
+}
 /** Print the participant plan to stderr before any sandbox/provider call (public-safe: ids, devices,
  *  digests, and budgets only; no prompt text, no secrets). */
 export function emitPreflightPlan(participantPlan, studyId) {
@@ -240,10 +209,7 @@ export async function loadCuaParticipants(args) {
     // Compile any committed personas before planning, so the plan builder stays pure and each participant's
     // prompt carries real behavioral directives rather than a bare `Persona: <id>.` label.
     const personas = await compileParticipantPersonas(args.projectRoot, participants.map((participant) => participant.personaId));
-    const { runs: participantRuns, participantPlan } = participantRunsAndPlan(plan, {
-        env: args.env,
-        personas,
-    });
+    const { runs: participantRuns, participantPlan } = participantRunsAndPlan(plan, { personas });
     const rerun = plan.rerun;
     if (!rerun)
         return { ok: true, participantRuns, participantPlan };

package/dist/routes/computer-use/plan.d.ts

@@ -50,4 +50,6 @@ export declare function planComputerUseStudy(config: StudyConfig, input: {
     readonly sandboxCeiling: SandboxCeiling;
     /** How many sandboxes the operator's E2B plan runs at once (concurrentSandboxes). */
     readonly concurrentSandboxes: ConcurrentSandboxes;
+    /** HUMANISH_CUA_MAX_CONCURRENCY (concurrencyCap), which may only lower the participants at once. */
+    readonly concurrencyCap?: number | undefined;
 }): ComputerUsePlanResult;

package/dist/routes/computer-use/plan.js

@@ -198,30 +198,42 @@ function rosterShapeReason(config, ceilingMs) {
  * How many of the runner's participants run at once, and when each one starts, with the session
  * budget the `ceilingMs` sandbox ceiling leaves. Hosted desktops share the E2B plan's concurrent
  * sandboxes; the local VM has its own capacity rules and the in-process route runs one
- * participant.
+ * participant. HUMANISH_CUA_MAX_CONCURRENCY (`concurrencyCap`) lowers the count on every desktop.
+ * `starts` holds the plan's fields for them.
  */
-function startsOf(config, runner, limit, ceilingMs) {
+function startsOf(config, runner, limits, ceilingMs) {
     const declared = config.execution?.concurrency;
     const n = runner.participants.length;
-    const concurrency = boundedConcurrency(declared, n);
-    const atOnce = runner.desktop === "e2b-desktop"
-        ? participantsAtOnce({ concurrency, declared: declared !== undefined, participants: n }, limit)
-        : { ok: true, count: concurrency };
+    const hosted = runner.desktop === "e2b-desktop";
+    const atOnce = participantsAtOnce({
+        concurrency: boundedConcurrency(declared, n),
+        declared: declared !== undefined,
+        participants: n,
+    }, {
+        ...(hosted ? { sandboxes: limits.concurrentSandboxes } : {}),
+        cap: limits.concurrencyCap,
+    });
     if (!atOnce.ok)
         return atOnce;
     const sessionMs = config.execution?.timeoutMs ?? defaultSessionTimeoutMs(config, ceilingMs);
     // A participant with a declared end gets a sandbox sized from its own window.
-    if (runner.desktop === "e2b-desktop") {
-        const headroomMs = resolveParticipantSandboxMs(config, ceilingMs) - sessionMs;
-        const window = windowDeadlineRefusal(runner.participants, { sessionMs, headroomMs }, ceilingMs);
+    if (hosted) {
+        const sandboxMs = resolveParticipantSandboxMs(config, ceilingMs);
+        const window = windowDeadlineRefusal(runner.participants, { sessionMs, sandboxMs }, ceilingMs);
         if (window !== undefined)
             return { ok: false, message: window };
     }
-    const slots = { slots: atOnce.count, sessionMs };
+    const { arrivals, warnings } = planStarts(runner.participants, { slots: atOnce.count, sessionMs }, atOnce.lowered);
+    const lowered = atOnce.loweredFrom;
     return {
         ok: true,
-        count: atOnce.count,
-        ...planStarts(runner.participants, slots, atOnce.lowered),
+        starts: {
+            concurrency: atOnce.count,
+            ...(lowered === undefined ? {} : { envLoweredConcurrencyFrom: lowered }),
+            arrivals,
+            sessionBudgetMs: sessionMs,
+        },
+        warnings,
     };
 }
 /** The plan's rerun: the source run and, when given, the participants to rerun. */
@@ -349,7 +361,7 @@ export function planComputerUseStudy(config, input) {
     const unsupported = runnerRefusal(runner.desktop, participants);
     if (unsupported)
         return refuse("in-scope", unsupported.code, unsupported.message, actor);
-    const starts = startsOf(config, runner, input.concurrentSandboxes, ceiling.ms);
+    const starts = startsOf(config, runner, input, ceiling.ms);
     if (!starts.ok)
         return refuse("after-personas", "HUMANISH_COMPUTER_USE_FANOUT_INVALID", starts.message, actor);
     const provisioned = source === "clone" || source === "local-tree";
@@ -362,9 +374,7 @@ export function planComputerUseStudy(config, input) {
             route: "computer-use",
             actor,
             runner,
-            concurrency: starts.count,
-            arrivals: starts.arrivals,
-            sessionBudgetMs: starts.arrivals.sessionMs,
+            ...starts.starts,
             sandboxMs: resolveParticipantSandboxMs(config, ceiling.ms),
             caps: planCaps(config),
             ...(input.rerun === undefined ? {} : { rerun: rerunPlan(input.rerun) }),

package/dist/routes/computer-use/rerun-selection.js

@@ -7,6 +7,7 @@ import {} from "../../run/streams.js";
 import { plural } from "../../run/text.js";
 import { access } from "node:fs/promises";
 import { cli } from "../../cli/invocation.js";
+import { startingWithTheRun } from "../../study/arrivals.js";
 export async function resolveCuaRerunSelection(args) {
     const { studyId, sourceRunId } = args;
     // Every refusal ends with the command that runs the whole study, which is what a user who
@@ -59,7 +60,7 @@ export async function resolveCuaRerunSelection(args) {
     }
     // A rerun runs the selected participants again now, all together: the study's start offsets
     // placed them in the first run's day, and that day is over.
-    const selectedSpecs = selectedIds.map((id) => startingWithTheRun(specsById.get(id)));
+    const selectedSpecs = selectedIds.map((id) => startingNow(specsById.get(id)));
     const selectedPlanIds = new Set(selectedIds);
     const selectedPlanEntries = args.participantPlan.lanes
         .filter((entry) => selectedPlanIds.has(entry.id))
@@ -86,11 +87,13 @@ export async function resolveCuaRerunSelection(args) {
         },
     };
 }
-function startingWithTheRun(spec) {
-    if (spec.planned.startAfterMs === undefined)
+function startingNow(spec) {
+    if (spec.planned.schedule.startAfterMs === undefined)
         return spec;
-    const { startAfterMs: _offset, ...planned } = spec.planned;
-    return { ...spec, planned };
+    return {
+        ...spec,
+        planned: { ...spec.planned, schedule: startingWithTheRun(spec.planned.schedule) },
+    };
 }
 function uniqueIds(values) {
     const seen = new Set();

package/dist/routes/computer-use/setup.js

@@ -108,7 +108,7 @@ export async function admitCuaRun(plan, input, config) {
         ? comms?.email?.external
         : undefined;
     const externalCommsEmail = externalCommsConfig ? comms?.email : undefined;
-    const participants = await loadCuaParticipants({ plan, cwd, projectRoot, env });
+    const participants = await loadCuaParticipants({ plan, cwd, projectRoot });
     if (!participants.ok) {
         return refuse(participants.code, participants.message, descriptor.id);
     }

package/dist/routes/computer-use/single-bundle.js

@@ -5,6 +5,7 @@ import {} from "../../run/streams.js";
 import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, participantSummary, withCuaReviewProvenance, } from "../../run/outcomes.js";
 import { participantCaption } from "../../run/participant-caption.js";
 import { actorEnding } from "../../actors/stop-cause.js";
+import { cuaGoalSource, ranUntilClockEnd } from "../../actors/goal-source.js";
 import { describeSubjectState, phaseEventIdSuffix, publicSafeAppUrlLabel, subjectProvenanceMessage, } from "./bundle-parts.js";
 import { participantFeedbackCandidates } from "./participant-feedback.js";
 import { judgeParticipantRecords } from "../../run/judge.js";
@@ -46,6 +47,7 @@ function runCost(args) {
 }
 /** The participant's status, reason, last frame, geometry and screenshot mode, shared by its records. */
 function participantView(args, publicAppUrl) {
+    const ranUntil = args.session === undefined ? undefined : ranUntilClockEnd(args.session.trace);
     const judgment = judgeParticipantRecords([
         {
             ...(args.session === undefined
@@ -55,6 +57,7 @@ function participantView(args, publicAppUrl) {
                     completionReason: args.session.completionReason,
                     reason: args.session.reason,
                 }),
+            ...(ranUntil === undefined ? {} : { ranUntil }),
             ...(args.sessionError === undefined ? {} : { sessionError: args.sessionError }),
             inProgress: args.inProgress === true,
             skipped: false,
@@ -298,8 +301,13 @@ function singleSummary(args, view, facts) {
             : `1 participant was planned, but the run failed before their session finished: ${view.reason}`;
     }
     const ending = actorEnding(args.session.trace);
+    const goalSource = cuaGoalSource(args.session.trace);
     const outcomes = formatParticipantOutcomes(view.tally, [
-        { status: args.session.status, ...(ending === undefined ? {} : { label: ending.label }) },
+        {
+            status: args.session.status,
+            ...(ending === undefined ? {} : { label: ending.label }),
+            ...(goalSource === undefined ? {} : { goalSource }),
+        },
     ]);
     return [
         `1 participant took part: ${outcomes}.`,

package/dist/routes/computer-use/types.d.ts

@@ -32,7 +32,6 @@ import type { ComputerUseParticipant, SharedWorldParticipant } from "../../study
 import type { ResolvedParticipant } from "../../run/participant.js";
 import { type StudyResultErrorCode, type StudyResultIdentity } from "../../run/study-result.js";
 export declare const CUA_FANOUT_STRATEGY: "per-lane-worlds";
-export declare const CUA_MAX_CONCURRENCY_ENV = "HUMANISH_CUA_MAX_CONCURRENCY";
 export declare const DEFAULT_APP_URL_SESSION_TIMEOUT_MS: number;
 export declare const MIN_DERIVED_SESSION_TIMEOUT_MS: number;
 /**
@@ -126,8 +125,8 @@ export interface CuaParticipantPlan {
     /** Effective in-flight bound (defaults to laneCount, all participants live; a declared
      *  execution.concurrency is a cap; the env override may only lower it). */
     concurrency: number;
-    /** Present when the env override lowered the bound below the config's value, recorded so the
-     *  plan never silently disagrees with the manifest. */
+    /** Present when HUMANISH_CUA_MAX_CONCURRENCY lowered the bound (the plan's
+     *  envLoweredConcurrencyFrom), recorded so the plan never silently disagrees with the manifest. */
     envLoweredConcurrencyFrom?: number;
     /** ceil(laneCount / concurrency). */
     waves: number;

package/dist/routes/computer-use/types.js

@@ -15,9 +15,6 @@ import {} from "../../run/study-result.js";
 // The fan-out topology of this route: N participants = N independent E2B desktop sandboxes,
 // each its own world (clone/serve + subject.state per participant). Shared-world has its own route.
 export const CUA_FANOUT_STRATEGY = "per-lane-worlds";
-// Env override that may only lower the effective concurrency (never raise concurrent paid
-// desktops). Read names-only into a local; the value never persists.
-export const CUA_MAX_CONCURRENCY_ENV = "HUMANISH_CUA_MAX_CONCURRENCY";
 // The default session budget, sized so a study can finish (docs/principles/three-roles.md: a
 // session ends because the participant is done, not because a timer fired; the time-box is a
 // session-level cap a researcher sets generously; spend protection is the dollar caps' job).

package/dist/routes/shared-world/bundle-records.js

@@ -72,7 +72,7 @@ function sharedWorldSimulation(ctx, spec, index, view) {
         updatedAt: args.run.createdAt,
         ...(args.plan.arrivals.declared
             ? {
-                arrival: arrivalRecord(spec.planned.startAfterMs, actorArrival(args.actorResults[index])),
+                arrival: arrivalRecord(spec.planned.schedule.startAfterMs, actorArrival(args.actorResults[index])),
             }
             : {}),
     });

package/dist/routes/shared-world/external-public.js

@@ -104,7 +104,7 @@ export async function runExternalPublicPlane(ctx, live, inbox) {
             }))
             : undefined;
         const followerResultsPromise = runOnSchedule(followerEntries, {
-            startAfterMs: ({ spec }) => spec.planned.startAfterMs,
+            startAfterMs: ({ spec }) => spec.planned.schedule.startAfterMs,
             slots: Math.max(1, concurrency - 1),
             now: ctx.now,
         }, async ({ spec, index }, _position, { scheduledAt }) => ({

package/dist/routes/shared-world/plan.d.ts

@@ -23,6 +23,8 @@ export declare function planSharedWorldStudy(config: StudyConfig, input: {
     readonly sandboxCeiling: SandboxCeiling;
     /** How many sandboxes the operator's E2B plan runs at once (concurrentSandboxes). */
     readonly concurrentSandboxes: ConcurrentSandboxes;
+    /** HUMANISH_CUA_MAX_CONCURRENCY (concurrencyCap), which may only lower the participants at once. */
+    readonly concurrencyCap?: number | undefined;
 }): SharedWorldPlanResult;
 /**
  * The schedule lines a shared-world run prints before it creates anything, when the study declares