humanish 0.111.4 → 0.113.0

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,24 +241,18 @@ 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;
     const stateSeriesLabel = external
-        ? "stateSeries omitted (no authoritative shared-state proof on the external-public plane)"
+        ? "Shared app state was not recorded because the app is hosted outside humanish"
         : `stateSeries ${plural((stateSeries ?? []).length, "snapshot")}, ${plural(deltas, "delta")}`;
     const convergenceLabel = external
         ? `; lobby convergence ${args.lobbyConvergenceDigest ? "shown (all participants reached one /lobby/CODE)" : "not observed"}`
@@ -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;

package/dist/routes/terminal/bundle.js

@@ -1,12 +1,14 @@
 import { redactText } from "../../evidence/redaction.js";
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
-import { verdictText } from "../../run/judge.js";
-import { reviewOutcome } from "../../run/display.js";
+import {} from "../../run/judge.js";
+import { renderReviewMarkdown } from "../../run/review-markdown.js";
 import {} from "../../run/streams.js";
 import { participantEvent, participantIds, participantRecord, participantStream, } from "../../run/participant-records.js";
 import { TERMINAL_EVENTS_ARTIFACT, TERMINAL_LEDGERS_ARTIFACT, TERMINAL_TRANSCRIPT_ARTIFACT, } from "../../run/terminal-contract.js";
 import { DEFAULT_RUNTIME_AUTH } from "./runtime-auth.js";
