humanish 0.111.4 → 0.113.0

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/computer-use/types.d.ts

@@ -1,4 +1,5 @@
 import type { Verdict } from "../../run/judge.js";
+import type { LocalCapacity } from "../../substrates/local/capacity.js";
 import type { RunDesktopRecording } from "../../evidence/desktop-recording-types.js";
 import type { CuaExecutor, CuaLiveMetadata, CuaLoopResult, CuaProvider } from "../../actors/computer-use/loop.js";
 import type { CommsReceivingRun } from "../../comms/receiving.js";
@@ -38,6 +39,8 @@ export declare const MIN_DERIVED_SESSION_TIMEOUT_MS: number;
  */
 export interface LocalVmInput {
     readonly desktop: ParticipantDesktopFactory;
+    /** How many desktops the local runtime holds, or undefined when it cannot be read. */
+    readonly capacity?: () => Promise<LocalCapacity | undefined>;
     /** The skip reason automatic analysis records instead of running, or undefined to run it. */
     readonly analysisRefusal: () => AutomaticAnalysisRefusal | undefined;
     readonly signal?: AbortSignal;
@@ -182,7 +185,7 @@ export interface CuaParticipantSummary {
     concurrency: number;
     waves: number;
 }
-export type CuaActorStudyErrorCode = StudyResultErrorCode | "HUMANISH_COMPUTER_USE_FAILED" | "HUMANISH_COMPUTER_USE_KEYS_MISSING" | "HUMANISH_COMPUTER_USE_AGENT_MISSING" | "HUMANISH_COMPUTER_USE_AGENT_SIGNIN_REQUIRED" | "HUMANISH_COMPUTER_USE_SUBJECT_ENV_MISSING" | "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED" | "HUMANISH_COMPUTER_USE_SUBJECT_INVALID" | "HUMANISH_COMPUTER_USE_SUBJECT_UNSAFE" | "HUMANISH_COMPUTER_USE_EXECUTOR_NO_PROVIDER" | "HUMANISH_COMPUTER_USE_LOCAL_APP_NO_EXECUTOR" | "HUMANISH_COMPUTER_USE_LOCAL_DESKTOP_MISSING" | "HUMANISH_COMPUTER_USE_FANOUT_INVALID" | "HUMANISH_COMPUTER_USE_RERUN_INVALID" | "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY" | "HUMANISH_COMPUTER_USE_UNPRICED_CAP" | "HUMANISH_COMPUTER_USE_COMMS_CATCH_UNREACHABLE" | "HUMANISH_COMPUTER_USE_COMMS_TOKEN_INVALID" | "HUMANISH_WATCH_ALLOW_REQUIRES_OAUTH" | "HUMANISH_WATCH_OAUTH_REQUIRES_TUNNEL" | "HUMANISH_WATCH_OPTION_CONFLICT" | "HUMANISH_WATCH_TUNNEL_REQUIRES_EXPOSE" | "HUMANISH_WATCH_EXPOSE_REQUIRES_EDGE_AUTH" | "HUMANISH_WATCH_EXPOSE_REQUIRES_LIVE_FOLLOW" | "HUMANISH_WATCH_SAFE_NOT_APPLICABLE" | "HUMANISH_SERVE_TUNNEL_NOT_FOUND" | "HUMANISH_SERVE_TUNNEL_START_FAILED";
+export type CuaActorStudyErrorCode = StudyResultErrorCode | "HUMANISH_COMPUTER_USE_FAILED" | "HUMANISH_COMPUTER_USE_KEYS_MISSING" | "HUMANISH_COMPUTER_USE_AGENT_MISSING" | "HUMANISH_COMPUTER_USE_AGENT_SIGNIN_REQUIRED" | "HUMANISH_COMPUTER_USE_SUBJECT_ENV_MISSING" | "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED" | "HUMANISH_COMPUTER_USE_SUBJECT_INVALID" | "HUMANISH_COMPUTER_USE_SUBJECT_UNSAFE" | "HUMANISH_COMPUTER_USE_EXECUTOR_NO_PROVIDER" | "HUMANISH_COMPUTER_USE_LOCAL_APP_NO_EXECUTOR" | "HUMANISH_COMPUTER_USE_LOCAL_DESKTOP_MISSING" | "HUMANISH_COMPUTER_USE_LOCAL_CAPACITY_EXCEEDED" | "HUMANISH_COMPUTER_USE_DESKTOP_OUT_OF_MEMORY" | "HUMANISH_COMPUTER_USE_FANOUT_INVALID" | "HUMANISH_COMPUTER_USE_RERUN_INVALID" | "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY" | "HUMANISH_COMPUTER_USE_UNPRICED_CAP" | "HUMANISH_COMPUTER_USE_COMMS_CATCH_UNREACHABLE" | "HUMANISH_COMPUTER_USE_COMMS_TOKEN_INVALID" | "HUMANISH_WATCH_ALLOW_REQUIRES_OAUTH" | "HUMANISH_WATCH_OAUTH_REQUIRES_TUNNEL" | "HUMANISH_WATCH_OPTION_CONFLICT" | "HUMANISH_WATCH_TUNNEL_REQUIRES_EXPOSE" | "HUMANISH_WATCH_EXPOSE_REQUIRES_EDGE_AUTH" | "HUMANISH_WATCH_EXPOSE_REQUIRES_LIVE_FOLLOW" | "HUMANISH_WATCH_SAFE_NOT_APPLICABLE" | "HUMANISH_SERVE_TUNNEL_NOT_FOUND" | "HUMANISH_SERVE_TUNNEL_START_FAILED";
 /** Subject provenance projection: what the actor actually drove. */
 export interface CuaSubjectProjection {
     source: "app-url" | "clone" | "local-tree";

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 {};

package/dist/routes/scripted/bundle.js

@@ -1,13 +1,13 @@
 // Assemble the scripted-browser study's run bundle from its sessions, and the review summary and
 // markdown that ship with it.
-import { verdictText } from "../../run/judge.js";
-import { reviewOutcome } from "../../run/display.js";
+import { renderReviewMarkdown } from "../../run/review-markdown.js";
 import { redactText } from "../../evidence/redaction.js";
 import { buildRunCostSummary, desktopSpanToMinutes, spendFreeCostSummary, } from "../../run/cost-summary.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import {} from "../../run/streams.js";
 import { participantEvent, recordIdOf } from "../../run/participant-records.js";
 import { scriptedSurfaceIds, scriptedSurfaceRecords } from "./surface-records.js";
+import { gapsListClause } from "../../run/outcomes.js";
 import { plural } from "../../run/text.js";
 /**
  * Project the scripted run into a humanish.run-bundle.v1 (no schema change: a new
@@ -146,7 +146,7 @@ function buildScriptedReview(args) {
         return {
             schema: REVIEW_SCHEMA,
             verdict: args.verdict,
-            summary: `The scripted run failed before a terminal session verdict: ${args.sessionError}`,
+            summary: `The run failed before the script finished: ${args.sessionError}`,
             gaps: [],
         };
     }
@@ -154,41 +154,31 @@ function buildScriptedReview(args) {
         return {
             schema: REVIEW_SCHEMA,
             verdict: args.verdict,
-            summary: `Dry run of scenario ${args.journey.scenarioId} (${args.scenarioSource}, ${args.journey.steps.length} steps) against ${args.appUrl}: composition and scenario checked at $0; no browser ran.`,
+            summary: `Dry run: scenario ${args.journey.scenarioId} (${args.scenarioSource}, ${args.journey.steps.length} steps) would replay against ${args.appUrl} on ${plural(args.surfaces.length, "browser surface")}. No browser ran and $0 was spent.`,
             gaps: ["Live scripted session not yet run (dry run only)."],
         };
     }
     const passed = args.sessionResults.filter((result) => result.status === "passed").length;
+    const ran = args.sessionResults.length;
     return {
         schema: REVIEW_SCHEMA,
         verdict: args.verdict,
-        summary: `Scripted-browser actor replayed ${args.journey.scenarioId} on ${args.sessionResults.length} surface${args.sessionResults.length === 1 ? "" : "s"} against ${args.appUrl}: ${passed}/${args.sessionResults.length} satisfied the scenario predicate.`,
+        summary: `Scenario ${args.journey.scenarioId} ran on ${plural(ran, "browser surface")} against ${args.appUrl}: ${passed}/${ran} passed it${gapsListClause(ran - passed, ran)}.`,
         gaps: args.sessionResults
             .filter((result) => result.status !== "passed")
             .map((result) => `${result.capture.surface.id}: ${result.reason}`),
     };
 }
-export function renderScriptedReviewMarkdown(bundle) {
+export function renderScriptedReviewMarkdown(bundle, status) {
     const subject = bundle.events.find((event) => event.type === "scripted-lab.subject.declared");
     const spend = bundle.events.find((event) => event.type === "scripted-lab.spend");
     const traces = bundle.streams
         .map((stream) => ({ stream, trace: stream.actor }))
         .filter((entry) => entry.trace !== undefined);
-    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, [
         `- scenario: ${bundle.scenario.id} @ ${bundle.scenario.sourceDigest} (${bundle.scenario.source})`,
         ...(subject ? [`- subject: ${subject.message}`] : []),
         ...(spend ? [`- spend: ${spend.message}`] : []),
         ...traces.map(({ stream, trace }) => `- ${recordIdOf(stream)}: ${trace.provider} (${trace.lane}/${trace.protocol}) ${trace.status} (${trace.completionReason}); ${plural(trace.counts.actions ?? 0, "step action")}, ${plural(trace.counts.screenshots ?? 0, "raw screenshot")}`),
-        ...(bundle.review.gaps.length > 0
-            ? ["", "## Gaps", ...bundle.review.gaps.map((gap) => `- ${gap}`)]
-            : []),
-        "",
-    ].join("\n");
+    ], { status });
 }

package/dist/routes/scripted/surface-records.d.ts

@@ -6,7 +6,6 @@ import { type ParticipantIds } from "../../run/participant-records.js";
 import type { RunStream } from "../../run/streams.js";
 /** What each surface's records read from the bundle arguments. */
 export interface ScriptedSurfaceContext {
-    actorId: string;
     appUrl: string;
     createdAt: string;
     journey: BrowserPersonaJourney;

package/dist/routes/scripted/surface-records.js

@@ -1,5 +1,7 @@
-// One scripted-browser surface's simulation and stream in the run bundle.
+import { judgeParticipantRecords } from "../../run/judge.js";
 import { participantIdsOf, participantRecord, participantStream, } from "../../run/participant-records.js";
+import { participantCaption } from "../../run/participant-caption.js";
+import { sessionEndingInWords } from "../../run/outcomes.js";
 /** A surface's saved ids: `scripted-<surface>` and its `-stream`. */
 export function scriptedSurfaceIds(surfaceId) {
     return participantIdsOf(`scripted-${surfaceId}`, `scripted-${surfaceId}-stream`);
@@ -11,14 +13,23 @@ export function scriptedSurfaceIds(surfaceId) {
 export function scriptedSurfaceRecords(context, surface, index, result, screenshots) {
     const ids = scriptedSurfaceIds(surface.id);
     const lastScreenshot = screenshots.at(-1);
-    const status = result
-        ? result.status
-        : context.sessionError !== undefined
-            ? "failed"
-            : "contract_proof_only";
-    const reason = result?.reason ??
-        context.sessionError ??
-        "Dry run: the scenario was pinned without launching a browser or touching the subject app.";
+    const { status, reason } = judgeParticipantRecords([
+        {
+            ...(result === undefined
+                ? {}
+                : {
+                    status: result.status,
+                    completionReason: result.completionReason,
+                    reason: result.reason,
+                }),
+            ...(context.sessionError === undefined ? {} : { sessionError: context.sessionError }),
+            skipped: false,
+            noEngagement: false,
+            selfReportedBlocker: false,
+        },
+    ], {
+        contractReason: "Dry run: the scenario was pinned without launching a browser or touching the subject app.",
+    }).participants[0];
     const simulation = participantRecord(ids, index + 1, {
         personaId: context.persona.id,
         scenarioId: context.journey.scenarioId,
@@ -28,16 +39,19 @@ export function scriptedSurfaceRecords(context, surface, index, result, screensh
         progress: 100,
         currentStep: reason,
         summary: result
-            ? `Scripted-browser actor (${context.actorId}) replayed ${context.journey.scenarioId} on the ${surface.id} surface; ${result.completionReason}.`
+            ? `Scenario ${context.journey.scenarioId} ran in the ${surface.id} browser and ${sessionEndingInWords(result.trace)}.`
             : context.sessionError !== undefined
-                ? `The scripted run failed before a terminal session verdict: ${context.sessionError}`
-                : `Scripted-browser actor (${context.actorId}) against ${context.appUrl}; no session ran.`,
+                ? `The run failed before the script finished: ${context.sessionError}`
+                : `Scenario ${context.journey.scenarioId} would replay in the ${surface.id} browser against ${context.appUrl}; no browser ran.`,
         startedAt: context.createdAt,
         updatedAt: result?.capture.capturedAt ?? context.createdAt,
     });
     const stream = participantStream(ids, {
         kind: "browser",
-        label: `${surface.label} · ${context.studyId}`,
+        label: participantCaption({
+            personaId: context.persona.id,
+            device: { name: surface.id, preset: { isMobile: surface.viewport.isMobile } },
+        }),
         status,
         transport: "snapshot",
         updatedAt: result?.capture.capturedAt ?? context.createdAt,

package/dist/routes/shared-world/bundle-records.d.ts

@@ -1,14 +1,14 @@
 import type { RunEvent, RunSimulation } from "../../run/bundle.js";
+import type { judgeParticipantRecords } from "../../run/judge.js";
 import type { RunStream } from "../../run/streams.js";
 import type { DesktopParticipantRun } from "../computer-use/types.js";
 import type { ConcurrentBundleArgs } from "./types.js";
 /** What every participant's records share. */
 export interface SharedWorldRecordContext {
     args: ConcurrentBundleArgs;
+    participants: ReturnType<typeof judgeParticipantRecords>["participants"];
     external: boolean;
     inProgress: boolean;
-    /** The public-safe plane label: never the raw getHost URL or public origin. */
-    appUrl: string;
     /** Numbers events in the order they are pushed. */
     nextEventId: (suffix: string) => string;
 }

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

@@ -3,14 +3,13 @@
 // running).
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { participantEvent, participantRecord, participantStream, } from "../../run/participant-records.js";
-import { judgedStatus } from "../../run/judge.js";
 import { declaredScreenForRender } from "../../substrates/e2b/desktop-geometry.js";
-import { participantFactsOf } from "../computer-use/participant-facts.js";
 import { publicSafeRouteLabel } from "./provenance.js";
-import { participantTaxonomyLabel } from "./participant-specs.js";
+import { participantCaption } from "../../run/participant-caption.js";
+import { sessionEndingInWords } from "../../run/outcomes.js";
 function participantView(ctx, spec, index) {
-    const { args, external, inProgress } = ctx;
-    const taxonomy = participantTaxonomyLabel(spec.planned.labels);
+    const { args, external } = ctx;
+    const name = participantCaption({ id: spec.planned.id, personaId: spec.persona.id });
     const result = args.actorResults[index];
     const outcome = result?.outcome;
     const session = outcome?.session;
@@ -21,18 +20,8 @@ function participantView(ctx, spec, index) {
     const route = external
         ? "[external-public-plane]"
         : publicSafeRouteLabel(args.plan.plane.participants[index]?.entry);
-    const status = session
-        ? session.status
-        : outcome?.sessionError !== undefined
-            ? "failed"
-            : inProgress
-                ? "running"
-                : "contract_proof_only";
-    const reason = session?.reason ??
-        outcome?.sessionError ??
-        (inProgress
-            ? "Actor desktop is running; the attached Observer hydrates the runtime stream URL without persisting it."
-            : "Dry run: the evidence shape was written without launching a desktop or spending provider tokens.");
+    const judgment = ctx.participants[index];
+    const { status, reason } = judgment;
     const traceScreenshotMode = session?.trace.redaction.screenshots;
     // Include `declared` on the no-outcome fallback too (dry-run, skipped participant): otherwise an
     // absent `declared` means either "the preset rendered faithfully" or "there was no live
@@ -53,7 +42,8 @@ function participantView(ctx, spec, index) {
             ? "blurred"
             : "raw";
     return {
-        taxonomy,
+        name,
+        judgment,
         outcome,
         session,
         screenshots,
@@ -67,7 +57,7 @@ function participantView(ctx, spec, index) {
 }
 function sharedWorldSimulation(ctx, spec, index, view) {
     const { args, inProgress } = ctx;
-    const { taxonomy, outcome, session } = view;
+    const { name, outcome, session } = view;
     return participantRecord(spec, index + 1, {
         personaId: spec.persona.id,
         scenarioId: `concurrent-shared-world-${args.plan.studyId}`,
@@ -77,27 +67,31 @@ function sharedWorldSimulation(ctx, spec, index, view) {
         progress: inProgress ? 35 : 100,
         currentStep: view.reason,
         summary: session
-            ? `Persona ${spec.planned.id}${taxonomy} (${spec.persona.id}): drove the shared plane concurrently; ${session.completionReason}.`
+            ? `${name} used the shared app and ${sessionEndingInWords(session.trace)}.`
             : outcome?.sessionError !== undefined
-                ? `Persona ${spec.planned.id}${taxonomy} failed before a terminal session verdict: ${outcome.sessionError}`
+                ? `${name} did not finish a session: ${outcome.sessionError}`
                 : inProgress
-                    ? `Persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) is running against the shared plane.`
-                    : `Persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) for ${args.descriptor.id} against the shared plane at ${ctx.appUrl}; no session ran.`,
+                    ? `${name} is using the shared app.`
+                    : `${name} would use the shared app; no session ran.`,
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
     });
 }
 function sharedWorldStream(ctx, spec, index, view) {
     const { args } = ctx;
-    const { taxonomy, session, screenshots, lastScreenshot, desktopGeometry, screenshotMode } = view;
-    // The judge's status for the participant, so the Observer shows it the way the verdict judged it.
-    const judged = view.outcome === undefined ? undefined : judgedStatus(participantFactsOf(view.outcome));
+    const { name, session, screenshots, lastScreenshot, desktopGeometry, screenshotMode } = view;
+    const judged = view.judgment.judgedStatus;
+    const caption = participantCaption({
+        id: spec.planned.id,
+        personaId: spec.persona.id,
+        device: spec.planned.device,
+    });
     return participantStream(spec, {
         ...(spec.evidenceAssignment === undefined
             ? {}
             : { assignment: participantAssignment(spec.evidenceAssignment) }),
         kind: "browser",
-        label: `Concurrent persona ${spec.planned.id}${taxonomy} · ${args.plan.studyId}`,
+        label: caption,
         status: view.status,
         ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
@@ -106,9 +100,9 @@ function sharedWorldStream(ctx, spec, index, view) {
             ? {
                 kind: "screenshot",
                 url: lastScreenshot,
-                title: `Shared plane, persona ${spec.planned.id} (${screenshotMode})`,
+                title: `${caption} (${screenshotMode})`,
             }
-            : { kind: "placeholder", title: `Shared plane, persona ${spec.planned.id}` },
+            : { kind: "placeholder", title: caption },
         ...(desktopGeometry.viewport === undefined
             ? {}
             : {
@@ -122,7 +116,7 @@ function sharedWorldStream(ctx, spec, index, view) {
         desktopGeometry,
         ui: {
             route: view.route,
-            intent: `Watch persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) use the shared app at the same time as the other personas.`,
+            intent: `Watch ${name} use the shared app at the same time as the others.`,
             state: view.reason,
             ...(session ? { actorStatus: session.status } : {}),
             ...(lastScreenshot ? { screenshotUrl: lastScreenshot } : {}),

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

@@ -17,4 +17,4 @@ export declare function judgeSharedWorldRun(args: Omit<ConcurrentBundleArgs, "ju
 export declare function actorRunPassed(result: ActorRunResult | undefined): boolean;
 /** Project the concurrent run into a humanish.run-bundle.v1 with the concurrent shared-world block. */
 export declare function buildConcurrentSharedWorldBundle(args: ConcurrentBundleArgs): RunBundle;
-export declare function renderConcurrentReviewMarkdown(bundle: RunBundle): string;
+export declare function renderConcurrentReviewMarkdown(bundle: RunBundle, status?: unknown): string;