humanish 0.111.4 → 0.112.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/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>
@@ -302,16 +303,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/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,19 +90,11 @@ 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));

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. */

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

@@ -2,10 +2,12 @@ import { participantAssignment } from "../../study/participant-assignment.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import {} from "../../run/streams.js";
-import { aggregateTaskFunnels, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
+import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, sessionEndingInWords, withCuaReviewProvenance, } from "../../run/outcomes.js";
+import { participantCaption } from "../../run/participant-caption.js";
+import { actorEnding } from "../../actors/stop-cause.js";
 import { describeSubjectState, phaseEventIdSuffix, publicSafeAppUrlLabel, subjectProvenanceMessage, } from "./bundle-parts.js";
 import { participantFeedbackCandidates } from "./participant-feedback.js";
-import { participantStatus as participantStatusFor } from "../../run/judge.js";
+import { judgeParticipantRecords } from "../../run/judge.js";
 import { buildRunCostSummary } from "../../run/cost-summary.js";
 import { participantEvent, participantIds, participantRecord, participantStream, } from "../../run/participant-records.js";
 import { plural } from "../../run/text.js";
@@ -43,18 +45,25 @@ function runCost(args) {
 }
 /** The participant's status, reason, last frame, geometry and screenshot mode, shared by its records. */
 function participantView(args, publicAppUrl) {
-    const status = args.inProgress === true
-        ? "running"
-        : args.session
-            ? args.session.status
-            : args.sessionError !== undefined
-                ? "failed"
-                : "contract_proof_only";
-    const reason = args.inProgress === true
-        ? "Live computer-use session is running; stream auth URL is available only through the attached Observer server."
-        : (args.session?.reason ??
-            args.sessionError ??
-            "Dry run: the evidence shape was written without launching a desktop or spending provider tokens.");
+    const judgment = judgeParticipantRecords([
+        {
+            ...(args.session === undefined
+                ? {}
+                : {
+                    status: args.session.status,
+                    completionReason: args.session.completionReason,
+                    reason: args.session.reason,
+                }),
+            ...(args.sessionError === undefined ? {} : { sessionError: args.sessionError }),
+            inProgress: args.inProgress === true,
+            skipped: false,
+            noEngagement: args.credibility?.noEngagement === true,
+            selfReportedBlocker: args.credibility?.selfReportedBlocker === true,
+            reportedFriction: args.credibility?.reportedFriction === true,
+        },
+    ]);
+    const participant = judgment.participants[0];
+    const { status, reason } = participant;
     const lastScreenshot = args.screenshots[args.screenshots.length - 1];
     const desktopGeometry = args.desktopRoute === false
         ? undefined
@@ -70,6 +79,8 @@ function participantView(args, publicAppUrl) {
         : (args.captureRedaction ?? "raw");
     return {
         publicAppUrl,
+        participant,
+        tally: judgment.tally,
         status,
         reason,
         lastScreenshot,
@@ -80,6 +91,10 @@ function participantView(args, publicAppUrl) {
 }
 function singleSimulation(args, view) {
     const { publicAppUrl, status, reason } = view;
+    const name = participantCaption({
+        id: args.participantId ?? "lane-01",
+        personaId: args.persona.id,
+    });
     return participantRecord(SINGLE, 1, {
         personaId: args.persona.id,
         scenarioId: `cua-${args.studyId}`,
@@ -89,23 +104,19 @@ function singleSimulation(args, view) {
         progress: args.inProgress === true ? 20 : 100,
         currentStep: reason,
         summary: args.session
-            ? `Computer-use actor (${args.actorId}) drove the subject app ${browserPlace(args)}; ${args.session.completionReason}.`
+            ? `${name} used the app ${browserPlace(args)}, and ${sessionEndingInWords(args.session.trace)}.`
             : args.inProgress === true
-                ? `Computer-use actor (${args.actorId}) is driving the subject app ${browserPlace(args)}.`
+                ? `${name} is using the app ${browserPlace(args)}.`
                 : args.sessionError !== undefined
-                    ? `The computer-use run failed before a terminal session verdict: ${args.sessionError}`
-                    : `Computer-use actor (${args.actorId}) against ${publicAppUrl}; no session ran.`,
+                    ? `${name} did not finish a session: ${args.sessionError}`
+                    : `${name} would use ${publicAppUrl}; no session ran.`,
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
     });
 }
 function singleStream(args, view) {
     const { publicAppUrl, status, reason, lastScreenshot, desktopGeometry, screenshotMode } = view;
-    // The judge's status for a finished session, as the review counts it, so the Observer shows
-    // the participant the way the verdict judged it.
-    const judged = args.session === undefined || args.inProgress === true
-        ? undefined
-        : participantStatusFor(args.session.status, args.credibility);
+    const judged = args.session === undefined ? undefined : view.participant.judgedStatus;
     return participantStream(SINGLE, {
         ...(args.assignment === undefined
             ? {}
@@ -114,7 +125,13 @@ function singleStream(args, view) {
         ...(args.surface === undefined ? {} : { surface: args.surface }),
         ...(args.caseGroup === undefined ? {} : { caseGroup: args.caseGroup }),
         kind: "browser",
-        label: `${args.participantId ?? "lane-01"} · browser`,
+        label: participantCaption({
+            id: args.participantId ?? "lane-01",
+            personaId: args.persona.id,
+            ...(args.isMobile === undefined
+                ? {}
+                : { device: { name: args.deviceName ?? "", preset: { isMobile: args.isMobile } } }),
+        }),
         status,
         ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
@@ -257,37 +274,64 @@ function singleEvents(args, view) {
     }
     return events;
 }
+/**
+ * The run's summary in plain sentences. A finished session gives the outcome with its denominator
+ * of one, any reason the harness did not count a pass, and how the session ended. The single
+ * participant has no gap line, so the summary carries the reason.
+ */
+function singleSummary(args, view, facts) {
+    if (args.inProgress === true) {
+        return "1 participant is using the app. The run is still going, so nothing here is final.";
+    }
+    if (args.dryRun) {
+        return `Dry run: 1 participant would use ${view.publicAppUrl}. Nothing was launched and $0 was spent.`;
+    }
+    if (args.session === undefined) {
+        return args.sessionError === undefined
+            ? `1 participant was planned against ${view.publicAppUrl}, but no session ran.`
+            : `1 participant was planned, but the run failed before their session finished: ${view.reason}`;
+    }
+    const ending = actorEnding(args.session.trace);
+    const outcomes = formatParticipantOutcomes(view.tally, [
+        { status: args.session.status, ...(ending === undefined ? {} : { label: ending.label }) },
+    ]);
+    return [
+        `1 participant took part: ${outcomes}.`,
+        facts.tasks === undefined ? undefined : `Tasks: ${formatRunTaskFunnel(facts.tasks)}.`,
+        facts.credibilityNote,
+        `How it ended: ${view.reason}`,
+    ]
+        .filter((sentence) => sentence !== undefined)
+        .join(" ");
+}
 function singleReview(args, view, stream) {
-    const { reason } = view;
     // A funnel with a denominator of one is still the funnel, and its absence stays recorded: no
     // declared protocol (or a dry run) means no `tasks` field, never an empty one.
     const singleRunTasks = args.inProgress !== true && args.session?.trace.taskFunnel !== undefined
         ? aggregateTaskFunnels([args.session.trace.taskFunnel])
         : undefined;
-    // What happened to the participant, as the route judged it: the same rule the fan-out roll-up
-    // applies (participantStatus in src/run/judge.ts). Reading the actor's own status instead would write up
-    // a run the route refused as "not a credible pass" as verdict pass, 1/1 reached the goal, and
-    // every projection of the bundle (Observer tally, `runs`, the status index) would repeat it.
-    const participantStatus = args.session === undefined
-        ? undefined
-        : participantStatusFor(args.session.status, args.credibility);
-    const credibilityNote = args.session === undefined || participantStatus === args.session.status
+    const credibilityNote = args.inProgress === true || args.session?.status !== "passed"
         ? undefined
         : args.credibility?.noEngagement === true
             ? "Not counted as a pass: the participant took no actions and said nothing."
-            : "Not counted as a pass: the participant's final message described a blocker.";
+            : args.credibility?.selfReportedBlocker === true
+                ? "Not counted as a pass: the participant's final message described a blocker."
+                : undefined;
     const review = withCuaReviewProvenance({
         schema: REVIEW_SCHEMA,
         verdict: args.verdict,
         // One participant is still a study with a denominator of one, and saying so keeps a
         // single-participant result from being read as though it generalized.
-        ...(participantStatus !== undefined && args.inProgress !== true
+        ...(args.session !== undefined && args.inProgress !== true
             ? {
-                participants: tallyParticipantOutcomes([participantStatus], [args.credibility?.reportedFriction === true]),
+                participants: view.tally,
             }
             : {}),
         ...(singleRunTasks === undefined ? {} : { tasks: singleRunTasks }),
-        summary: credibilityNote === undefined ? reason : `${credibilityNote} ${reason}`,
+        summary: singleSummary(args, view, {
+            ...(singleRunTasks === undefined ? {} : { tasks: singleRunTasks }),
+            ...(credibilityNote === undefined ? {} : { credibilityNote }),
+        }),
         gaps: args.session || args.sessionError !== undefined
             ? []
             : args.inProgress === true

package/dist/routes/scripted/bundle.d.ts

@@ -36,5 +36,5 @@ interface ScriptedBundleArgs {
  * the bundle-builder tests.
  */
 export declare function buildScriptedStudyBundle(args: ScriptedBundleArgs): RunBundle;
-export declare function renderScriptedReviewMarkdown(bundle: RunBundle): string;
+export declare function renderScriptedReviewMarkdown(bundle: RunBundle, status?: unknown): string;
 export {};