humanish 0.111.4 → 0.112.0

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 { 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";
@@ -47,13 +49,20 @@ function participantFrom(stream, index) {
     const trace = stream.liveActor ?? stream.actor ?? {};
     const id = stream.id ?? `stream-${index + 1}`;
     const personaId = trace.persona?.id;
+    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 }),

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

package/dist/run/display.js

@@ -2,7 +2,8 @@
 // library, `humanish runs`, `humanish stats` and review.md. Each of them calls runDisplay with the
 // same facts, so a run whose own ok is false shows as a pass on none of them, and two surfaces
 // cannot disagree about one run.
-import { classifyRunStatus, isRunStatusRecord } from "./status.js";
+import {} from "./status.js";
+import { runLiveness } from "./liveness.js";
 import { plural } from "./text.js";
 const LABELS = {
     running: "running",
@@ -72,38 +73,34 @@ function runDisplayLine(display) {
  * 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 function bundleDisplayFacts(bundle, status, nowMs = Date.now()) {
-    const base = { mode: bundle.mode, verdict: bundle.review?.verdict };
+    const { liveness, record } = runLiveness(bundle.runId, status, bundle, nowMs);
+    const base = { liveness, mode: bundle.mode, verdict: bundle.review?.verdict };
     const outcome = bundle.outcome;
     if (outcome?.state === "interrupted")
-        return { ...base, liveness: "interrupted" };
+        return base;
     if (outcome?.state === "finished")
         return {
             ...base,
-            liveness: "finished",
             ok: outcome.ok,
             failure: outcome.execution.failures[0],
         };
-    if (isRunStatusRecord(status) && status.runId === bundle.runId)
-        return {
-            ...base,
-            liveness: classifyRunStatus(status, nowMs),
-            ...(typeof status.outcome?.ok === "boolean" ? { ok: status.outcome.ok } : {}),
-            ...(status.outcome?.execution?.failures[0] === undefined
-                ? {}
-                : { failure: status.outcome.execution.failures[0] }),
-        };
-    const inProgress = (bundle.simulations ?? []).some((simulation) => simulation?.status === "running");
-    return { ...base, liveness: inProgress ? "running" : "finished" };
+    return {
+        ...base,
+        ...(typeof record?.outcome?.ok === "boolean" ? { ok: record.outcome.ok } : {}),
+        ...(record?.outcome?.execution?.failures[0] === undefined
+            ? {}
+            : { failure: record.outcome.execution.failures[0] }),
+    };
 }
 /**
  * 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 function reviewOutcome(bundle) {
-    return runDisplayLine(runDisplay(bundleDisplayFacts(bundle)));
+export function reviewOutcome(bundle, status) {
+    return runDisplayLine(runDisplay(bundleDisplayFacts(bundle, status)));
 }
 /**
  * The summary and gaps a review shows beside its run's display. A run stopped while a participant

package/dist/run/dry-run.js

@@ -9,8 +9,8 @@ import {} from "./streams.js";
 import { participantEvent, participantIdsOf, participantRecord, participantStream, } from "./participant-records.js";
 import { implicitProjectDirectoryExists, readPackageName, validateCwd } from "./project.js";
 import { loadDryRunInputs } from "./dry-run-inputs.js";
-import { judgeExecution, judgePreview, OUTCOME_POLICIES, resultOk, verdictText, } from "./judge.js";
-import { reviewOutcome } from "./display.js";
+import { judgeExecution, judgePreview, OUTCOME_POLICIES, resultOk } from "./judge.js";
+import { renderReviewMarkdown } from "./review-markdown.js";
 import { cli } from "../cli/invocation.js";
 /**
  * The preview route's run. The run scope closes the run it started on every exit, including
@@ -68,7 +68,7 @@ async function runDryRunInScope(options, scope) {
         mode: options.dryRun ? "dry-run" : "live",
         study: options.study,
         warnings: options.warnings,
-        renderReview: renderReviewMarkdown,
+        renderReview: renderPreviewReview,
         // The run starts at the time its id and source were stamped with.
         now: () => Date.parse(createdAt),
         ...(options.observer === undefined ? {} : { observer: { open: options.observer.open } }),
@@ -170,28 +170,13 @@ function createReviewSummary(verdict) {
     };
 }
 /** The preview's review.md. */
-function renderReviewMarkdown(bundle) {
-    return `# humanish Run Review
-
-Run: ${bundle.runId}
-
-Mode: ${bundle.mode}
-
-Verdict: ${verdictText(bundle.review.verdict, bundle.mode)}
-
-Outcome: ${reviewOutcome(bundle)}
-
-${bundle.review.summary}
-
-## Public-Safety
-
-- Redaction: ${bundle.redaction.status}
-- Notes: ${bundle.redaction.notes}
-
-## Gaps
-
-${bundle.review.gaps.map((gap) => `- ${gap}`).join("\n")}
-`;
+function renderPreviewReview(bundle, status) {
+    return renderReviewMarkdown(bundle, [
+        "## Public-Safety",
+        "",
+        `- Redaction: ${bundle.redaction.status}`,
+        `- Notes: ${bundle.redaction.notes}`,
+    ], { style: "preview", status });
 }
 /**
  * Render through the finished run, so a directory swapped in under the same id is never rendered.

package/dist/run/judge.d.ts

@@ -41,6 +41,30 @@ export interface ParticipantFacts {
     /** selfReportedBlocker held for its session. */
     selfReportedBlocker: boolean;
 }
+/** The participant facts its bundle and result can name. */
+export interface ParticipantRecordFacts extends ParticipantFacts {
+    id?: string;
+    reason?: string;
+    skippedReason?: string;
+    reportedFriction?: boolean;
+    inProgress?: boolean;
+}
+/** Judge participant evidence for the bundle and the result in the same order. */
+export declare function judgeParticipantRecords(participants: readonly ParticipantRecordFacts[], wording?: {
+    sessionLabel?: string;
+    missingSessionMessage?: string;
+    runningReason?: string;
+    contractReason?: string;
+}): {
+    participants: {
+        status: "abandoned" | "blocked" | "contract_proof_only" | "failed" | "incomplete" | "passed" | "running" | "timed_out";
+        judgedStatus: "abandoned" | "blocked" | "failed" | "incomplete" | "passed" | "timed_out" | undefined;
+        reason: string;
+        notPassedMessage: string;
+        gapLine: string | undefined;
+    }[];
+    tally: import("./bundle.js").ParticipantOutcomes;
+};
 /**
  * The status a participant is judged under. A harness failure is failed, and a skipped participant
  * is blocked, as the fan-out bundle and the result write it. Otherwise it is the tallied

package/dist/run/judge.js

@@ -12,6 +12,7 @@
 //   4. foldScorerFailures, which every route with a scorer applies before the run finishes;
 //   5. the outcome: judgeExecution applies the route's policy to its execution failures, and
 //      resultOk gives the result's ok.
+import { tallyParticipantOutcomes } from "./outcomes.js";
 import { cli } from "../cli/invocation.js";
 /**
  * The participant said it reached the goal having taken no action and said nothing, and no stop
@@ -35,6 +36,59 @@ export function selfReportedBlocker(ending) {
         ending.closingReportReadsBlocked &&
         !ending.stopConditionMatched);
 }
+/** Judge participant evidence for the bundle and the result in the same order. */
+export function judgeParticipantRecords(participants, wording = {}) {
+    const records = participants.map((participant) => {
+        const status = participant.inProgress
+            ? "running"
+            : participant.skipped
+                ? "blocked"
+                : (participant.status ??
+                    (participant.sessionError === undefined ? "contract_proof_only" : "failed"));
+        const judged = participant.inProgress ? undefined : judgedStatus(participant);
+        return {
+            status,
+            judgedStatus: judged,
+            reason: participant.inProgress
+                ? (wording.runningReason ??
+                    "Live computer-use session is running; stream auth URL is available only through the attached Observer server.")
+                : (participant.skippedReason ??
+                    participant.reason ??
+                    participant.sessionError ??
+                    wording.contractReason ??
+                    "Dry run: the evidence shape was written without launching a desktop or spending provider tokens."),
+            notPassedMessage: participantNotPassedMessage(participant, wording),
+            gapLine: participant.inProgress || judged === "passed"
+                ? undefined
+                : `${participant.id ?? "Participant"}: ${participant.skippedReason ?? participant.sessionError ?? participant.reason ?? "did not pass"}`,
+        };
+    });
+    const terminal = records.filter((_, index) => participants[index].status !== undefined && !participants[index].inProgress);
+    return {
+        participants: records,
+        tally: tallyParticipantOutcomes(terminal.map((participant) => participant.judgedStatus), participants
+            .filter((participant) => participant.status !== undefined && !participant.inProgress)
+            .map((participant) => participant.reportedFriction === true)),
+    };
+}
+function participantNotPassedMessage(participant, wording) {
+    const label = wording.sessionLabel ?? "Computer-use session";
+    if (participant.sessionError !== undefined)
+        return participant.sessionError;
+    if (participant.skippedReason !== undefined)
+        return participant.skippedReason;
+    if (participant.noEngagement)
+        return "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied.";
+    if (participant.selfReportedBlocker)
+        return "Actor reported goal_satisfied while its final message described a blocker or asked for missing instructions; not a credible pass.";
+    if (participant.completionReason === "harness_error")
+        return `${label} ended with a harness error: ${participant.reason}`;
+    if (participant.status === undefined && wording.missingSessionMessage !== undefined)
+        return wording.missingSessionMessage;
+    if (participant.status !== "passed")
+        return `${label} ended with ${participant.status ?? "unknown"}: ${participant.reason ?? "no terminal reason"}`;
+    return (wording.missingSessionMessage ?? "The computer-use run did not produce a terminal session.");
+}
 /**
  * The status a participant is judged under. A harness failure is failed, and a skipped participant
  * is blocked, as the fan-out bundle and the result write it. Otherwise it is the tallied

package/dist/run/liveness.d.ts

@@ -0,0 +1,18 @@
+import type { RunOutcome } from "./bundle.js";
+import { type RunLiveness, type RunStatusRecord } from "./status.js";
+interface LivenessBundle {
+    simulations?: ReadonlyArray<{
+        status?: string | undefined;
+    } | undefined> | undefined;
+    outcome?: RunOutcome | undefined;
+}
+/**
+ * One run's liveness: the bundle outcome, then usable status, then bundle-only evidence.
+ * `readRunIndex` reads in the same order; `humanish verify` calls this with both in hand. `record`
+ * is the status record the liveness came from, when there was one.
+ */
+export declare function runLiveness(runId: string, status: unknown, bundle: LivenessBundle, nowMs: number): {
+    liveness: RunLiveness;
+    record?: RunStatusRecord;
+};
+export {};

package/dist/run/liveness.js

@@ -0,0 +1,24 @@
+import { classifyRunStatus, isRunStatusRecord, } from "./status.js";
+/**
+ * The bundle-only reading, for a run with no usable status record. A bundle on disk usually means
+ * the run reached its final write. But a live run now flushes an in-progress bundle as it goes (so
+ * anything asking what a participant is doing has something to read), and that bundle marks its
+ * simulations `running`. With no status record there is no freshness to judge, and the
+ * reading of "it started, and nothing here says it finished" is interrupted, not finished.
+ */
+function bundleLiveness(bundle) {
+    const inProgress = (bundle.simulations ?? []).some((simulation) => simulation?.status === "running");
+    return inProgress ? "interrupted" : "finished";
+}
+/**
+ * One run's liveness: the bundle outcome, then usable status, then bundle-only evidence.
+ * `readRunIndex` reads in the same order; `humanish verify` calls this with both in hand. `record`
+ * is the status record the liveness came from, when there was one.
+ */
+export function runLiveness(runId, status, bundle, nowMs) {
+    if (bundle.outcome !== undefined)
+        return { liveness: bundle.outcome.state };
+    return isRunStatusRecord(status) && status.runId === runId
+        ? { liveness: classifyRunStatus(status, nowMs), record: status }
+        : { liveness: bundleLiveness(bundle) };
+}

package/dist/run/outcomes.d.ts

@@ -1,4 +1,4 @@
-import { type ActorStatus } from "../actors/contract.js";
+import { type ActorStatus, type ActorTrace } from "../actors/contract.js";
 import { type CuaGoalSource } from "../actors/goal-source.js";
 import type { TaskFunnel } from "../study/tasks.js";
 import type { ParticipantOutcomes, ReviewSummary, RunTaskFunnel } from "./bundle.js";
@@ -16,6 +16,13 @@ type ParticipantOutcomeDetail = {
     label?: string;
     goalSource?: CuaGoalSource;
 };
+/**
+ * How one participant's session ended, in words a participant summary can end on. A computer-use
+ * goal says where the claim came from, as the run's participant line does.
+ */
+export declare function sessionEndingInWords(trace: ActorTrace): string;
+/** "; the gaps list the other 2", or "all 3" when nobody passed. Empty when the gaps list nobody. */
+export declare function gapsListClause(listed: number, total: number): string;
 /** One line a stakeholder can read, with the denominator attached to every number. */
 export declare function formatParticipantOutcomes(outcomes: ParticipantOutcomes, terminalCauses?: readonly ParticipantOutcomeDetail[]): string;
 /** Presentation details tolerate optional legacy actor payloads without changing their tallies. */