humanish 0.126.0 → 0.127.1

package/CHANGELOG.md

@@ -8,6 +8,30 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.127.1: Clock-end closing reports declare their outcome; skipped participants named as skipped (2026-10-13)
+
+humanish 0.127.1 fixes two things the 0.127.0 release smoke found in scheduled studies. An OpenAI
+participant asked for its closing report at a scheduled end or session cap now says how the task
+went in a structured `outcome` field, so one that reached its goal counts in `reachedGoal` where
+0.127.0 counted it in `ranUntilEnd`. A participant the run skips before its session starts now
+shows its skip reason on its run line, and the summary counts it apart from those that took
+part.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.127.1)
+
+## 0.127.0: Clock-end passes counted by what participants declared, a scaled wind-down, the concurrency cap in the plan (2026-10-13)
+
+humanish 0.127.0 makes long scheduled studies report what happened. A participant that passes at
+its scheduled end or session cap without declaring `REACHED THE GOAL.` is now counted as running
+until that end (`participants.ranUntilEnd`), where 0.126.0 counted it as reaching the goal. The
+default wind-down is a quarter of the window, at most 10 minutes, so a short window is no longer
+told its end from its first turn. `HUMANISH_CUA_MAX_CONCURRENCY` now lowers the plan itself, on
+shared-world studies too, and a participant whose scheduled end passes while it waits for a slot
+is skipped before its desktop is created. The Observer keeps updating past 100,000 items for a
+participant, and the bundle estimate is re-derived for run bundle v3.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.127.0)
+
 ## 0.126.0: Per-participant time zones, session caps and desktop files, page paths, a lighter live Observer (2026-10-13)
 
 humanish 0.126.0 adds per-participant settings for long, mixed studies and a lighter live Observer.

package/dist/actors/closing-report.d.ts

@@ -23,10 +23,17 @@ export declare const participantImpressionsSchema: z.ZodArray<z.ZodObject<{
     text: z.ZodString;
 }, z.core.$strict>>;
 /**
- * A closing report. A report without impressions is still valid: third-party provider ports and
+ * A closing report. `outcome` is how the participant says the task went: `reached` when it is
+ * finished, `blocked` when something in the app stopped it, `not_reached` for any other reason.
+ * A report without an outcome or impressions is still valid: third-party provider ports and
  * stored traces do not have them.
  */
 export declare const closingReportSchema: z.ZodObject<{
+    outcome: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        not_reached: "not_reached";
+        reached: "reached";
+    }>>;
     summary: z.ZodString;
     frictionReports: z.ZodArray<z.ZodString>;
     impressions: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/dist/actors/closing-report.js

