humanish 0.111.4 → 0.113.0

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

@@ -45,5 +45,5 @@ interface CuaRunBundleState {
  */
 export declare function buildCuaRunBundle(base: CuaRunBundleBase, state: CuaRunBundleState): RunBundle;
 /** The run's review.md: title, run, mode, gate, summary, subject, actor evidence and gaps. */
-export declare function renderCuaReviewMarkdown(bundle: RunBundle): string;
+export declare function renderCuaReviewMarkdown(bundle: RunBundle, status?: unknown): string;
 export {};

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

@@ -2,8 +2,8 @@
 // and buildCuaRunBundle sends it to the single-participant or the fan-out builder with that
 // shape's arguments. renderCuaReviewMarkdown writes review.md. shared-world/bundle.ts holds the
 // same for that route.
-import { judgeOneParticipant, judgeParticipants, verdictText, } from "../../run/judge.js";
-import { reviewOutcome } from "../../run/display.js";
+import { judgeOneParticipant, judgeParticipants } from "../../run/judge.js";
+import { renderReviewMarkdown } from "../../run/review-markdown.js";
 import { desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { e2bDesktopTemplate } from "../../substrates/e2b/sandbox.js";
 import { providerResourcesForOutcome } from "./bundle-parts.js";
@@ -92,6 +92,7 @@ function singleParticipantArgs(base, state) {
         ...(spec.evidenceAssignment === undefined ? {} : { assignment: spec.evidenceAssignment }),
         persona: spec.persona,
         resolution: spec.planned.device.resolution,
+        deviceName: spec.planned.device.name,
         desktopRoute: base.plan.runner.desktop !== "in-process",
         substrate: base.plan.runner.desktop === "in-process"
             ? "local-filesystem"
@@ -151,17 +152,10 @@ function singleParticipantArgs(base, state) {
     };
 }
 /** The run's review.md: title, run, mode, gate, summary, subject, actor evidence and gaps. */
-export function renderCuaReviewMarkdown(bundle) {
+export function renderCuaReviewMarkdown(bundle, status) {
     const trace = bundle.streams[0]?.actor;
     const provenance = bundle.events.find((event) => event.type === "cua-lab.subject.provenance");
-    return [
-        `# ${bundle.scenario.title}`,
-        "",
-        `- run: ${bundle.runId}`,
-        `- mode: ${bundle.mode}`,
-        `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
-        `- outcome: ${reviewOutcome(bundle)}`,
-        `- summary: ${bundle.review.summary}`,
+    return renderReviewMarkdown(bundle, [
         ...(provenance ? [`- subject: ${provenance.message}`] : []),
         ...(trace
             ? [
@@ -173,9 +167,5 @@ export function renderCuaReviewMarkdown(bundle) {
                     : "screenshot")}`,
             ]
             : []),
-        ...(bundle.review.gaps.length > 0
-            ? ["", "## Gaps", ...bundle.review.gaps.map((gap) => `- ${gap}`)]
-            : []),
-        "",
-    ].join("\n");
+    ], { status });
 }

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

@@ -3,11 +3,11 @@ import { receivingPublication } from "../../comms/receiving-runtime.js";
 import { actorEnding } from "../../actors/stop-cause.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
-import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
+import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, gapsListClause, withCuaReviewProvenance, } from "../../run/outcomes.js";
 import { providerResourcesForOutcome, publicSafeAppUrlLabel } from "./bundle-parts.js";
 import { participantFeedbackCandidates } from "./participant-feedback.js";
 import { participantFactsOf } from "./participant-facts.js";
-import { participantPassed, participantStatus } from "../../run/judge.js";
+import { judgeParticipantRecords } from "../../run/judge.js";
 import { buildRunCostSummary, desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { formatParticipantPlanEntry } from "./participant-runs.js";
 import { fanoutParticipantRecords } from "./fanout-records.js";
@@ -32,29 +32,32 @@ function fanoutPlanEvents(args) {
     });
     return events;
 }
