humanish 0.111.4 → 0.112.0

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,30 @@ 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;
     return participantStream(spec, {
         ...(spec.evidenceAssignment === undefined
             ? {}
             : { assignment: participantAssignment(spec.evidenceAssignment) }),
         kind: "browser",
-        label: `Concurrent persona ${spec.planned.id}${taxonomy} · ${args.plan.studyId}`,
+        label: participantCaption({
+            id: spec.planned.id,
+            personaId: spec.persona.id,
+            device: spec.planned.device,
+        }),
         status: view.status,
         ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
@@ -122,7 +115,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;

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

@@ -9,13 +9,14 @@ import { commandDigestOf } from "../../subject/state.js";
 import { buildRunCostSummary, desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { participantFactsOf } from "../computer-use/participant-facts.js";
 import { participantFeedbackCandidates } from "../computer-use/participant-feedback.js";
-import { judgeSharedWorld, participantPassed, sharedWorldShortfall, verdictText, } from "../../run/judge.js";
-import { reviewOutcome } from "../../run/display.js";
+import { judgeSharedWorld, judgeParticipantRecords, participantPassed, sharedWorldShortfall, } from "../../run/judge.js";
+import { renderReviewMarkdown } from "../../run/review-markdown.js";
 import { combineCheckpointDigest } from "./checkpoints.js";
 import { hostOriginDigest } from "./provenance.js";
 import { participantEvent, participantIds } from "../../run/participant-records.js";
 import { sharedWorldParticipantRecords } from "./bundle-records.js";
 import { CONCURRENT_ATTRIBUTION_LIMITS, EXTERNAL_PUBLIC_ATTRIBUTION_LIMITS, } from "./types.js";
+import { gapsListClause } from "../../run/outcomes.js";
 import { plural } from "../../run/text.js";
 /** Max windows live at the same instant (sweep over start/end points). The simultaneity
  *  count: the participant count says how many existed; this says how many ever ran at once. */
@@ -63,33 +64,39 @@ export function actorRunPassed(result) {
     return result !== undefined && participantPassed(participantFactsOf(result.outcome));
 }
 /**
- * Keep three different claims separate in the stakeholder roll-up:
- *
- * - `outcome.ok` says the actor session passed the harness's credibility checks;
- * - `completionReason` says how the participant session ended;
- * - shared-world convergence is reported by the plane-specific summary alongside this line.
- *
- * None of those is adopter-scored proof that the mission text was completed. In particular, a
- * productive `budget_reached` session can coexist with lobby convergence without becoming a
- * `goal_satisfied` result.
+ * The run's summary in plain sentences: who took part, how many reached the goal, and what the
+ * world showed. A participant reached the goal when its session passed the judge's checks and
+ * ended at the goal, so a productive `budget_reached` session does not count even when the lobby
+ * converged. Each participant's ending stays in `sharedWorld.outcomes`, and the plane, topology
+ * and attribution limits stay in the bundle's events and `sharedWorld` block.
  */
-function formatSharedWorldActorOutcomes(outcomes, expectedCount) {
-    const passedSessions = outcomes.filter((outcome) => outcome.ok).length;
-    const goalSatisfiedSessions = outcomes.filter((outcome) => outcome.ok && outcome.completionReason === "goal_satisfied").length;
-    const completionReasonCounts = new Map();
-    for (const outcome of outcomes) {
-        const reason = outcome.completionReason ?? "not_recorded";
-        completionReasonCounts.set(reason, (completionReasonCounts.get(reason) ?? 0) + 1);
+function sharedWorldSummary(args, facts) {
+    const count = args.actorSpecs.length;
+    const people = plural(count, "participant");
+    const app = facts.external ? "one public app" : "one shared app";
+    if (args.dryRun) {
+        const served = facts.external ? ", as it is deployed" : ", served from a sandbox";
+        return `Dry run: ${people} would use ${app} at the same time${served}. No sandboxes were launched and $0 was spent.`;
     }
-    for (let missing = outcomes.length; missing < expectedCount; missing += 1) {
-        completionReasonCounts.set("not_recorded", (completionReasonCounts.get("not_recorded") ?? 0) + 1);
+    if (facts.inProgress) {
+        return `${people} ${count === 1 ? "is" : "are"} using ${app} at the same time. The run is still going, so nothing here is final.`;
     }
-    const completionReasons = [...completionReasonCounts.entries()]
-        // ASCII contract tokens: compare directly so bundle text is byte-stable across host locales.
-        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-        .map(([reason, count]) => `${reason} ${count}/${expectedCount}`)
-        .join(", ");
-    return `${passedSessions}/${plural(expectedCount, "actor session")} passed credibility checks; mission endpoint: ${goalSatisfiedSessions}/${expectedCount} ended goal_satisfied; completion reasons: ${completionReasons}`;
+    const passed = facts.outcomes.filter((outcome) => outcome.ok);
+    const reached = passed.filter((outcome) => outcome.completionReason === "goal_satisfied").length;
+    const together = facts.overlaps ? " at the same time" : ", but never at the same time";
+    // A participant who did not pass has a gap line; one who passed but stopped short has none.
+    const rest = [
+        passed.length > reached ? `; ${passed.length - reached} ended without reaching it` : "",
+        gapsListClause(count - passed.length, count),
+    ].join("");
+    const world = facts.external
+        ? args.lobbyConvergenceDigest
+            ? `All ${count} ended up in the same lobby.`
+            : "humanish did not see them all end up in the same lobby."
+        : facts.deltas === 0
+            ? "The app's shared state did not change during the run."
+            : `The app's shared state changed ${plural(facts.deltas, "time")} during the run.`;
+    return `${people} used ${app}${together}. ${reached} of ${count} reached the goal${rest}. ${world}`;
 }
 /** The run's first two events: its creation and the shared plane's provenance. */
 function planeEvents(args, external) {
@@ -234,19 +241,13 @@ function sharedWorldEvidence(args, external, inProgress, planeCommit) {
  * A finished run's gaps: each participant that did not pass, or, when every participant passed, the
  * world shortfall that failed the run.
  */
-function finishedGaps(actorResults, shortfall) {
-    const participantGaps = actorResults
-        .filter((result) => result.outcome.sessionError !== undefined ||
-        result.outcome.noEngagement ||
-        result.outcome.selfReportedBlocker ||
-        result.outcome.session === undefined ||
-        result.outcome.session.status !== "passed")
-        .map((result) => `${result.spec.planned.id}: ${result.outcome.sessionError ?? result.outcome.session?.reason ?? "did not pass"}`);
+function finishedGaps(participants, shortfall) {
+    const participantGaps = participants.flatMap((participant) => participant.gapLine === undefined ? [] : [participant.gapLine]);
     return participantGaps.length === 0 && shortfall !== undefined ? [shortfall] : participantGaps;
 }
 /** Records the concurrency event and returns the review. */
-function concurrencyReview(args, external, inProgress, evidence, events, nextEventId) {
-    const { plan, descriptor, run: { createdAt }, dryRun, actorSpecs, actorResults, } = args;
+function concurrencyReview(args, external, inProgress, evidence, events, nextEventId, participants) {
+    const { plan, run: { createdAt }, dryRun, } = args;
     const { sharedWorld, windows, stateSeries, outcomes } = evidence;
     const overlaps = args.judgment.world.overlap;
     const deltas = (stateSeries ?? []).filter((snapshot, i) => i > 0 && snapshot.digest !== (stateSeries ?? [])[i - 1].digest).length;
@@ -268,25 +269,12 @@ function concurrencyReview(args, external, inProgress, evidence, events, nextEve
         message: `Concurrency: ${plural(windows.length, "participant")}${dryRun ? " (dry run; $0)" : `, up to ${maxLive} live at once (cap ${capForReport}), overlap ${overlaps ? "shown" : "not observed"}`}; ${stateSeriesLabel}${convergenceLabel}. Attribution ceiling: ${sharedWorld.attributionLimits.join(", ")}. ${dryRun ? "This dry run proves nothing about live concurrency, scale, or adoption." : "This run reports only its own observed overlap and state changes; it does not prove scale, repeatability, or adopter-harness replacement."}`,
     });
     // The judge's verdict (judgeSharedWorld): every participant produced a terminal, engaged, passed
-    // session. Mission endpoint and completion reasons are reported separately below; `outcomes[].ok`
-    // is not renamed into mission success.
-    const verdict = args.judgment.verdict;
-    const actorOutcomeSummary = formatSharedWorldActorOutcomes(outcomes, actorSpecs.length);
+    // session and the world showed the concurrency verify requires.
     const review = {
         schema: REVIEW_SCHEMA,
-        verdict,
-        // Plane-class-aware: the external-public plane has no getHost/clone/seed and carries no
-        // authoritative state series, so its summary must not claim a getHost-exposed plane (dry-run) nor
-        // report "state delta(s) under load" (live). It reports lobby convergence instead.
-        summary: dryRun
-            ? external
-                ? `Concurrent shared-world dry run: ${plural(actorSpecs.length, "persona")} declared against one public deployment, used as it is (no sandbox, clone or seed); no sandboxes launched, $0 spent.`
-                : `Concurrent shared-world dry run: ${plural(actorSpecs.length, "persona")} declared against one app served at a public sandbox URL (${descriptor.id}); no sandboxes launched, $0 spent.`
-            : inProgress
-                ? `In-progress concurrent shared-world Observer snapshot: ${plural(actorSpecs.length, "persona")} running against one shared app; final verification is pending.`
-                : external
-                    ? `Concurrent shared-world (one public deployment, ${actorSpecs.length} personas at once): swarm ${verdict === "pass" ? "ran coherently" : "did not run coherently"}; ${actorOutcomeSummary}; overlap ${overlaps ? "proven" : "not observed"}; ${args.lobbyConvergenceDigest ? `${actorSpecs.length} participants converged on one lobby` : "lobby convergence not observed"}.`
-                    : `Concurrent shared-world (one shared app, ${actorSpecs.length} personas at once): swarm ${verdict === "pass" ? "ran coherently" : "did not run coherently"}; ${actorOutcomeSummary}; overlap ${overlaps ? "proven" : "not observed"}; ${plural(deltas, "state delta")} under load.`,
+        verdict: args.judgment.verdict,
+        // The external-public app has no state series, so its summary reports the lobby instead.
+        summary: sharedWorldSummary(args, { external, inProgress, overlaps, deltas, outcomes }),
         gaps: dryRun
             ? [
                 "This dry run launched no concurrent shared-world session; it checks the evidence shape only, not live behavior, scale, or adopter-harness replacement.",
@@ -295,7 +283,7 @@ function concurrencyReview(args, external, inProgress, evidence, events, nextEve
                 ? [
                     "Final actor traces, screenshots, state deltas, and verification are pending; this Observer is for live watch only.",
                 ]
-                : finishedGaps(actorResults, sharedWorldShortfall(args.judgment.world)),
+                : finishedGaps(participants, sharedWorldShortfall(args.judgment.world)),
     };
     return review;
 }
@@ -306,15 +294,26 @@ export function buildConcurrentSharedWorldBundle(args) {
     const external = (args.planeClass ?? "provisioned-getHost") === "external-public";
     const simulations = [];
     const streams = [];
-    // Public-safe label only: neither the raw getHost URL (provisioned) nor the raw public origin
-    // (external-public) lands in the bundle. The plane identity is a digest (plane.hostDigest on
-    // getHost; plane.publicOriginDigest on external-public).
-    const appUrl = external ? "[external-public-plane]" : "[provisioned-subject]";
     const planeCommit = external ? undefined : dryRun ? undefined : args.subjectCommit;
     const events = planeEvents(args, external);
     let eventSeq = 2;
     const nextEventId = (suffix) => `event-${String(eventSeq++).padStart(3, "0")}-${suffix}`;
-    const recordContext = { args, external, inProgress, appUrl, nextEventId };
+    const judgment = judgeParticipantRecords(actorSpecs.map((spec, index) => ({
+        ...participantFactsOf(actorResults[index]?.outcome),
+        id: spec.planned.id,
+        inProgress: inProgress && actorResults[index] === undefined,
+    })), {
+        runningReason: "Actor desktop is running; the attached Observer hydrates the runtime stream URL without persisting it.",
+        sessionLabel: "Participant",
+        missingSessionMessage: "Actor did not produce a terminal session.",
+    });
+    const recordContext = {
+        args,
+        external,
+        inProgress,
+        nextEventId,
+        participants: judgment.participants,
+    };
     actorSpecs.forEach((spec, index) => {
         const records = sharedWorldParticipantRecords(recordContext, spec, index);
         simulations.push(records.simulation);
@@ -323,7 +322,7 @@ export function buildConcurrentSharedWorldBundle(args) {
     });
     const evidence = sharedWorldEvidence(args, external, inProgress, planeCommit);
     const { sharedWorld } = evidence;
-    const review = concurrencyReview(args, external, inProgress, evidence, events, nextEventId);
+    const review = concurrencyReview(args, external, inProgress, evidence, events, nextEventId, judgment.participants.filter((_, index) => actorResults[index] !== undefined));
     const anyRaw = actorResults.some((result) => result.outcome.session?.trace.redaction.screenshots === "raw");
     const ranLive = actorResults.some((result) => result.outcome.session !== undefined || result.outcome.sessionError !== undefined);
     const cost = concurrentCostSummary(args, inProgress);
@@ -335,7 +334,7 @@ export function buildConcurrentSharedWorldBundle(args) {
         }),
         persona: {
             id: actorSpecs[0]?.persona.id ?? "concurrent-persona",
-            name: `Concurrent shared-world swarm (${actorSpecs.length} personas)`,
+            name: `${plural(actorSpecs.length, "participant")} in one ${external ? "public" : "shared"} app`,
             source: `study:${plan.studyId}`,
             sourceDigest: actorSpecs[0]?.persona.promptDigest ?? args.seedDigest,
         },
@@ -456,27 +455,20 @@ function declaredStateDigest(state) {
     const probes = state?.checkpoint ?? [];
     return combineCheckpointDigest(probes.map((probe) => `${probe.name}=${commandDigestOf(probe.command)}`));
 }
-export function renderConcurrentReviewMarkdown(bundle) {
+export function renderConcurrentReviewMarkdown(bundle, status) {
     const plane = bundle.events.find((event) => event.type === "concurrent-shared-world.plane.provenance");
     const concurrency = bundle.events.find((event) => event.type === "concurrent-shared-world.concurrency");
     const sw = bundle.sharedWorld;
-    return [
-        `# ${bundle.scenario.title}`,
-        "",
-        `- run: ${bundle.runId}`,
-        `- mode: ${bundle.mode}`,
-        `- attribution class: ${bundle.attributionClass ?? "isolated"}`,
-        `- topology: ${sw?.topology ?? "(none)"} / ${sw?.topologyMode ?? "(none)"}`,
-        `- personas: ${sw?.roleCount ?? 0}`,
-        `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
-        `- outcome: ${reviewOutcome(bundle)}`,
-        `- summary: ${bundle.review.summary}`,
+    return renderReviewMarkdown(bundle, [
         ...(plane ? [`- plane: ${plane.message}`] : []),
         ...(concurrency ? [`- concurrency: ${concurrency.message}`] : []),
         ...(sw ? [`- attribution limits: ${sw.attributionLimits.join(", ")}`] : []),
-        ...(bundle.review.gaps.length > 0
-            ? ["", "## Gaps", ...bundle.review.gaps.map((gap) => `- ${gap}`)]
-            : []),
-        "",
-    ].join("\n");
+    ], {
+        status,
+        beforeVerdict: [
+            `- attribution class: ${bundle.attributionClass ?? "isolated"}`,
+            `- topology: ${sw?.topology ?? "(none)"} / ${sw?.topologyMode ?? "(none)"}`,
+            `- personas: ${sw?.roleCount ?? 0}`,
+        ],
+    });
 }

package/dist/routes/shared-world/participant-specs.d.ts

@@ -1,5 +1,5 @@
 import type { SharedWorldPlan } from "../../study/plan-types.js";
-import type { Participant, SharedWorldParticipant } from "../../study/plan-participants.js";
+import type { SharedWorldParticipant } from "../../study/plan-participants.js";
 import type { RunBundle } from "../../run/bundle.js";
 import type { DesktopParticipantRun, ParticipantRunOutcome } from "../computer-use/types.js";
 import { type DesktopParticipantDeps } from "../computer-use/participant-deps.js";
@@ -8,7 +8,6 @@ export declare function defaultSessionTimeoutMs(plan: SharedWorldPlan): number;
 /** Resolve an actor's participant URL against the harness-minted getHost base (entry is a
  *  same-origin relative path, validated at parse against serve.url). */
 export declare function resolveActorEntryUrl(baseUrl: string, entry: string | undefined): string;
-export declare function participantTaxonomyLabel(labels: Participant["labels"]): string;
 /** Thread the host-yielded lobby code into a follower's mission at runtime (external-public route).
  *  The code flows into the follower's join instruction; it is persisted only as the composed prompt
  *  the model reads (never a raw bundle field), and humanish scrubs the code from all narration. The

package/dist/routes/shared-world/participant-specs.js

@@ -45,14 +45,6 @@ export function resolveActorEntryUrl(baseUrl, entry) {
         return baseUrl;
     }
 }
-export function participantTaxonomyLabel(labels) {
-    const parts = [
-        labels.actorType ? `type:${labels.actorType}` : undefined,
-        labels.surface ? `surface:${labels.surface}` : undefined,
-        labels.caseGroup ? `case:${labels.caseGroup}` : undefined,
-    ].filter((part) => part !== undefined);
-    return parts.length > 0 ? ` (${parts.join(" / ")})` : "";
-}
 /** Build one participant's DesktopParticipantRun from its plan (each participant has its own
  *  desktop, so its own device). */
 function buildActorSpec(participant, personas) {

package/dist/routes/shared-world/result.js

@@ -3,9 +3,9 @@
 import { redactText } from "../../evidence/redaction.js";
 import { adapterScoreFailureMessage, applyBrowserScorer } from "../../study/adapter-extension.js";
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
-import { foldScorerFailures, judgeExecution, sandboxCleanupFailure, OUTCOME_POLICIES, resultOk, sharedWorldShortfall, } from "../../run/judge.js";
+import { foldScorerFailures, judgeParticipantRecords, judgeExecution, sandboxCleanupFailure, OUTCOME_POLICIES, resultOk, sharedWorldShortfall, } from "../../run/judge.js";
 import { validatePreparedRunArtifactPaths } from "../../run/paths.js";
-import { participantExecutionFailures } from "../computer-use/participant-facts.js";
+import { participantExecutionFailures, participantFactsOf, } from "../computer-use/participant-facts.js";
 import { participantCapWarning } from "../computer-use/participant-model.js";
 import { resolveSubjectState } from "../computer-use/subject-projection.js";
 import { actorRunPassed, buildConcurrentSharedWorldBundle, judgeSharedWorldRun, maxSimultaneousWindows, } from "./bundle.js";
@@ -70,14 +70,10 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
                 : {
                     error: {
                         code: "HUMANISH_SHARED_WORLD_FAILED",
-                        message: result.outcome.sessionError ??
-                            (result.outcome.noEngagement
-                                ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
-                                : result.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"
-                                        ? `Participant ended with a harness error: ${session.reason}`
-                                        : "Actor did not produce a terminal session."),
+                        message: judgeParticipantRecords([participantFactsOf(result.outcome)], {
+                            sessionLabel: "Participant",
+                            missingSessionMessage: "Actor did not produce a terminal session.",
+                        }).participants[0].notPassedMessage,
                     },
                 }),
         };
@@ -126,7 +122,7 @@ function concurrentStudyError(args) {
     if (passed === participantCount && args.shortfall !== undefined) {
         return {
             code: "HUMANISH_SHARED_WORLD_FAILED",
-            message: `Concurrent shared-world run did not run coherently. ${args.shortfall}`,
+            message: `The shared-world run failed although every participant passed. ${args.shortfall}`,
         };
     }
     if (passed === participantCount && args.executionFailure !== undefined) {
@@ -137,7 +133,7 @@ function concurrentStudyError(args) {
     }
     return {
         code: "HUMANISH_SHARED_WORLD_FAILED",
-        message: `Concurrent shared-world run did not run coherently: ${passed}/${plural(participantCount, "actor")} reached a terminal, engaged passed session.`,
+        message: `The shared-world run failed: ${passed} of ${plural(participantCount, "participant")} passed. The run's review.md lists what happened to the others.`,
     };
 }
 /**

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

@@ -71,4 +71,4 @@ export declare function buildLiveTerminalProductBundle(args: {
      *  the review names, beside the agent's own verdict. */
     capFailure?: string;
 }): RunBundle;
-export declare function renderTerminalReviewMarkdown(bundle: RunBundle): string;
+export declare function renderTerminalReviewMarkdown(bundle: RunBundle, status?: unknown): string;