@@ -32,10 +32,13 @@ const impressionSchema = z.strictObject({
 /** The impressions a participant gave; an empty list means it had none. */
 export const participantImpressionsSchema = z.array(impressionSchema).max(LIMITS.impressions);
 /**
- * A closing report. A report without impressions is still valid: third-party provider ports and
+ * A closing report. `outcome` is how the participant says the task went: `reached` when it is
+ * finished, `blocked` when something in the app stopped it, `not_reached` for any other reason.
+ * A report without an outcome or impressions is still valid: third-party provider ports and
  * stored traces do not have them.
  */
 export const closingReportSchema = z.strictObject({
+    outcome: z.enum(["reached", "not_reached", "blocked"]).optional(),
     summary: said(LIMITS.summaryChars),
     frictionReports: z.array(said(LIMITS.frictionReportChars)).max(LIMITS.frictionReports),
     impressions: participantImpressionsSchema.optional(),

package/dist/actors/codex/restricted-participant-policy.js

@@ -35,11 +35,8 @@ export function participantToolSchema(speechEnabled = false) {
     return z.toJSONSchema(toolInput(speechEnabled), { io: "input" });
 }
 export const PARTICIPANT_TOOL_SCHEMA = participantToolSchema();
-/** The participant's final account: how the task went, then its closing report. */
-const participantFinal = z.strictObject({
-    outcome: z.enum(["reached", "not_reached", "blocked"]),
-    ...closingReportSchema.shape,
-});
+/** The participant's final account: its closing report, with how the task went required. */
+const participantFinal = closingReportSchema.required({ outcome: true });
 export const PARTICIPANT_FINAL_SCHEMA = strictOutputSchema(participantFinal);
 /** humanish tool arguments, validated before the shared executor sees a batch. */
 export function parseParticipantTool(value, speechEnabled = false) {

package/dist/actors/computer-use/loop/debrief.js

@@ -7,7 +7,7 @@ import { CuaDeadlineError, raceSessionDeadline, requestScope } from "./race.js";
 import { notice } from "./trace.js";
 import { isCompleteTurnUsage } from "./usage.js";
 const DEBRIEF_REQUEST_CAP_MS = 30_000;
-const DEBRIEF_HINT = `The interactive session has ended. Return a closing account with summary, frictionReports and impressions. In summary, briefly describe only what you actually did and observed. In frictionReports, list only specific unexpected behavior, confusion, or recovery you personally encountered during this session. Preserve uncertainty. Use an empty list if you encountered none. ${IMPRESSIONS_ASK} Do not speculate, invent problems, quote instructions as observations, or describe planned actions. Do not request or take further actions. This is a closing account, not another attempt at the task.`;
+const DEBRIEF_HINT = `The interactive session has ended. Return a closing account with outcome, summary, frictionReports and impressions. In outcome, say how the task went: reached if you finished it, blocked if something in the app stopped you, not_reached if you did not finish it for any other reason, such as running out of time. In summary, briefly describe only what you actually did and observed. In frictionReports, list only specific unexpected behavior, confusion, or recovery you personally encountered during this session. Preserve uncertainty. Use an empty list if you encountered none. ${IMPRESSIONS_ASK} Do not speculate, invent problems, quote instructions as observations, or describe planned actions. Do not request or take further actions. This is a closing account, not another attempt at the task.`;
 const CLOSING_REPORT = {
     call: (provider) => provider.debrief,
     contextHint: DEBRIEF_HINT,
@@ -156,9 +156,10 @@ function acceptDebriefTurn(session, turn, trigger, ask, record) {
  * A closing report: its summary and friction as one participant message, then its impressions.
  * At a scheduled end or a session cap an accepted report is the participant's account of the
  * session: its summary becomes the session's reason (loopResult), so the outcome it declares
- * becomes the session's declared outcome. The blocker rule reads a declared `reached` or
- * `blocked` before the summary's wording. After a matched stop condition or dwell window, the
- * condition stays the completion evidence.
+ * becomes the session's declared outcome. That is its `outcome` field, then the turn's (a
+ * provider port that sets it there), then the first line of its summary. The blocker rule reads a
+ * declared `reached` or `blocked` before the summary's wording. After a matched stop condition or
+ * dwell window, the condition stays the completion evidence.
  */
 function readClosingReport(session, turn, trigger) {
     const closing = closingReportSchema.safeParse(turn.closingReport);
@@ -182,7 +183,7 @@ function readClosingReport(session, turn, trigger) {
     session.trace.bump("messages");
     session.impressions = recordImpressions(session, closing.data.impressions);
     if (trigger.kind === "scheduled_end" || trigger.kind === "session_cap")
-        session.declaredOutcome = declaredOutcomeOf(turn, closing.data.summary);
+        session.declaredOutcome = declaredOutcomeOf(turn, closing.data, closing.data.summary);
     return {
         status: "completed",
         detail: "one read-only report; no additional desktop actions; original stop and task outcomes preserved",

package/dist/actors/computer-use/loop/ending.d.ts

@@ -1,4 +1,4 @@
-import type { ActorCompletionReason, ActorStopCause, ParticipantDeclaredOutcome } from "../../contract.js";
+import type { ActorCompletionReason, ActorStopCause, ParticipantClosingReport, ParticipantDeclaredOutcome } from "../../contract.js";
 import type { StopConditionMatch } from "../../stop-conditions.js";
 import type { LoopSession } from "./session.js";
 import { type Evidence } from "./trace.js";
@@ -23,14 +23,17 @@ export interface Stop {
 /**
  * Read the fixed closing line the prompt asks for: the first non-empty line of the
  * participant's last message or closing report summary, exactly one of three phrases,
- * punctuation and case forgiven. Anything else is absence, never a guess. Exported for tests.
+ * punctuation and case forgiven. Anything else is absence, never a guess. A `>` blockquote line
+ * is skipped: it quotes something else, such as the page, and the blocker scan
+ * (routes/computer-use/self-report.ts) drops it too. Exported for tests.
  */
 export declare function declaredOutcomeFromClosingLine(message: string | undefined): ParticipantDeclaredOutcome | undefined;
 /**
- * The participant's own word for how it ended: the turn's schema field first, then the closing
- * line of `text`, its last message or its closing report's summary.
+ * The participant's own word for how it ended: its closing report's `outcome`, then the turn's
+ * (Codex and provider ports that set it there), then the closing line of `text`, its last message
+ * or its closing report's summary. A self-ending turn and a closing request read it in this order.
  */
-export declare function declaredOutcomeOf(turn: CuaTurn, text: string | undefined): ParticipantDeclaredOutcome | undefined;
+export declare function declaredOutcomeOf(turn: CuaTurn, report: ParticipantClosingReport | undefined, text: string | undefined): ParticipantDeclaredOutcome | undefined;
 /**
  * The participant reported a natural endpoint. "not_reached" is a participant who stopped without
  * finishing: gave_up, which tallies as abandoned. "blocked" keeps goal_satisfied here (the actor

package/dist/actors/computer-use/loop/ending.js

@@ -7,7 +7,9 @@ import { plural } from "../../../run/text.js";
 /**
  * Read the fixed closing line the prompt asks for: the first non-empty line of the
  * participant's last message or closing report summary, exactly one of three phrases,
- * punctuation and case forgiven. Anything else is absence, never a guess. Exported for tests.
+ * punctuation and case forgiven. Anything else is absence, never a guess. A `>` blockquote line
+ * is skipped: it quotes something else, such as the page, and the blocker scan
+ * (routes/computer-use/self-report.ts) drops it too. Exported for tests.
  */
 export function declaredOutcomeFromClosingLine(message) {
     if (message === undefined)
@@ -15,10 +17,10 @@ export function declaredOutcomeFromClosingLine(message) {
     const first = message
         .split(/\r?\n/)
         .map((line) => line.trim())
-        .find((line) => line.length > 0);
+        .find((line) => line.length > 0 && !line.startsWith(">"));
     if (first === undefined)
         return undefined;
-    const normalized = first.replace(/^[*_#>\s-]+|[*_.!\s]+$/g, "").toLowerCase();
+    const normalized = first.replace(/^[*_#\s-]+|[*_.!\s]+$/g, "").toLowerCase();
     if (normalized === "reached the goal")
         return "reached";
     if (normalized === "did not reach the goal")
@@ -28,11 +30,12 @@ export function declaredOutcomeFromClosingLine(message) {
     return undefined;
 }
 /**
- * The participant's own word for how it ended: the turn's schema field first, then the closing
- * line of `text`, its last message or its closing report's summary.
+ * The participant's own word for how it ended: its closing report's `outcome`, then the turn's
+ * (Codex and provider ports that set it there), then the closing line of `text`, its last message
+ * or its closing report's summary. A self-ending turn and a closing request read it in this order.
  */
-export function declaredOutcomeOf(turn, text) {
-    return turn.outcome ?? declaredOutcomeFromClosingLine(text);
+export function declaredOutcomeOf(turn, report, text) {
+    return report?.outcome ?? turn.outcome ?? declaredOutcomeFromClosingLine(text);
 }
 /**
  * The participant reported a natural endpoint. "not_reached" is a participant who stopped without

package/dist/actors/computer-use/loop.js

@@ -126,10 +126,10 @@ async function runTurns(session, conversation) {
             continue;
         }
         if (turn.done || turn.actions.length === 0) {
+            const report = closingReportSchema.safeParse(turn.closingReport).data;
             // The declared outcome is kept even if redacting the participant's summary fails.
-            session.declaredOutcome = declaredOutcomeOf(turn, turn.message);
+            session.declaredOutcome = declaredOutcomeOf(turn, report, turn.message);
             const ended = stops.participantEnded(turn, session.declaredOutcome, (text) => session.redactNarration(text));
-            const report = closingReportSchema.safeParse(turn.closingReport).data;
             // A provider that can ask for impressions alone does so after the session, like a debrief.
             if (report?.impressions !== undefined || session.provider.requestImpressions === undefined) {
                 session.impressions =

package/dist/actors/computer-use/openai-provider.js

@@ -512,7 +512,7 @@ export function createOpenAiResponsesProvider(options) {
         // Both are offered in both modes. A threaded request reads the session the server holds; an
         // explicit_context one carries its newest screens whole and its oldest turns summarized past
         // the budget, which the trace's conversation record counts. A participant that worked a long
-        // shift writes its closing account from what it carries, as a person writes one from memory.
+        // session writes its closing account from what it carries, as a person writes one from memory.
         debrief: (req, signal) => requestTurn(req, signal, "report"),
         requestImpressions: (req, signal) => requestTurn(req, signal, "impressions"),
     };

package/dist/actors/contract.d.ts

@@ -25,10 +25,11 @@ export declare const ACTOR_STATUSES: readonly ["passed", "abandoned", "incomplet
 export type ActorStatus = (typeof ACTOR_STATUSES)[number];
 /**
  * What the participant said happened, in a field rather than a paragraph. Providers whose
- * reply is schema-constrained (the local-agent routes) fill it on their final turn; a free-text
- * provider leaves it absent and the route falls back to reading the closing message. `reached`:
- * the task is finished. `blocked`: something in the app stopped the participant. `not_reached`:
- * the participant stopped for another reason (gave up, ran out of ideas).
+ * reply is schema-constrained (the local-agent routes) fill it on their final turn, and a closing
+ * report carries it as `outcome`; a free-text turn leaves it absent and the route falls back to
+ * reading the closing message. `reached`: the task is finished. `blocked`: something in the app
+ * stopped the participant. `not_reached`: the participant stopped for another reason (gave up,
+ * ran out of ideas).
  */
 export type ParticipantDeclaredOutcome = "reached" | "not_reached" | "blocked";
 /** Statuses that describe what happened to a participant rather than a harness malfunction. Verify
@@ -372,8 +373,11 @@ export interface ActorTrace {
         reason: string;
         /** Absent if no request was made; false means token accounting is incomplete. */
         usageReported?: boolean;
-        /** The report's impressions are kept in `impressions`, with the messages that quote them. */
-        report?: Omit<ParticipantClosingReport, "impressions">;
+        /**
+         * The report's impressions are kept in `impressions`, with the messages that quote them, and
+         * the outcome it declared at a clock end in `declaredOutcome`.
+         */
+        report?: Omit<ParticipantClosingReport, "impressions" | "outcome">;
         /** Links the readable projection so it is not heuristically classified a second time. */
         messageId?: string;
     };

package/dist/actors/goal-source.d.ts

@@ -1,5 +1,35 @@
-/** Presentation provenance for computer-use completion; never reclassifies the stored outcome. */
-export type CuaGoalSource = "participant_report" | "condition_matched" | "unavailable";
+/**
+ * The endpoint a computer-use completion came from, as analysis provenance records it
+ * (cuaEndpointSource). Saved analyses hash it, so a new value would make them invalid on read.
+ */
+export declare const CUA_ENDPOINT_SOURCES: readonly ["participant_report", "condition_matched", "unavailable"];
+export type CuaEndpointSource = (typeof CUA_ENDPOINT_SOURCES)[number];
+/**
+ * Presentation provenance for computer-use completion; never reclassifies the stored outcome.
+ * `scheduled_end` and `session_cap` name a session that passed at that clock end without the
+ * participant declaring it reached the goal (ranUntilClockEnd).
+ */
+export type CuaGoalSource = CuaEndpointSource | ClockEnd;
+/** The two clock ends a computer-use session passes at: the stop causes of the same names. */
+export type ClockEnd = "scheduled_end" | "session_cap";
+export declare function isClockEnd(source: CuaGoalSource | undefined): source is ClockEnd;
+/**
+ * The clock end a session ran until, when the participant did not declare that it reached the
+ * goal: its scheduled end or its session cap. Such a session ends as passed, because ending at
+ * the clock is the plan, and its closing report says `DID NOT REACH THE GOAL.` or declares
+ * nothing. The tally and every completion label read this, so none counts it as reaching the
+ * goal. Undefined for every other ending, including a declared `reached` at a clock end.
+ */
+export declare function ranUntilClockEnd(trace: {
+    readonly stopCause?: unknown;
+    readonly declaredOutcome?: unknown;
+}): ClockEnd | undefined;
 export declare function isCuaTrace(value: unknown): boolean;
 export declare function cuaGoalSource(value: unknown, recordedStatus?: unknown): CuaGoalSource | undefined;
+/**
+ * cuaGoalSource for analysis provenance. A clock end reads as it did before it had a source of
+ * its own, so an analysis saved then still matches its run when re-read. The provenance's
+ * `stopCause` and `declaredOutcome` name the clock end.
+ */
+export declare function cuaEndpointSource(value: unknown, recordedStatus?: unknown): CuaEndpointSource | undefined;
 export declare const CUA_COMPLETION_NOTE = "Participant reports alone do not establish task success. A matched stop condition establishes only its declared condition. Run gate and share-safety results are separate.";

package/dist/actors/goal-source.js

@@ -1,3 +1,27 @@
+/**
+ * The endpoint a computer-use completion came from, as analysis provenance records it
+ * (cuaEndpointSource). Saved analyses hash it, so a new value would make them invalid on read.
+ */
+export const CUA_ENDPOINT_SOURCES = [
+    "participant_report",
+    "condition_matched",
+    "unavailable",
+];
+export function isClockEnd(source) {
+    return source === "scheduled_end" || source === "session_cap";
+}
+/**
+ * The clock end a session ran until, when the participant did not declare that it reached the
+ * goal: its scheduled end or its session cap. Such a session ends as passed, because ending at
+ * the clock is the plan, and its closing report says `DID NOT REACH THE GOAL.` or declares
+ * nothing. The tally and every completion label read this, so none counts it as reaching the
+ * goal. Undefined for every other ending, including a declared `reached` at a clock end.
+ */
+export function ranUntilClockEnd(trace) {
+    if (trace.stopCause !== "scheduled_end" && trace.stopCause !== "session_cap")
+        return undefined;
+    return trace.declaredOutcome === "reached" ? undefined : trace.stopCause;
+}
 export function isCuaTrace(value) {
     if (typeof value !== "object" || value === null)
         return false;
@@ -32,7 +56,22 @@ export function cuaGoalSource(value, recordedStatus) {
         (item.title.startsWith("stopWhen matched:") || item.title === "dwell window complete"))) {
         return "condition_matched";
     }
-    // A legacy trace without enough detail cannot establish which endpoint ended the loop.
-    return trace.items.length > 0 ? "participant_report" : "unavailable";
+    return ranUntilClockEnd(trace) ?? endpointOfItems(trace.items);
+}
+// A legacy trace without enough detail cannot establish which endpoint ended the loop.
+function endpointOfItems(items) {
+    return items.length > 0 ? "participant_report" : "unavailable";
+}
+/**
+ * cuaGoalSource for analysis provenance. A clock end reads as it did before it had a source of
+ * its own, so an analysis saved then still matches its run when re-read. The provenance's
+ * `stopCause` and `declaredOutcome` name the clock end.
+ */
+export function cuaEndpointSource(value, recordedStatus) {
+    const source = cuaGoalSource(value, recordedStatus);
+    // cuaGoalSource returns a clock end only after it has checked that `items` is an array.
+    return isClockEnd(source)
+        ? endpointOfItems(value.items)
+        : source;
 }
 export const CUA_COMPLETION_NOTE = "Participant reports alone do not establish task success. A matched stop condition establishes only its declared condition. Run gate and share-safety results are separate.";

package/dist/analysis/evidence-sources.js

@@ -1,6 +1,6 @@
 import { receivingAnalysisContext } from "../comms/receiving-evidence.js";
 import { eventRecordIdOf, recordIdOf, streamParticipantIdOf } from "../run/participant-records.js";
-import { cuaGoalSource } from "../actors/goal-source.js";
+import { cuaEndpointSource } from "../actors/goal-source.js";
 import { isRecord } from "../run/type-guards.js";
 import { ACTION_CAPTURE_VERSION, } from "./types.js";
 import { decodesToPlainRelativePath, isEvidencePath } from "../run/evidence-files.js";
@@ -82,7 +82,7 @@ export function participantSource(stream, captureVersion) {
             actorStatus: actor?.status ?? null,
             completionReason: actor?.completionReason ?? null,
             stopCause: actor?.stopCause ?? null,
-            goalSource: cuaGoalSource(actor, stream.status) ?? null,
+            goalSource: cuaEndpointSource(actor, stream.status) ?? null,
             declaredOutcome: actor?.declaredOutcome ?? null,
             taskOutcomes: actor?.taskFunnel === undefined
                 ? null

package/dist/analysis/types.d.ts

@@ -1,5 +1,5 @@
 import type { ActorStatus, ActorCompletionReason, ActorStopCause, ParticipantDeclaredOutcome } from "../actors/contract.js";
-import type { CuaGoalSource } from "../actors/goal-source.js";
+import type { CuaEndpointSource } from "../actors/goal-source.js";
 import type { AutomaticAnalysisView } from "./job.js";
 import type { RunAnalysisCost } from "../run/run-cost.js";
 /** Independent interpretation of retained evidence; never a participant or harness verdict. */
@@ -55,7 +55,7 @@ export interface AnalysisParticipantInput {
         actorStatus: ActorStatus | null;
         completionReason: ActorCompletionReason | null;
         stopCause: ActorStopCause | null;
-        goalSource: CuaGoalSource | null;
+        goalSource: CuaEndpointSource | null;
         declaredOutcome: ParticipantDeclaredOutcome | null;
         taskOutcomes: Array<{
             taskId: string;

package/dist/analysis/validation.js

@@ -2,6 +2,7 @@ import { validStoredCodexAnalysisConfig } from "./codex-config.js";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ACTOR_STATUSES, ACTOR_STOP_CAUSES } from "../actors/contract.js";
+import { CUA_ENDPOINT_SOURCES } from "../actors/goal-source.js";
 import { ANALYSIS_LIMITS, EVIDENCE_LIMITS, MAX_ANALYSIS_COHORTS, hasControlCharacter, hasRevisionFields, } from "./analysis-limits.js";
 import { SHA256_HEX_PATTERN, ACTION_CAPTURE_VERSION, ANALYSIS_SCHEMA, ANALYSIS_CORRECTION_SCHEMA, } from "./types.js";
 const text = (max) => z
@@ -178,7 +179,7 @@ const analysisParticipantProvenanceSchema = z
     ])
         .nullable(),
     stopCause: z.enum(ACTOR_STOP_CAUSES).nullable(),
-    goalSource: z.enum(["participant_report", "condition_matched", "unavailable"]).nullable(),
+    goalSource: z.enum(CUA_ENDPOINT_SOURCES).nullable(),
     declaredOutcome: z.enum(["reached", "not_reached", "blocked"]).nullable(),
     taskOutcomes: z
         .array(z

package/dist/cli/commands/study-format.js

@@ -81,10 +81,21 @@ function oneLine(text) {
     const line = text.replace(/\s+/g, " ").trim();
     return line.length > REASON_CHARS ? `${line.slice(0, REASON_CHARS - 1).trimEnd()}…` : line;
 }
-function participantLine({ id, status, session, diagnostics }) {
+/**
+ * A participant's status, how it ended and its closing message. A participant the run skipped
+ * before its session started has no ending to classify, so its line ends on the reason the run
+ * recorded. That reason is the harness's own sentence, so it prints whole.
+ */
+function participantLine(participant) {
+    const { id, status, session, diagnostics, skippedReason } = participant;
+    const ending = skippedReason !== undefined
+        ? [skippedReason]
+        : diagnostics
+            ? [formatCuaDiagnostics(diagnostics)]
+            : [];
     return [
         `participant ${id}: ${participantStatus(status)}${session ? ` (${session.completionReason})` : ""}`,
-        ...(diagnostics ? [formatCuaDiagnostics(diagnostics)] : []),
+        ...ending,
         ...(session ? [oneLine(session.reason)] : []),
     ].join(" · ");
 }

package/dist/observer/data.js

@@ -156,6 +156,13 @@ export function observerDataFromSaved(value) {
         ? null
         : joinObserverData(saved, null);
 }
+const GOAL_SOURCE_LABELS = {
+    participant_report: "Reported complete",
+    condition_matched: "Condition matched",
+    scheduled_end: "Ran until scheduled end",
+    session_cap: "Ran until session cap",
+    unavailable: "Completion source unavailable",
+};
 /** Refresh presentation from recorded actor evidence, including older exported snapshots. */
 export function withObserverEndings(data) {
     const streams = (data.streams ?? []).map(({ ending: _previousEnding, ...stream }) => {
@@ -166,11 +173,7 @@ export function withObserverEndings(data) {
             ...(ending === undefined ? {} : { ending }),
             ...((stream.status === "passed" || stream.status === "complete") && source !== undefined
                 ? {
-                    statusLabel: source === "participant_report"
-                        ? "Reported complete"
-                        : source === "condition_matched"
-                            ? "Condition matched"
-                            : "Completion source unavailable",
+                    statusLabel: GOAL_SOURCE_LABELS[source],
                 }
                 : {}),
             ...(stream.status === "incomplete" || (ending !== undefined && stream.status === "abandoned")