-function fanoutReview(args, streams) {
-    const { specs, outcomes } = 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.
+ */
+function fanoutSummary(args, facts) {
+    const count = args.specs.length;
+    const people = plural(count, "participant");
+    const rerun = args.rerun === undefined ? "" : `Rerun from ${args.rerun.sourceRunId}: `;
+    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.`;
+    }
+    if (args.dryRun) {
+        return `${rerun}Dry run: ${people} would each use their own copy of ${publicSafeAppUrlLabel(args.appUrl)}. No desktops were launched and $0 was spent.`;
+    }
+    const tasks = facts.tasks === undefined ? "" : ` Tasks: ${facts.tasks}.`;
+    return `${rerun}${people} took part, each in their own copy of the app: ${facts.outcomes}${gapsListClause(count - facts.passed, count)}.${tasks}`;
+}
+function fanoutReview(args, streams, judgment) {
+    const { outcomes } = args;
     // The judge's verdict: live fan-out must prove every participant (judgeParticipants).
     const verdict = args.verdict;
-    const passedParticipants = (outcomes ?? []).filter((outcome) => participantPassed(participantFactsOf(outcome))).length;
+    const passedParticipants = judgment.participants.filter((participant) => participant.judgedStatus === "passed").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);
-    const participants = terminalOutcomes.length > 0
-        ? tallyParticipantOutcomes(
-        // A no-engagement participant is not one who reached the goal. It said "done" having
-        // taken zero actions and said nothing, and `passedParticipants` above already refuses to
-        // count it, but `reachedGoal` was reading the trace status directly, so one run could be both
-        // "not a passed participant" and "1/1 reached the goal". The headline number a researcher reads
-        // first was the dishonest one. Found by a provider bug that ended a study on turn one.
-        terminalOutcomes.map((outcome) => participantStatus(outcome.session.status, {
-            noEngagement: outcome.noEngagement === true,
-            selfReportedBlocker: outcome.selfReportedBlocker === true,
-        })), 
-        // A participant who reached the goal and told you the road there was broken is the most
-        // useful result a study produces; reporting only the outcome would bury it.
-        terminalOutcomes.map((outcome) => outcome.reportedFriction === true))
-        : undefined;
+    const participants = judgment.tally.total > 0 ? judgment.tally : undefined;
     // The study funnel: per-task completion rates across every session that measured one. This is
     // "where did people get stuck" as data, next to who got stuck (participants) above.
     const participantFunnels = (outcomes ?? [])
@@ -75,25 +78,18 @@ function fanoutReview(args, streams) {
         ...(runTasks === undefined ? {} : { tasks: runTasks }),
         // The app URL is named as the participant records name it: one on an E2B host names a
         // sandbox, so the summary carries its digest, which verify accepts in a shared run.
-        summary: args.inProgress === true
-            ? `Live computer-use fan-out is running (${specs.length} participants, one world each); terminal participant evidence has not been written yet.`
-            : args.dryRun
-                ? `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Dry-run fan-out: ${specs.length} participants composed for ${args.descriptor.id} against ${publicSafeAppUrlLabel(args.appUrl)}, one world each; no desktops launched, $0 spend.`
-                : `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Computer-use fan-out (${specs.length} participants, one world each): ${passedParticipants}/${plural(specs.length, "participant")} reached a terminal, engaged verdict${participants ? `: ${formatParticipantOutcomes(participants, participantEndings)}` : ""}${runTasks ? `; tasks: ${formatRunTaskFunnel(runTasks)}` : ""}.`,
+        summary: fanoutSummary(args, {
+            passed: passedParticipants,
+            outcomes: participants === undefined
+                ? `0/${args.specs.length} finished a session`
+                : formatParticipantOutcomes(participants, participantEndings),
+            ...(runTasks === undefined ? {} : { tasks: formatRunTaskFunnel(runTasks) }),
+        }),
         gaps: args.inProgress === true
             ? ["Live fan-out session is still running."]
             : args.dryRun
                 ? ["Live fan-out session not yet run (dry run only)."]
-                : specs
-                    .map((spec, index) => ({ spec, outcome: outcomes?.[index] }))
-                    .filter(({ outcome }) => outcome === undefined ||
-                    outcome.skippedReason !== undefined ||
-                    outcome.sessionError !== undefined ||
-                    outcome.noEngagement ||
-                    outcome.selfReportedBlocker ||
-                    outcome.session === undefined ||
-                    outcome.session.status !== "passed")
-                    .map(({ spec, outcome }) => `${spec.planned.id}: ${outcome?.skippedReason ?? outcome?.sessionError ?? outcome?.session?.reason ?? "did not pass"}`),
+                : judgment.participants.flatMap((participant) => participant.gapLine === undefined ? [] : [participant.gapLine]),
     }, streams);
     return review;
 }
@@ -175,6 +171,13 @@ export function buildCuaFanoutBundle(args) {
     const simulations = [];
     const streams = [];
     const events = fanoutPlanEvents(args);
+    const judgment = judgeParticipantRecords(specs.map((spec, index) => ({
+        ...participantFactsOf(outcomes?.[index]),
+        id: spec.planned.id,
+        inProgress: args.inProgress === true && outcomes?.[index] === undefined,
+    })), {
+        runningReason: "Live computer-use participant is running; stream auth URL is available only through the attached Observer server.",
+    });
     let eventSeq = 2;
     const nextEventId = (suffix) => `event-${String(eventSeq++).padStart(3, "0")}-${suffix}`;
     if (args.rerun) {
@@ -187,7 +190,7 @@ export function buildCuaFanoutBundle(args) {
         });
     }
     specs.forEach((spec, index) => {
-        const records = fanoutParticipantRecords({ args, nextEventId }, spec, index);
+        const records = fanoutParticipantRecords({ args, nextEventId, participants: judgment.participants }, spec, index);
         simulations.push(records.simulation);
         streams.push(records.stream);
         events.push(...records.events);
@@ -201,7 +204,7 @@ export function buildCuaFanoutBundle(args) {
             message: `Fan-out fail-fast: ${args.failFastReason}. In-flight participants finished; queued participants were skipped (blocked); completed evidence is retained.`,
         });
     }
-    const review = fanoutReview(args, streams);
+    const review = fanoutReview(args, streams, judgment);
     const anyRaw = (outcomes ?? []).some((outcome) => outcome.session?.trace.redaction.screenshots === "raw");
     const ranLive = (outcomes ?? []).some((outcome) => outcome.session !== undefined || outcome.sessionError !== undefined);
     const desktopTemplate = e2bDesktopTemplate(plan.residual);

package/dist/routes/computer-use/fanout-records.d.ts

@@ -1,9 +1,11 @@
 import type { RunEvent, RunSimulation } from "../../run/bundle.js";
 import type { RunStream } from "../../run/streams.js";
+import type { judgeParticipantRecords } from "../../run/judge.js";
 import type { CuaFanoutBundleArgs, DesktopParticipantRun } from "./types.js";
 /** What every participant's records share. */
 export interface FanoutParticipantContext {
     args: CuaFanoutBundleArgs;
+    participants: ReturnType<typeof judgeParticipantRecords>["participants"];
     /** Numbers events in the order they are pushed. */
     nextEventId: (suffix: string) => string;
 }

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

@@ -2,13 +2,13 @@
 // subject provenance event and the events of its outcome (session, geometry warnings, phase trail).
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { participantEvent, participantRecord, participantStream, } from "../../run/participant-records.js";
+import { participantCaption } from "../../run/participant-caption.js";
+import { sessionEndingInWords } from "../../run/outcomes.js";
 import { declaredScreenForRender } from "../../substrates/e2b/desktop-geometry.js";
 import { describeSubjectState, phaseEventIdSuffix, publicSafeAppUrlLabel } from "./bundle-parts.js";
-import { judgedStatus } from "../../run/judge.js";
-import { participantFactsOf } from "./participant-facts.js";
 import { participantSubjectEnv } from "./types.js";
 const describeEnvNames = (names) => names.length > 0 ? names.join(", ") : "none";
-function fanoutParticipantView(args, spec, index) {
+function fanoutParticipantView(args, spec, index, participant) {
     const { outcomes, plan } = args;
     const outcome = outcomes?.[index];
     const targetUrl = spec.planned.targetUrl ?? args.appUrl;
@@ -27,21 +27,7 @@ function fanoutParticipantView(args, spec, index) {
     };
     const screenshots = outcome?.screenshots ?? [];
     const lastScreenshot = screenshots[screenshots.length - 1];
-    const status = args.inProgress === true && outcome === undefined
-        ? "running"
-        : outcome?.skippedReason !== undefined
-            ? "blocked"
-            : session
-                ? session.status
-                : outcome?.sessionError !== undefined
-                    ? "failed"
-                    : "contract_proof_only";
-    const reason = args.inProgress === true && outcome === undefined
-        ? "Live computer-use participant is running; stream auth URL is available only through the attached Observer server."
-        : (outcome?.skippedReason ??
-            session?.reason ??
-            outcome?.sessionError ??
-            "Dry run: the evidence shape was written without launching a desktop or spending provider tokens.");
+    const { status, reason } = participant;
     const traceScreenshotMode = session?.trace.redaction.screenshots;
     const screenshotMode = traceScreenshotMode === "raw" || traceScreenshotMode === "blurred"
         ? traceScreenshotMode
@@ -50,6 +36,7 @@ function fanoutParticipantView(args, spec, index) {
             : "raw";
     return {
         outcome,
+        participant,
         publicTargetUrl,
         subject,
         session,
@@ -64,6 +51,7 @@ function fanoutParticipantView(args, spec, index) {
 function fanoutParticipantRecord(args, spec, index, view) {
     const { plan } = args;
     const { outcome, publicTargetUrl, session, status, reason } = view;
+    const name = participantCaption({ id: spec.planned.id, personaId: spec.persona.id });
     return participantRecord(spec, index + 1, {
         personaId: spec.persona.id,
         scenarioId: `cua-${plan.studyId}`,
@@ -73,14 +61,14 @@ function fanoutParticipantRecord(args, spec, index, view) {
         progress: args.inProgress === true && outcome === undefined ? 20 : 100,
         currentStep: reason,
         summary: session
-            ? `Participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}): computer-use actor (${args.descriptor.id}) drove the subject app; ${session.completionReason}.`
+            ? `${name} used the app and ${sessionEndingInWords(session.trace)}.`
             : args.inProgress === true && outcome === undefined
-                ? `Participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}): computer-use actor (${args.descriptor.id}) is driving the subject app.`
+                ? `${name} is using the app.`
                 : outcome?.skippedReason !== undefined
-                    ? `Participant ${spec.planned.id} ${outcome.skippedReason}.`
+                    ? `${name} was ${outcome.skippedReason}.`
                     : outcome?.sessionError !== undefined
-                        ? `Participant ${spec.planned.id} failed before a terminal session verdict: ${outcome.sessionError}`
-                        : `Participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}) for ${args.descriptor.id} against ${publicTargetUrl}; no session ran.`,
+                        ? `${name} did not finish a session: ${outcome.sessionError}`
+                        : `${name} would use ${publicTargetUrl}; no session ran.`,
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
     });
@@ -88,7 +76,7 @@ function fanoutParticipantRecord(args, spec, index, view) {
 function fanoutParticipantStream(args, spec, view) {
     const { outcome, publicTargetUrl, session, desktopGeometry, screenshots } = view;
     const { lastScreenshot, status, reason, screenshotMode } = view;
-    const judged = outcome === undefined ? undefined : judgedStatus(participantFactsOf(outcome));
+    const judged = view.participant.judgedStatus;
     return participantStream(spec, {
         ...(spec.evidenceAssignment === undefined
             ? {}
@@ -103,7 +91,11 @@ function fanoutParticipantStream(args, spec, view) {
             ? {}
             : { caseGroup: spec.planned.labels.caseGroup }),
         kind: "browser",
-        label: `${spec.planned.id} · browser`,
+        label: participantCaption({
+            id: spec.planned.id,
+            personaId: spec.persona.id,
+            device: spec.planned.device,
+        }),
         status,
         ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
@@ -298,7 +290,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
 }
 /** One participant's simulation, stream and events, in the order the bundle records them. */
 export function fanoutParticipantRecords(ctx, spec, index) {
-    const view = fanoutParticipantView(ctx.args, spec, index);
+    const view = fanoutParticipantView(ctx.args, spec, index, ctx.participants[index]);
     return {
         simulation: fanoutParticipantRecord(ctx.args, spec, index, view),
         stream: fanoutParticipantStream(ctx.args, spec, view),

package/dist/routes/computer-use/local-vm.js

@@ -3,8 +3,9 @@ import path from "node:path";
 import { inboxRecipientFor, } from "./participant-desktop.js";
 import { createLocalFirecrackerDesktop, } from "../../substrates/local/firecracker-desktop.js";
 import { localBrowserDefaults, localBrowserUnsupportedReason, } from "../../substrates/local/runtime-config.js";
-import { prepareLocalRuntime } from "../../substrates/local/runtime.js";
-import { dockerCommandLine } from "../../substrates/local/runtime-host.js";
+import { localRuntimeCapacity, prepareLocalRuntime } from "../../substrates/local/runtime.js";
+import { dockerCommandLine, usesLima } from "../../substrates/local/runtime-host.js";
+import { outOfMemoryMessage } from "../../substrates/local/capacity.js";
 import { checkRestrictedCodexAnalysisReadiness } from "../../analysis/restricted-codex.js";
 import { createRestrictedCodexParticipant } from "../../actors/codex/restricted-participant.js";
 import { withCloseReport } from "./participant-model.js";
@@ -110,6 +111,11 @@ function createLocalParticipantDesktop(context, run, warnings, artifactRoot) {
                         warnings.push("Desktop video/audio recording could not be retained. Screenshots and participant evidence remain available.");
                     }
                 }
+                // Asked before close, which removes the container; the answer comes from Docker's events.
+                if ((await session.killedForMemory?.()) === true) {
+                    evidence.failureCode = "HUMANISH_COMPUTER_USE_DESKTOP_OUT_OF_MEMORY";
+                    evidence.desktopFailure = outOfMemoryMessage(usesLima() ? "lima-vm" : "linux-host");
+                }
                 try {
                     evidence.released = (await session.close()).status === "released";
                 }
@@ -180,6 +186,7 @@ export function prepareLocalVmRun(options) {
         options: account ? { ...runOptions, createProvider: accountProvider(state) } : runOptions,
         localVm: {
             desktop: (run, warnings, artifactRoot) => createLocalParticipantDesktop(context, run, warnings, artifactRoot),
+            capacity: () => localRuntimeCapacity(),
             analysisRefusal: () => state.cleanupUnconfirmed ? "AUTOMATIC_ANALYSIS_CLEANUP_UNCONFIRMED" : undefined,
             ...(options.signal === undefined ? {} : { signal: options.signal }),
         },

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

@@ -16,6 +16,12 @@ export type ParticipantDesktopEvidence = {
     /** The substrate confirmed the desktop was released (an E2B kill or a local VM shutdown). The participant
      *  outcome records it as `killed`. */
     released: boolean;
+    /**
+     * Why the desktop itself ended the session, in words a person reads, when the substrate knows:
+     * a local desktop Docker killed for memory. It replaces the session's error for a participant
+     * who did not pass.
+     */
+    desktopFailure?: string;
 } & Pick<ParticipantRunOutcome, "sandboxId" | "sandboxRelease" | "desktopDurationMs" | "desktopResources" | "streamUrlPresent" | "subjectCommit" | "desktopBrowser" | "desktopGeometry" | "stateStepRecords" | "phaseRecords" | "failureCode" | "commsArtifactPath" | "recording">;
 /**
  * The desktop one participant runs on, owned from preparation through final evidence collection.

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

@@ -1,3 +1,4 @@
+import { judgeParticipantRecords } from "../../run/judge.js";
 import { createE2BParticipantDesktop } from "./e2b-desktop/desktop.js";
 import { createInProcessDesktop } from "./in-process-desktop.js";
 import path from "node:path";
@@ -6,7 +7,7 @@ import { mapWithConcurrency } from "../../run/concurrency.js";
 import { assertScreenshotEvidence, stripPngMetadataChunks } from "../../evidence/image.js";
 import { redactText, toErrorMessage } from "../../evidence/redaction.js";
 import { assertSafeOutputPathSegment, writeContainedOutputFile, } from "../../run/contained-output.js";
-import { participantOutcomeOk } from "./participant-facts.js";
+import { participantOutcomeOk, participantFactsOf } from "./participant-facts.js";
 import { closeParticipantModel, judgeParticipantSession, participantSessionOptions, recordParticipantTrace, startParticipantModel, } from "./participant-model.js";
 /** Build a participant's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
  *  the relative path the trace references (screenshots/<name> at N=1; screenshots/<laneId>/<name>
@@ -106,6 +107,15 @@ export async function runCuaParticipant(spec, deps) {
             });
         }
     }
+    const { released, desktopFailure, ...desktopEvidence } = desktop.snapshot();
+    // A desktop that died under the participant explains the failure better than the transport
+    // error the session saw. A session that passed keeps its result.
+    if (desktopFailure !== undefined) {
+        if (session?.status === "passed")
+            warnings.push(desktopFailure);
+        else
+            sessionError = desktopFailure;
+    }
     if (session)
         await recordParticipantTrace(spec, deps, session, warnings);
     const { noEngagement, selfReportedBlocker, reportedFriction } = judgeParticipantSession(session, deps, warnings);
@@ -115,7 +125,6 @@ export async function runCuaParticipant(spec, deps) {
         providerCleanupError !== undefined ||
         providerPolicyError !== undefined ||
         session?.completionReason === "harness_error";
-    const { released, ...desktopEvidence } = desktop.snapshot();
     return {
         spec,
         ...(session ? { session } : {}),
@@ -302,16 +311,8 @@ export function toParticipantResult(spec, outcome, subject, dryRun) {
             : {
                 error: {
                     code: outcome.failureCode ?? "HUMANISH_COMPUTER_USE_FAILED",
-                    message: outcome.sessionError ??
-                        (outcome.noEngagement
-                            ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
-                            : outcome.selfReportedBlocker
-                                ? "Actor reported goal_satisfied while its final message described a blocker or asked for missing instructions; not a credible pass."
-                                : session?.completionReason === "harness_error"
-                                    ? `Computer-use session ended with a harness error: ${session.reason}`
-                                    : session?.status !== "passed"
-                                        ? `Computer-use session ended with ${session?.status ?? "unknown"}: ${session?.reason ?? "no terminal reason"}`
-                                        : "The computer-use run did not produce a terminal session."),
+                    message: judgeParticipantRecords([participantFactsOf(outcome)]).participants[0]
+                        .notPassedMessage,
                 },
             }),
     };

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

@@ -1,7 +1,7 @@
-import { type ExecutionFailure, type ParticipantFacts } from "../../run/judge.js";
+import { type ExecutionFailure, type ParticipantRecordFacts } from "../../run/judge.js";
 import type { ParticipantRunOutcome } from "./types.js";
 /** A participant outcome's facts for the judge. */
-export declare function participantFactsOf(outcome: ParticipantRunOutcome): ParticipantFacts;
+export declare function participantFactsOf(outcome: ParticipantRunOutcome | undefined): ParticipantRecordFacts;
 /** Whether a participant passed. A dry-run participant passes as a contract. */
 export declare function participantOutcomeOk(outcome: ParticipantRunOutcome | undefined, dryRun: boolean): boolean;
 /**

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

@@ -4,10 +4,19 @@
 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 };
     return {
+        id: outcome.spec.planned.id,
+        ...(outcome.skippedReason === undefined ? {} : { skippedReason: outcome.skippedReason }),
+        reportedFriction: outcome.reportedFriction === true,
         ...(outcome.session === undefined
             ? {}
-            : { status: outcome.session.status, completionReason: outcome.session.completionReason }),
+            : {
+                status: outcome.session.status,
+                completionReason: outcome.session.completionReason,
+                reason: outcome.session.reason,
+            }),
         ...(outcome.sessionError === undefined ? {} : { sessionError: outcome.sessionError }),
         skipped: outcome.skippedReason !== undefined,
         noEngagement: outcome.noEngagement === true,

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

@@ -4,42 +4,44 @@ import {} from "../../run/bundle.js";
 import { loadRunBundle } from "../../run/locate.js";
 import {} from "../../run/streams.js";
 import { plural } from "../../run/text.js";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { cli } from "../../cli/invocation.js";
 export async function resolveCuaRerunSelection(args) {
-    const source = await loadRunBundle(args.cwd, args.sourceRunId);
+    const { studyId, sourceRunId } = args;
+    // Every refusal ends with the command that runs the whole study, which is what a user who
+    // reached for a rerun too early wants.
+    const instead = `To run every participant of ${studyId} instead, leave out --rerun-failed-from: ${cli(`watch ${studyId}`)} or ${cli(`run ${studyId}`)}.`;
+    const refuse = (what) => ({ ok: false, message: `${what} ${instead}` });
+    const source = await loadRunBundle(args.cwd, sourceRunId);
     if (!source) {
-        return { ok: false, message: `source run not found or invalid: ${args.sourceRunId}` };
+        const noRuns = sourceRunId === "latest" &&
+            !(await access(path.join(args.cwd, ".humanish", "runs", "latest.json")).then(() => true, () => false));
+        return refuse(noRuns
+            ? "--rerun-failed-from latest found no run: this project has no runs yet, and a rerun repeats the failed participants of an earlier live run."
+            : `--rerun-failed-from ${sourceRunId} names no run humanish can read in this project. ${cli("runs")} lists its runs.`);
     }
     const bundle = source.bundle;
+    const run = `Run ${bundle.runId}${sourceRunId === bundle.runId ? "" : ` (the ${sourceRunId} run)`}`;
+    const notFanout = `${run} is not a live computer-use run with more than one participant, so it has no participants to rerun.`;
     if (bundle.mode !== "live") {
-        return {
-            ok: false,
-            message: `source run ${bundle.runId} is ${bundle.mode}; rerun selection only applies to live CUA fan-out evidence.`,
-        };
+        return refuse(`${run} is a dry run: no participant ran in it, so none can be rerun. A rerun repeats the failed participants of a live run with more than one participant.`);
     }
     const fanoutEvent = bundle.events.some((event) => event.type === "cua-lab.fanout.plan");
-    if (!fanoutEvent || bundle.streams.length < 2) {
-        return { ok: false, message: `source run ${bundle.runId} is not a CUA fan-out run.` };
-    }
+    if (!fanoutEvent || bundle.streams.length < 2)
+        return refuse(notFanout);
     const prior = bundle.streams
         .map(snapshotPriorParticipant)
         .filter((entry) => entry !== null);
     const priorById = new Map(prior.map((entry) => [entry.participantId, entry]));
-    if (priorById.size < 2) {
-        return {
-            ok: false,
-            message: `source run ${bundle.runId} does not expose multiple participant ids.`,
-        };
-    }
+    if (priorById.size < 2)
+        return refuse(notFanout);
     const explicitIds = uniqueIds(args.participantIds ?? []);
     const selectedIds = explicitIds.length > 0
         ? explicitIds
         : prior.filter((entry) => entry.rerunnable).map((entry) => entry.participantId);
-    if (selectedIds.length === 0) {
-        return {
-            ok: false,
-            message: `source run ${bundle.runId} has no participant to rerun: none failed, was blocked, timed out or ended without engaging.`,
-        };
-    }
+    if (selectedIds.length === 0)
+        return refuse(`${run} has no participant to rerun: none failed, was blocked, timed out or ended without engaging.`);
     const missingPrior = selectedIds.filter((id) => !priorById.has(id));
     if (missingPrior.length > 0) {
         return {

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

@@ -1,8 +1,8 @@
 import { adapterScoreFailureMessage, applyBrowserScorer } from "../../study/adapter-extension.js";
 import { redactText } from "../../evidence/redaction.js";
-import { foldScorerFailures, judgeExecution, OUTCOME_POLICIES, resultOk, } from "../../run/judge.js";
+import { foldScorerFailures, judgeExecution, judgeParticipantRecords, OUTCOME_POLICIES, resultOk, } from "../../run/judge.js";
 import { validatePreparedRunArtifactPaths } from "../../run/paths.js";
-import { participantExecutionFailures, participantOutcomeOk } from "./participant-facts.js";
+import { participantExecutionFailures, participantOutcomeOk, participantFactsOf, } from "./participant-facts.js";
 import { participantCapWarning } from "./participant-model.js";
 import { summarizeCuaDiagnostics } from "./diagnostics.js";
 import { toParticipantResult } from "./participant-execution.js";
@@ -90,24 +90,17 @@ function cuaStudyResult(args) {
                 message: outcome?.sessionError ??
                     outcome?.providerCleanupError ??
                     outcome?.providerPolicyError ??
-                    (outcome?.noEngagement
-                        ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
-                        : // The participant result (toParticipantResult) named this refusal; the N=1 envelope fell through to
-                            // "did not produce a terminal session", which is false: it produced one and refused it.
-                            outcome?.selfReportedBlocker
-                                ? "Actor reported goal_satisfied while its final message described a blocker or asked for missing instructions; not a credible pass."
-                                : observer.ok
-                                    ? outcome?.session?.completionReason === "harness_error"
-                                        ? `Computer-use session ended with a harness error: ${outcome.session.reason}`
-                                        : outcome?.session?.status !== "passed"
-                                            ? `Computer-use session ended with ${outcome?.session?.status ?? "unknown"}: ${outcome?.session?.reason ?? "no terminal reason"}`
-                                            : "The computer-use run did not produce a terminal session."
-                                    : (observer.error?.message ?? "Observer failed for the computer-use run.")),
+                    (outcome?.noEngagement || outcome?.selfReportedBlocker || observer.ok
+                        ? (participantResults[0]?.error?.message ??
+                            judgeParticipantRecords([participantFactsOf(outcome)]).participants[0]
+                                .notPassedMessage)
+                        : (observer.error?.message ?? "Observer failed for the computer-use run.")),
             };
         }
         const failing = (outcomes ?? []).find((outcome) => !participantOk(outcome));
-        const geometryFailure = (outcomes ?? []).find((outcome) => outcome.failureCode === "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY");
-        const code = geometryFailure?.failureCode ?? "HUMANISH_COMPUTER_USE_FAILED";
+        // A participant whose desktop failed for a known cause gives the run that cause's code.
+        const codedFailure = (outcomes ?? []).find((outcome) => outcome.failureCode !== undefined);
+        const code = codedFailure?.failureCode ?? "HUMANISH_COMPUTER_USE_FAILED";
         return {
             code,
             message: observer.ok

package/dist/routes/computer-use/self-report.js

@@ -200,8 +200,14 @@ export function resolveSelfReportedFriction(session) {
     // reached the goal and described what was hard on the way has reported friction.
     if (session.trace.declaredOutcome === "blocked")
         return session.reason;
+    // Impressions are opinions about the product, not reports of what went wrong in the session.
+    const impressions = new Set(session.trace.impressions?.status === "collected"
+        ? session.trace.impressions.items.map((item) => item.messageId)
+        : []);
     const messages = session.trace.items
-        .filter((item) => item.kind === "message" && item.id !== session.trace.debrief?.messageId)
+        .filter((item) => item.kind === "message" &&
+        item.id !== session.trace.debrief?.messageId &&
+        !impressions.has(item.id))
         .map((item) => item.text?.trim() ?? "")
         .filter((text) => text.length > 0);
     // A custom session may keep its closing report only in reason even when earlier messages exist.

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

@@ -22,6 +22,7 @@ import {} from "./bundle.js";
 import { packRunLocalTree } from "./local-tree-pack.js";
 import { projectParticipantSubjects, subjectProvenanceArg } from "./subject-projection.js";
 import { participantSubjectEnv, } from "./types.js";
+import { capacityShortfall } from "../../substrates/local/capacity.js";
 import { studyPersonaIds } from "../../study/persona-resolve.js";
 import { refusedResult } from "../../run/study-result.js";
 /** The physical project, bound before any caller hook runs. */
@@ -145,6 +146,11 @@ export async function admitCuaRun(plan, input, config) {
         });
         if (rejection)
             return refuse(rejection.code, rejection.message, descriptor.id);
+        const shortfall = await localCapacityShortfall(input.localVm, participantPlan.concurrency);
+        if (shortfall !== undefined && "refusal" in shortfall)
+            return refuse("HUMANISH_COMPUTER_USE_LOCAL_CAPACITY_EXCEEDED", shortfall.refusal, descriptor.id);
+        if (shortfall !== undefined)
+            process.stderr.write(`warning: ${shortfall.warning}\n`);
     }
     // Pack the working tree once per run, on the host, before any sandbox or provider call: every
     // fan-out participant below uploads this same archive, so one archiveSha256 describes every
@@ -192,6 +198,14 @@ export async function admitCuaRun(plan, input, config) {
         },
     };
 }
+/**
+ * Whether a local study's desktops at once fit the local runtime. Read before any desktop: a
+ * desktop past the VM's memory is killed mid-session, after its participant has spent.
+ */
+async function localCapacityShortfall(localVm, desktops) {
+    const capacity = await localVm?.capacity?.();
+    return capacity === undefined ? undefined : capacityShortfall(capacity, desktops);
+}
 /** Starts the run and builds what the participants and the finish read: the deps and the bundle base. */
 export async function startCuaRun(plan, input, admitted, scope) {
     const { cwd, descriptor, participantRuns, participantPlan, publicRepo } = admitted;

package/dist/routes/computer-use/single-bundle.d.ts

@@ -32,6 +32,8 @@ export declare function buildSingleParticipantBundle(args: {
     assignment?: RunStream["assignment"];
     persona: ActorPersonaRef;
     resolution: [number, number];
+    /** The device preset's name; the caption names a tablet. */
+    deviceName?: string;
     /** False only for the custom in-process route, which has no hosted screen/window to claim. */
     desktopRoute?: boolean;
     /** The participant's runner; see runnerSubstrate for the default. */