+import { participantCaption } from "../../run/participant-caption.js";
+import { formatParticipantOutcomes, tallyParticipantOutcomes } from "../../run/outcomes.js";
 import { describeMeasuredSpend, noSpendLineMeasured, noSpendNotEstablished } from "./ledger.js";
 /**
  * Project the terminal-product run into a humanish.run-bundle.v1 (no schema change: a new
@@ -80,7 +82,7 @@ export function buildTerminalProductBundle(args) {
     const review = {
         schema: REVIEW_SCHEMA,
         verdict: args.verdict,
-        summary: reason,
+        summary: `Dry run: 1 participant would try ${args.productName} from a terminal. No sandbox was created, no key was used and $0 was spent.`,
         gaps: [
             "This dry run did not execute the live in-sandbox agent route; it checks the evidence shape only, not live behavior, scale, or adoption.",
             "No exec-stream, transcript, substrate, cost, or cleanup artifacts were produced because no live session ran; live verification requires those artifacts.",
@@ -164,7 +166,7 @@ export function buildLiveTerminalProductBundle(args) {
     const review = {
         schema: REVIEW_SCHEMA,
         verdict: args.verdict,
-        summary: args.sessionReason,
+        summary: `1 participant took part: ${formatParticipantOutcomes(tallyParticipantOutcomes([args.trace.status]))}. How it ended: ${args.sessionReason}`,
         gaps: [
             ...(args.trace.status === "passed"
                 ? []
@@ -212,7 +214,7 @@ function terminalParticipant(args, session) {
     const stream = participantStream(TERMINAL_IDS, {
         assignment: participantAssignment({ mission: args.mission }),
         kind: "terminal",
-        label: `Terminal agent · ${args.studyId}`,
+        label: participantCaption({ personaId: args.persona.id }),
         status: session.status,
         transport: "snapshot",
         updatedAt: session.updatedAt,
@@ -275,25 +277,14 @@ function describeCaps(caps) {
         parts.push(`maxMinutes=${caps.maxMinutes}`);
     return parts.length > 0 ? parts.join(", ") : "empty";
 }
-export function renderTerminalReviewMarkdown(bundle) {
+export function renderTerminalReviewMarkdown(bundle, status) {
     const subject = bundle.events.find((event) => event.type === "terminal-lab.subject.declared");
     const credentials = bundle.events.find((event) => event.type === "terminal-lab.credentials.declared");
     const caps = bundle.events.find((event) => event.type === "terminal-lab.caps.declared");
-    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, [
         `- mission: ${bundle.scenario.goal}`,
         ...(subject ? [`- subject: ${subject.message}`] : []),
         ...(credentials ? [`- credentials: ${credentials.message}`] : []),
         ...(caps ? [`- caps: ${caps.message}`] : []),
-        ...(bundle.review.gaps.length > 0
-            ? ["", "## Gaps", ...bundle.review.gaps.map((gap) => `- ${gap}`)]
-            : []),
-        "",
-    ].join("\n");
+    ], { status });
 }

package/dist/routes/terminal/dry-run.js

@@ -124,6 +124,7 @@ function runtimeDeclaredEvent(runtime, createdAt) {
         level: "info",
         type: "terminal-lab.runtime.declared",
         message: redactText(JSON.stringify(declaredRuntimeProvenance({
+            doNotTrack: runtime.doNotTrack,
             ...(version === undefined ? {} : { version }),
             model,
             modelSource,

package/dist/routes/terminal/live-sandbox.js

@@ -261,7 +261,10 @@ export class LiveTerminalSandbox {
                 // The install step may run the product itself (release:dogfood's does: `humanish init
                 // --yes`); on the 0.67.0 dogfood that one command arrived unmarked while the participant's
                 // nine others carried the marker.
-                envs: { HUMANISH_STUDY_PARTICIPANT: "1" },
+                envs: {
+                    HUMANISH_STUDY_PARTICIPANT: "1",
+                    ...(plan.runtime.doNotTrack ? { DO_NOT_TRACK: "1" } : {}),
+                },
                 requestTimeoutMs,
                 timeoutMs: PRODUCT_SETUP_TIMEOUT_MS,
             });
@@ -314,7 +317,11 @@ export class LiveTerminalSandbox {
                 // The selected command env (raw key or inert placeholder). The participant
                 // marker rides the same command: humanish telemetry from inside a study reads as a new
                 // adopter otherwise.
-                envs: { ...runtimeEnv.envs, HUMANISH_STUDY_PARTICIPANT: "1" },
+                envs: {
+                    ...runtimeEnv.envs,
+                    HUMANISH_STUDY_PARTICIPANT: "1",
+                    ...(plan.runtime.doNotTrack ? { DO_NOT_TRACK: "1" } : {}),
+                },
                 requestTimeoutMs,
                 timeoutMs: wallClockMs,
                 onStdout: (data) => recordStreamedTerminalChunk("stdout", data),

package/dist/routes/terminal/plan.js

@@ -69,6 +69,7 @@ export function planTerminalStudy(config, input) {
         ...(actor?.persona === undefined ? {} : { personaId: actor.persona }),
         ...(actor?.mission === undefined ? {} : { mission: actor.mission }),
         runtime: {
+            doNotTrack: config.execution?.terminal?.doNotTrack !== false,
             ...(runtimeVersion === undefined ? {} : { version: runtimeVersion }),
             // Codex's own default can change with any release and its JSON stream does not name it, so
             // the route always passes a model: the declared one, else humanish's participant default.

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

@@ -8,6 +8,7 @@ export declare function parseTerminalRuntimeVersion(stdout: string): string | un
 export declare function buildRuntimeVersionCommand(requestedVersion?: string): string;
 export declare function buildRuntimeExecPrefix(version: string, model: string, reasoningEffort?: ReasoningEffort): string;
 export declare function declaredRuntimeProvenance(args: {
+    doNotTrack: boolean;
     version?: string;
     model: string;
     modelSource: "declared" | "humanish_default";

package/dist/routes/terminal/runtime.js

@@ -35,6 +35,7 @@ export function declaredRuntimeProvenance(args) {
     return {
         schema: "humanish.actor-runtime.v1",
         package: TERMINAL_RUNTIME_PACKAGE,
+        doNotTrack: args.doNotTrack,
         requestedVersion: args.version ?? "latest",
         versionStatus: "unobserved",
         requestedModel: args.model,

package/dist/routes/terminal/session.js

@@ -75,6 +75,7 @@ export async function runLiveTerminalSession(args) {
     });
     const { version, model, modelSource, reasoningEffort } = plan.runtime;
     const runtime = declaredRuntimeProvenance({
+        doNotTrack: plan.runtime.doNotTrack,
         ...(version === undefined ? {} : { version }),
         model: sanitize(model),
         modelSource,

package/dist/run/costs.js

@@ -1,4 +1,4 @@
-import { round6 } from "./pricing.js";
+import { runEstimateUsd, sumEstimatedUsd } from "./run-cost.js";
 import { bindExistingRunArtifactPaths } from "./paths.js";
 import { contradictsAccountBilling } from "../verify/costs.js";
 import { EVIDENCE_LIMITS } from "../analysis/evidence.js";
@@ -20,13 +20,9 @@ export function emptyCostTotals() {
         analysisHistoryUncertainRuns: 0,
     };
 }
-const isKnownUsd = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
-function sumKnown(a, b) {
-    return a === null && b === null ? null : round6((a ?? 0) + (b ?? 0));
-}
 export function addCostTotals(into, next) {
     for (const key of ["estimatedTotalUsd", "runEstimatedUsd", "analysisEstimatedUsd"]) {
-        into[key] = sumKnown(into[key], next[key]);
+        into[key] = sumEstimatedUsd(into[key], next[key]);
     }
     for (const key of [
         "incompleteRunEstimates",
@@ -49,11 +45,7 @@ export async function readCostTotals(cwd, entry) {
     const analysisWarnings = [];
     // A dry run makes no model request and creates no desktop, so with no figure it costs $0. A
     // recorded unknown (null) figure stays unknown.
-    costs.runEstimatedUsd = isKnownUsd(entry.estimatedCostUsd)
-        ? entry.estimatedCostUsd
-        : entry.estimatedCostUsd === undefined && entry.mode === "dry-run"
-            ? 0
-            : null;
+    costs.runEstimatedUsd = runEstimateUsd(entry);
     try {
         const prepared = await bindExistingRunArtifactPaths(cwd, entry.runId);
         const bytes = await readBoundedFile(prepared, RUN_BUNDLE_FILE, EVIDENCE_LIMITS.sourceBytes);
@@ -70,9 +62,7 @@ export async function readCostTotals(cwd, entry) {
             runWarnings.push("RUN_COST_ID_MISMATCH");
         }
         if (bundle?.cost !== undefined) {
-            costs.runEstimatedUsd = isKnownUsd(bundle.cost?.estimatedTotalUsd)
-                ? bundle.cost.estimatedTotalUsd
-                : null;
+            costs.runEstimatedUsd = runEstimateUsd({ estimatedCostUsd: bundle.cost?.estimatedTotalUsd });
             if (bundle.cost?.fullyEstimated !== true || costs.runEstimatedUsd === null) {
                 costs.incompleteRunEstimates = 1;
                 runWarnings.push("RUN_COST_PARTIAL_OR_UNKNOWN");
@@ -102,7 +92,7 @@ export async function readCostTotals(cwd, entry) {
         costs.analysisHistoryUncertainRuns = 1;
         analysisWarnings.push("STUDY_COST_ACCOUNTING_UNAVAILABLE");
     }
-    costs.estimatedTotalUsd = sumKnown(costs.runEstimatedUsd, costs.analysisEstimatedUsd);
+    costs.estimatedTotalUsd = sumEstimatedUsd(costs.runEstimatedUsd, costs.analysisEstimatedUsd);
     return {
         runId: entry.runId,
         costs,
@@ -153,16 +143,15 @@ export async function readAnalysisAccounting(prepared) {
         }
         if (!usage.dispatched) {
             accounting.notDispatched += 1;
-            accounting.estimatedUsd = sumKnown(accounting.estimatedUsd, 0);
+            accounting.estimatedUsd = sumEstimatedUsd(accounting.estimatedUsd, 0);
             continue;
         }
         accounting.dispatched += 1;
         if (record.receipt)
             providers.add(record.receipt.provider);
-        if (isKnownUsd(usage.estimatedCostUsd)) {
-            accounting.estimatedUsd = sumKnown(accounting.estimatedUsd, usage.estimatedCostUsd);
-        }
-        if (!isKnownUsd(usage.estimatedCostUsd) || !usage.usageComplete)
+        const estimatedUsd = runEstimateUsd({ estimatedCostUsd: usage.estimatedCostUsd });
+        accounting.estimatedUsd = sumEstimatedUsd(accounting.estimatedUsd, estimatedUsd);
+        if (estimatedUsd === null || !usage.usageComplete)
             accounting.unpriced += 1;
     }
     // A skipped or queued automatic job says nothing about earlier manual requests. Only final

package/dist/run/detail.d.ts

@@ -11,7 +11,7 @@ interface RunThought {
 export interface RunParticipant {
     /** Stream id: stable within a run, and what distinguishes participants of one study. */
     id: string;
-    /** What to call them on screen: the participant's own label, else the persona id. */
+    /** What to call them on screen: the caption the Observer shows, else the persona id. */
     label: string;
     /** The persona id, when the trace recorded one. */
     personaId?: string;

package/dist/run/detail.js

@@ -12,6 +12,8 @@ import path from "node:path";
 import { estimateActorCostForExecution } from "./pricing.js";
 import { resolveRunPath } from "./locate.js";
 import { RUN_BUNDLE_FILE } from "./bundle.js";
+import { savedCaption } from "./participant-caption.js";
+import { recordedPersonaId, streamParticipantIdOf } from "./participant-records.js";
 import { readContainedRegularFile } from "./contained-output.js";
 import { isPathInside, resolvePhysicalCwd } from "./paths.js";
 const RUN_DETAIL_SCHEMA = "humanish.run-detail.v1";
@@ -41,19 +43,26 @@ function latestThought(trace) {
     }
     return undefined;
 }
-function participantFrom(stream, index) {
+function participantFrom(stream, index, savedPersonaId) {
     // A live run's flush wins over the finished trace: while both exist, the live one is the newer
     // account of what is happening.
     const trace = stream.liveActor ?? stream.actor ?? {};
     const id = stream.id ?? `stream-${index + 1}`;
-    const personaId = trace.persona?.id;
+    const personaId = trace.persona?.id ?? savedPersonaId;
+    const participantId = streamParticipantIdOf(stream);
     // Computed once: calling it twice to test-then-use reads as though the two could differ.
     const thought = latestThought(trace);
     const status = trace.status ?? stream.status;
     const thoughts = (trace.items ?? []).filter((item) => item?.kind === "reasoning").length;
     return {
         id,
-        label: stream.label ?? personaId ?? id,
+        label: stream.label === undefined
+            ? (personaId ?? id)
+            : savedCaption({
+                label: stream.label,
+                ...(participantId === undefined ? {} : { participantId }),
+                ...(personaId === undefined ? {} : { personaId }),
+            }),
         ...(personaId === undefined ? {} : { personaId }),
         traits: Array.isArray(trace.persona?.traitsApplied) ? trace.persona.traitsApplied : [],
         ...(status === undefined ? {} : { status }),
@@ -131,7 +140,7 @@ export async function readRunDetail(cwdInput, runId) {
         ...(automaticAnalysis === undefined ? {} : { automaticAnalysis }),
         schema: RUN_DETAIL_SCHEMA,
         runId: bundle.runId ?? runId,
-        participants: streams.map(participantFrom),
+        participants: streams.map((stream, index) => participantFrom(stream, index, recordedPersonaId(bundle, stream))),
         ...(isPathInside(cwd, observerAbsolute)
             ? { observerPath: path.relative(cwd, observerAbsolute) }
             : { observerPath: observerAbsolute }),

package/dist/run/display.d.ts

@@ -49,14 +49,14 @@ export interface DisplayedBundle {
  * The facts for a run from its bundle. run.json's `outcome` decides when it has one. A bundle
  * without one is in progress, or was recorded before the field existed: its status record, when
  * given and naming the run, then says whether the run is alive and, for the older run, holds its ok.
- * With no record, a bundle whose simulations are still running is live.
+ * With no record, a bundle whose simulations are still running is interrupted.
  */
 export declare function bundleDisplayFacts(bundle: DisplayedBundle, status?: unknown, nowMs?: number): RunDisplayFacts;
 /**
  * How review.md says the run ended: the display of the bundle it is rendered from, so a run whose
  * execution failed never reads as a pass beside its participants' verdict.
  */
-export declare function reviewOutcome(bundle: DisplayedBundle): string;
+export declare function reviewOutcome(bundle: DisplayedBundle, status?: unknown): string;
 /**
  * The summary and gaps a review shows beside its run's display. A run stopped while a participant
  * was still running keeps the review its last live flush wrote, which describes that session as