humanish 0.125.0 → 0.127.0

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

@@ -72,7 +72,7 @@ function sharedWorldSimulation(ctx, spec, index, view) {
         updatedAt: args.run.createdAt,
         ...(args.plan.arrivals.declared
             ? {
-                arrival: arrivalRecord(spec.planned.startAfterMs, actorArrival(args.actorResults[index])),
+                arrival: arrivalRecord(spec.planned.schedule.startAfterMs, actorArrival(args.actorResults[index])),
             }
             : {}),
     });
@@ -122,6 +122,9 @@ function sharedWorldStream(ctx, spec, index, view) {
                 },
             }),
         desktopGeometry,
+        ...(spec.planned.limits.timeZone === undefined
+            ? {}
+            : { timeZone: spec.planned.limits.timeZone }),
         ui: {
             route: view.route,
             intent: `Watch ${name} use the shared app at the same time as the others.`,

package/dist/routes/shared-world/external-public.js

@@ -104,7 +104,7 @@ export async function runExternalPublicPlane(ctx, live, inbox) {
             }))
             : undefined;
         const followerResultsPromise = runOnSchedule(followerEntries, {
-            startAfterMs: ({ spec }) => spec.planned.startAfterMs,
+            startAfterMs: ({ spec }) => spec.planned.schedule.startAfterMs,
             slots: Math.max(1, concurrency - 1),
             now: ctx.now,
         }, async ({ spec, index }, _position, { scheduledAt }) => ({

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

@@ -140,10 +140,11 @@ export function participantRunDeps(ctx, live, scrubKnownValues) {
         studyCwd: ctx.cwd,
         redactScreenshots: ctx.redactScreenshots,
         scrubKnownValues,
-        // A session that throws returns no trace; the run still records that it started.
+        // A session that throws returns no trace; the run still records that it started. Observed
+        // URLs land in a shared-world bundle only as digests, so no session records its pages.
         runSession: (options) => {
             ctx.run.participantStarted();
-            return ctx.runSession(options);
+            return ctx.runSession({ ...options, recordPages: false });
         },
         liveFlush: () => live.flush?.flush,
         onStream: participantStreams(ctx.input.onStream, live),

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

@@ -23,6 +23,8 @@ export declare function planSharedWorldStudy(config: StudyConfig, input: {
     readonly sandboxCeiling: SandboxCeiling;
     /** How many sandboxes the operator's E2B plan runs at once (concurrentSandboxes). */
     readonly concurrentSandboxes: ConcurrentSandboxes;
+    /** HUMANISH_CUA_MAX_CONCURRENCY (concurrencyCap), which may only lower the participants at once. */
+    readonly concurrencyCap?: number | undefined;
 }): SharedWorldPlanResult;
 /**
  * The schedule lines a shared-world run prints before it creates anything, when the study declares

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

@@ -8,6 +8,8 @@ import { actorRegistry, isCuaActorDescriptor, } from "../../actors/registry.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { brainOf, planCaps, desktopRequirements, isNonEmpty, planBase, } from "../../study/plan-base.js";
 import { sharedWorldParticipants } from "../../study/plan-participants.js";
+import { DESKTOP_FILES_ROUTE_REASON } from "../../study/desktop-files.js";
+import { participantList } from "../../study/study-fields.js";
 import { PUBLIC_TARGET_OWNER_PATTERN } from "../../study/parse/subject.js";
 import { REPO_SLUG_PATTERN } from "../../study/parse/values.js";
 import { concurrentSharedWorldValidationReason, desktopMediaValidationReason, externalPublicSharedWorldValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "../../study/validation.js";
@@ -41,6 +43,9 @@ export function planSharedWorldStudy(config, input) {
     const tasksReason = taskProtocolValidationReason(config, false);
     if (tasksReason)
         return refuse("HUMANISH_STUDY_TASKS_UNSUPPORTED", tasksReason);
+    // The parser refuses these; a library caller's config skips it.
+    if (participantList(config)?.some((entry) => entry.files !== undefined))
+        return refuse(invalid, `participants[].files: ${DESKTOP_FILES_ROUTE_REASON}. Remove them.`);
     const actorType = config.actor?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isCuaActorDescriptor(descriptor))
@@ -98,7 +103,7 @@ export function planSharedWorldStudy(config, input) {
     if (plane === undefined)
         throw new Error("shared-world validation admitted a plane it cannot plan");
     const sessionTimeoutMs = config.execution?.timeoutMs ?? defaultSessionTimeoutMs(plane, ceiling.ms);
-    const starts = startsOf(plane, config.execution?.concurrency, input.concurrentSandboxes, sessionTimeoutMs);
+    const starts = startsOf(plane, config.execution?.concurrency, { sandboxes: input.concurrentSandboxes, cap: input.concurrencyCap }, sessionTimeoutMs);
     if (!starts.ok)
         return refuse(invalid, starts.message, actor);
     const { arrivals, warnings } = starts;
@@ -149,7 +154,7 @@ export function planSharedWorldStudy(config, input) {
  * shared world needs two participants live together. On the external-public plane the host runs
  * on a slot of its own and the others queue for the rest (external-public.ts).
  */
-function startsOf(plane, declared, limit, sessionMs) {
+function startsOf(plane, declared, limits, sessionMs) {
     const n = plane.participants.length;
     const atOnce = participantsAtOnce({
         concurrency: boundedConcurrency(declared, n),
@@ -157,7 +162,7 @@ function startsOf(plane, declared, limit, sessionMs) {
         participants: n,
         alongside: plane.kind === "provisioned" ? 1 : 0,
         minimum: 2,
-    }, limit);
+    }, limits);
     if (!atOnce.ok)
         return atOnce;
     const hostIndex = plane.participants.findIndex((participant) => participant.host === true);

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

@@ -391,7 +391,7 @@ function runParticipants(plane, ctx, live, setup) {
     const { commsEmail } = setup;
     const baseActorDeps = participantRunDeps(ctx, live, ctx.scrubKnownValues);
     const schedule = {
-        startAfterMs: (spec) => spec.planned.startAfterMs,
+        startAfterMs: (spec) => spec.planned.schedule.startAfterMs,
         slots: Math.max(1, ctx.concurrency),
         now,
     };

package/dist/run/bundle.d.ts

@@ -511,8 +511,18 @@ export interface RunRerunLineage {
 export interface ParticipantOutcomes {
     /** Participants whose sessions reached a terminal state: the denominator for every count below. */
     total: number;
-    /** Recorded successful sessions; completion provenance depends on the actor and its evidence. */
+    /**
+     * Recorded successful sessions; completion provenance depends on the actor and its evidence. A
+     * computer-use session that passed at its scheduled end or session cap counts here only when
+     * its participant declared that it reached the goal; otherwise it counts in `ranUntilEnd`.
+     */
     reachedGoal: number;
+    /**
+     * Passed at a scheduled end or a session cap without declaring that they reached the goal: the
+     * closing report said `DID NOT REACH THE GOAL.` or declared nothing. Present when above 0.
+     * Bundles written before this count existed tallied them under `reachedGoal`.
+     */
+    ranUntilEnd?: number;
     /** Stopped trying. A finding about the product. */
     abandoned: number;
     /** Interrupted before reaching the goal, including session, spend and provider limits. */

package/dist/run/contained-output.d.ts

@@ -117,10 +117,14 @@ export declare function readOpenedAtMost(handle: FileHandle, maxBytes: number):
 /**
  * The first `length` bytes of one regular file, under the checks readContainedRegularFile makes,
  * or all of a file that holds fewer. Bytes past `length`, such as a later append, are not read.
+ * With `start`, the bytes from `start` to `length`.
  */
-export declare function readContainedPrefix(rootInput: PreparedOutputRoot, relativePath: string, length: number): Promise<ContainedRead>;
-/** The first `length` bytes of an opened file, read by position, or all of a shorter one. */
-export declare function readOpenedPrefix(handle: FileHandle, length: number): Promise<Buffer>;
+export declare function readContainedPrefix(rootInput: PreparedOutputRoot, relativePath: string, length: number, start?: number): Promise<ContainedRead>;
+/**
+ * The first `length` bytes of an opened file, read by position, or all of a shorter one. With
+ * `start`, the bytes from `start` to `length`.
+ */
+export declare function readOpenedPrefix(handle: FileHandle, length: number, start?: number): Promise<Buffer>;
 /** The caller owns this checked descriptor and must close it after reading/streaming. */
 export declare function openContainedRegularFile(rootInput: PreparedOutputRoot, relativePath: string): Promise<FileHandle | null>;
 export declare function assertSafeOutputPathSegment(value: string, label?: string): void;

package/dist/run/contained-output.js

@@ -307,15 +307,16 @@ export async function readOpenedAtMost(handle, maxBytes) {
 /**
  * The first `length` bytes of one regular file, under the checks readContainedRegularFile makes,
  * or all of a file that holds fewer. Bytes past `length`, such as a later append, are not read.
+ * With `start`, the bytes from `start` to `length`.
  */
-export async function readContainedPrefix(rootInput, relativePath, length) {
+export async function readContainedPrefix(rootInput, relativePath, length, start = 0) {
     const opened = await openContained(rootInput, relativePath);
     if (opened.status === "missing")
         return opened;
     if (opened.status === "refused")
         return { status: "refused", reason: opened.reason, limit: length };
     try {
-        return { status: "read", bytes: await readOpenedPrefix(opened.handle, length) };
+        return { status: "read", bytes: await readOpenedPrefix(opened.handle, length, start) };
     }
     catch {
         return { status: "refused", reason: "unreadable", limit: length };
@@ -324,12 +325,15 @@ export async function readContainedPrefix(rootInput, relativePath, length) {
         await opened.handle.close().catch(() => { });
     }
 }
-/** The first `length` bytes of an opened file, read by position, or all of a shorter one. */
-export async function readOpenedPrefix(handle, length) {
-    const bytes = Buffer.allocUnsafe(length);
+/**
+ * The first `length` bytes of an opened file, read by position, or all of a shorter one. With
+ * `start`, the bytes from `start` to `length`.
+ */
+export async function readOpenedPrefix(handle, length, start = 0) {
+    const bytes = Buffer.allocUnsafe(Math.max(0, length - start));
     let total = 0;
-    while (total < length) {
-        const { bytesRead } = await handle.read(bytes, total, length - total, total);
+    while (total < bytes.length) {
+        const { bytesRead } = await handle.read(bytes, total, bytes.length - total, start + total);
         if (bytesRead === 0)
             break;
         total += bytesRead;

package/dist/run/judge.d.ts

@@ -1,4 +1,5 @@
 import type { ActorCompletionReason, ActorStatus, ParticipantDeclaredOutcome } from "../actors/contract.js";
+import type { ClockEnd } from "../actors/goal-source.js";
 import type { ReviewSummary } from "./bundle.js";
 export type Verdict = ReviewSummary["verdict"];
 /** How a finished session ended, as the blocker rule reads it. */
@@ -6,7 +7,7 @@ export interface BlockerFacts {
     completionReason: ActorCompletionReason;
     /** A harness-owned stop condition ended the session: a matched stopWhen or a completed dwell window. */
     stopConditionMatched: boolean;
-    /** What the participant declared in a field, when its provider has one. */
+    /** What the participant declared, when it declared an outcome (ActorTrace.declaredOutcome). */
     declaredOutcome?: ParticipantDeclaredOutcome;
     /** The route's reading of the closing report: it describes a blocker or asks for instructions. */
     closingReportReadsBlocked: boolean;
@@ -22,9 +23,12 @@ export interface SessionEnding extends BlockerFacts {
  */
 export declare function hollowCompletion(ending: SessionEnding): boolean;
 /**
- * The participant said it reached the goal but reported a blocker. A declared outcome is its own
- * word and wins. Without one, the closing report is read, unless a stop condition ended the
- * session: a matched stopWhen is structured completion evidence and overrides the text.
+ * The session ended goal_satisfied but the participant reported a blocker. A declared `reached`
+ * or `blocked` is its own word and wins. Otherwise the closing report is read, unless a stop
+ * condition ended the session: a matched stopWhen is structured completion evidence and overrides
+ * the text. A declared `not_reached` is read the same way: it ends the session as gave_up when
+ * the participant ends it, so here it comes from a closing report at a scheduled end or a session
+ * cap, and it does not say whether something stopped the participant.
  */
 export declare function selfReportedBlocker(ending: BlockerFacts): boolean;
 /** What a participant's pass reads: its session's end, or why it has none, and the two judgments above. */
@@ -40,6 +44,12 @@ export interface ParticipantFacts {
     noEngagement: boolean;
     /** selfReportedBlocker held for its session. */
     selfReportedBlocker: boolean;
+    /**
+     * Its session ran until its scheduled end or session cap without the participant declaring it
+     * reached the goal (ranUntilClockEnd). A pass counts under `ranUntilEnd` in place of
+     * `reachedGoal`.
+     */
+    ranUntil?: ClockEnd;
 }
 /** The participant facts its bundle and result can name. */
 export interface ParticipantRecordFacts extends ParticipantFacts {

package/dist/run/judge.js

@@ -25,16 +25,21 @@ export function hollowCompletion(ending) {
         !ending.stopConditionMatched);
 }
 /**
- * The participant said it reached the goal but reported a blocker. A declared outcome is its own
- * word and wins. Without one, the closing report is read, unless a stop condition ended the
- * session: a matched stopWhen is structured completion evidence and overrides the text.
+ * The session ended goal_satisfied but the participant reported a blocker. A declared `reached`
+ * or `blocked` is its own word and wins. Otherwise the closing report is read, unless a stop
+ * condition ended the session: a matched stopWhen is structured completion evidence and overrides
+ * the text. A declared `not_reached` is read the same way: it ends the session as gave_up when
+ * the participant ends it, so here it comes from a closing report at a scheduled end or a session
+ * cap, and it does not say whether something stopped the participant.
  */
 export function selfReportedBlocker(ending) {
-    if (ending.declaredOutcome !== undefined)
-        return ending.declaredOutcome === "blocked" && ending.completionReason === "goal_satisfied";
-    return (ending.completionReason === "goal_satisfied" &&
-        ending.closingReportReadsBlocked &&
-        !ending.stopConditionMatched);
+    if (ending.completionReason !== "goal_satisfied")
+        return false;
+    if (ending.declaredOutcome === "blocked")
+        return true;
+    if (ending.declaredOutcome === "reached")
+        return false;
+    return ending.closingReportReadsBlocked && !ending.stopConditionMatched;
 }
 /** Judge participant evidence for the bundle and the result in the same order. */
 export function judgeParticipantRecords(participants, wording = {}) {
@@ -63,12 +68,12 @@ export function judgeParticipantRecords(participants, wording = {}) {
                 : `${participant.id ?? "Participant"}: ${participant.skippedReason ?? participant.sessionError ?? participant.reason ?? "did not pass"}`,
         };
     });
-    const terminal = records.filter((_, index) => participants[index].status !== undefined && !participants[index].inProgress);
+    const ended = (participant) => participant.status !== undefined && !participant.inProgress;
+    const terminal = records.filter((_, index) => ended(participants[index]));
+    const terminalFacts = participants.filter(ended);
     return {
         participants: records,
-        tally: tallyParticipantOutcomes(terminal.map((participant) => participant.judgedStatus), participants
-            .filter((participant) => participant.status !== undefined && !participant.inProgress)
-            .map((participant) => participant.reportedFriction === true)),
+        tally: tallyParticipantOutcomes(terminal.map((participant) => participant.judgedStatus), terminalFacts.map((participant) => participant.reportedFriction === true), terminalFacts.map((participant) => participant.ranUntil !== undefined)),
     };
 }
 function participantNotPassedMessage(participant, wording) {

package/dist/run/live-items.d.ts

@@ -8,6 +8,11 @@ export declare const LIVE_ACTOR_SCHEMA = "humanish.live-actor.v2";
 export declare const LIVE_ACTOR_V1_SCHEMA = "humanish.live-actor.v1";
 /** Whether `value` is a live items index naming a live file name and its own generation. */
 export declare function isLiveItemsIndex(value: unknown): value is LiveItemsIndex;
+/** Where a reader's copy of a live file ends: its first `items` lines, `bytes` bytes. */
+export interface LiveItemsCursor {
+    items: number;
+    bytes: number;
+}
 /**
  * The items the indexed prefix of a live file holds, or why the bytes do not match the index:
  * `bytes` must be exactly the indexed byte count, hash to the indexed sha256, and hold the indexed
@@ -18,6 +23,20 @@ export declare function liveItemsFromBytes(bytes: Buffer, index: LiveItemsIndex)
 } | {
     refused: string;
 };
+/**
+ * The items past `after` in the indexed prefix of a live file, from the file's bytes between
+ * `after.bytes - 1` and the indexed end, or why they do not fit: the first byte must end the line
+ * before the cursor, and the rest must hold exactly the lines between the cursor's count and the
+ * indexed count, each a JSON object. A line end at `after.bytes - 1` fixes how many lines precede
+ * it, so a cursor whose `items` is not that count fails on the line count. The sha256 run.json
+ * records covers the whole prefix and is not checked here: what precedes the cursor is the
+ * reader's, and a generation's bytes never change once written.
+ */
+export declare function liveItemsAfter(bytes: Buffer, index: LiveItemsIndex, after: LiveItemsCursor): {
+    items: ActorTraceItem[];
+} | {
+    refused: string;
+};
 /** One run's live files: what each stream position's current generation holds. */
 export interface LiveItemsWriter {
     /**

package/dist/run/live-items.js

@@ -41,20 +41,40 @@ export function liveItemsFromBytes(bytes, index) {
         };
     if (createHash("sha256").update(bytes).digest("hex") !== index.sha256)
         return { refused: `${index.path} does not match the sha256 run.json records for it` };
+    return itemLinesOf(bytes, index.items, index.path);
+}
+/**
+ * The items past `after` in the indexed prefix of a live file, from the file's bytes between
+ * `after.bytes - 1` and the indexed end, or why they do not fit: the first byte must end the line
+ * before the cursor, and the rest must hold exactly the lines between the cursor's count and the
+ * indexed count, each a JSON object. A line end at `after.bytes - 1` fixes how many lines precede
+ * it, so a cursor whose `items` is not that count fails on the line count. The sha256 run.json
+ * records covers the whole prefix and is not checked here: what precedes the cursor is the
+ * reader's, and a generation's bytes never change once written.
+ */
+export function liveItemsAfter(bytes, index, after) {
+    if (bytes.length !== index.bytes - after.bytes + 1)
+        return {
+            refused: `${index.path} holds ${bytes.length - 1} bytes past byte ${after.bytes} and run.json records ${index.bytes - after.bytes}`,
+        };
+    if (bytes[0] !== 0x0a)
+        return { refused: `${index.path} has no line end before byte ${after.bytes}` };
+    return itemLinesOf(bytes.subarray(1), index.items - after.items, index.path);
+}
+/** The JSON object on each of `count` lines in `bytes`, which must be UTF-8 and end a line. */
+function itemLinesOf(bytes, count, file) {
     let text;
     try {
         text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     }
     catch {
-        return { refused: `${index.path} is not UTF-8 text` };
+        return { refused: `${file} is not UTF-8 text` };
     }
     const lines = text === "" ? [] : text.split("\n");
     if (lines.length > 0 && lines.pop() !== "")
-        return { refused: `${index.path} does not end its indexed bytes at a line end` };
-    if (lines.length !== index.items)
-        return {
-            refused: `${index.path} holds ${lines.length} items and run.json records ${index.items}`,
-        };
+        return { refused: `${file} does not end its indexed bytes at a line end` };
+    if (lines.length !== count)
+        return { refused: `${file} holds ${lines.length} items and run.json records ${count}` };
     const items = [];
     for (const line of lines) {
         let item;
@@ -62,10 +82,10 @@ export function liveItemsFromBytes(bytes, index) {
             item = JSON.parse(line);
         }
         catch {
-            return { refused: `${index.path} holds a line that is not JSON` };
+            return { refused: `${file} holds a line that is not JSON` };
         }
         if (!isRecord(item))
-            return { refused: `${index.path} holds a line that is not an item` };
+            return { refused: `${file} holds a line that is not an item` };
         items.push(item);
     }
     return { items };

package/dist/run/notes.js

@@ -21,7 +21,7 @@ const refuse = (code, message) => ({
 });
 /**
  * The stream id a note's participant names: a stream id, or the participant's own id from the study
- * (`charge-nurse`). Both kinds of id are matched, so a name that is one stream's id and another
+ * (`support-lead`). Both kinds of id are matched, so a name that is one stream's id and another
  * stream's study id is refused, naming both, as is a study id that two streams record. Otherwise
  * the refusal names the run's participants by caption, with the id to type for each.
  */

package/dist/run/outcomes.d.ts

@@ -6,7 +6,13 @@ import type { ParticipantOutcomes, ReviewSummary, RunTaskFunnel } from "./bundle
  *  `total` but nowhere else, so the parts can never exceed the whole. */
 export declare function tallyParticipantOutcomes(statuses: readonly ActorStatus[], 
 /** Per-participant: did this one report friction or a defect? Same order as `statuses`. */
-reportedFriction?: readonly boolean[]): ParticipantOutcomes;
+reportedFriction?: readonly boolean[], 
+/**
+ * Per-participant: did its session run until its scheduled end or session cap without it
+ * declaring that it reached the goal (ranUntilClockEnd)? Same order as `statuses`. Such a pass
+ * counts under `ranUntilEnd` in place of `reachedGoal`.
+ */
+ranUntilEnd?: readonly boolean[]): ParticipantOutcomes;
 /** Roll per-participant funnels up into the study funnel. Undefined when nothing measured one. */
 export declare function aggregateTaskFunnels(funnels: readonly TaskFunnel[]): RunTaskFunnel | undefined;
 /** The funnel as one line, denominator on every number: `signup 2/2 · verify-email 1/2`. */
@@ -53,7 +59,7 @@ export declare function formatParticipantOutcomes(outcomes: ParticipantOutcomes,
 export declare function participantOutcomeDetails(streams: readonly {
     actor?: unknown;
     status?: unknown;
-}[]): ParticipantOutcomeDetail[];
+}[], goalSourceOf?: (actor: unknown, recordedStatus: unknown) => CuaGoalSource | undefined): ParticipantOutcomeDetail[];
 /** Refresh a CUA completion claim from recorded traces, leaving original evidence and enums intact. */
 export declare function withCuaReviewProvenance(review: ReviewSummary, streams: readonly {
     actor?: unknown;

package/dist/run/outcomes.js

@@ -1,13 +1,19 @@
 import { ACTOR_STATUSES } from "../actors/contract.js";
-import { cuaGoalSource, isCuaTrace, CUA_COMPLETION_NOTE, } from "../actors/goal-source.js";
-import { actorEnding } from "../actors/stop-cause.js";
+import { cuaEndpointSource, cuaGoalSource, isClockEnd, isCuaTrace, CUA_COMPLETION_NOTE, } from "../actors/goal-source.js";
+import { actorEnding, actorStopCauseLabel } from "../actors/stop-cause.js";
 import { plural } from "./text.js";
 import { isNonNegativeSafeInteger, isRecord } from "./type-guards.js";
 /** Tally participant outcomes from actor statuses. Statuses this does not recognise are counted in
  *  `total` but nowhere else, so the parts can never exceed the whole. */
 export function tallyParticipantOutcomes(statuses, 
 /** Per-participant: did this one report friction or a defect? Same order as `statuses`. */
-reportedFriction = []) {
+reportedFriction = [], 
+/**
+ * Per-participant: did its session run until its scheduled end or session cap without it
+ * declaring that it reached the goal (ranUntilClockEnd)? Same order as `statuses`. Such a pass
+ * counts under `ranUntilEnd` in place of `reachedGoal`.
+ */
+ranUntilEnd = []) {
     const tally = {
         total: statuses.length,
         reachedGoal: 0,
@@ -17,8 +23,11 @@ reportedFriction = []) {
         harnessFailed: 0,
         reportedFriction: reportedFriction.filter(Boolean).length,
     };
-    for (const status of statuses) {
-        if (status === "passed")
+    let clockEnds = 0;
+    statuses.forEach((status, index) => {
+        if (status === "passed" && ranUntilEnd[index] === true)
+            clockEnds += 1;
+        else if (status === "passed")
             tally.reachedGoal += 1;
         else if (status === "abandoned")
             tally.abandoned += 1;
@@ -28,8 +37,8 @@ reportedFriction = []) {
             tally.blocked += 1;
         else if (status === "failed")
             tally.harnessFailed += 1;
-    }
-    return tally;
+    });
+    return clockEnds === 0 ? tally : { ...tally, ranUntilEnd: clockEnds };
 }
 /** Roll per-participant funnels up into the study funnel. Undefined when nothing measured one. */
 export function aggregateTaskFunnels(funnels) {
@@ -86,15 +95,38 @@ export function formatRunTaskFunnel(funnel) {
     })
         .join(" · ");
 }
+/**
+ * "1 ran until its session cap", "2 ran until their scheduled end", grouped by clock end, most
+ * first. Clock ends the details cannot account for get one line that names both.
+ */
+function ranUntilPhrases(count, details) {
+    const words = (n, end) => n === 1 ? `1 ran until its ${end}` : `${n} ran until their ${end}`;
+    const ends = details.flatMap((entry) => (isClockEnd(entry.goalSource) ? [entry.goalSource] : []));
+    if (ends.length !== count)
+        return [words(count, "scheduled end or session cap")];
+    return ["session_cap", "scheduled_end"]
+        .map((end) => [end, ends.filter((entry) => entry === end).length])
+        .filter(([, n]) => n > 0)
+        .sort(([, m], [, n]) => n - m)
+        .map(([end, n]) => words(n, actorStopCauseLabel(end)));
+}
 function participantCompletionLine(outcomes, terminalCauses) {
-    const completions = terminalCauses.filter((entry) => entry.status === "passed");
+    const passed = terminalCauses.filter((entry) => entry.status === "passed");
+    // A bundle without `ranUntilEnd` either has no such clock end or predates the count and tallied
+    // its clock ends under reachedGoal. Those stay among its completions, and the breakdown names
+    // them, so a re-read never changes a recorded count.
+    const completions = outcomes.ranUntilEnd === undefined
+        ? passed
+        : passed.filter((entry) => !isClockEnd(entry.goalSource));
     const reported = completions.filter((entry) => entry.goalSource === "participant_report").length;
     const matched = completions.filter((entry) => entry.goalSource === "condition_matched").length;
+    const clockEnds = completions.filter((entry) => isClockEnd(entry.goalSource));
     let goalLine = outcomes.reachedGoal === 0
         ? `0/${outcomes.total} recorded completions`
         : `${outcomes.reachedGoal}/${outcomes.total} reached the goal`;
     if (outcomes.reachedGoal > 0 && terminalCauses.some((entry) => entry.goalSource !== undefined)) {
         const count = `${outcomes.reachedGoal}/${outcomes.total}`;
+        const other = outcomes.reachedGoal - reported - matched - clockEnds.length;
         goalLine =
             completions.length !== outcomes.reachedGoal
                 ? `${count} recorded completions (completion source unavailable)`
@@ -105,9 +137,8 @@ function participantCompletionLine(outcomes, terminalCauses) {
                         : `${count} recorded completions (${[
                             reported > 0 ? `${reported} participant-reported` : undefined,
                             matched > 0 ? `${matched} condition-matched` : undefined,
-                            outcomes.reachedGoal - reported - matched > 0
-                                ? `${outcomes.reachedGoal - reported - matched} other or unavailable source`
-                                : undefined,
+                            ...(clockEnds.length > 0 ? ranUntilPhrases(clockEnds.length, clockEnds) : []),
+                            other > 0 ? `${other} other or unavailable source` : undefined,
                         ]
                             .filter(Boolean)
                             .join(", ")})`;
@@ -124,6 +155,8 @@ export function sessionEndingInWords(trace) {
             const source = cuaGoalSource(trace);
             if (source === "participant_report")
                 return "reported reaching the goal";
+            if (isClockEnd(source))
+                return `ran until its ${actorStopCauseLabel(source)}`;
             return source === "condition_matched" ? "met its completion condition" : "reached the goal";
         }
         case "turn_completed":
@@ -178,6 +211,10 @@ export function formatParticipantOutcomes(outcomes, terminalCauses = []) {
     if (outcomes.total === 0)
         return "no participants reached a terminal state";
     const parts = [participantCompletionLine(outcomes, terminalCauses)];
+    // Passed at the clock without declaring that they reached the goal: next to the completions,
+    // and never counted among them.
+    if (outcomes.ranUntilEnd !== undefined && outcomes.ranUntilEnd > 0)
+        parts.push(...ranUntilPhrases(outcomes.ranUntilEnd, terminalCauses.filter((entry) => entry.status === "passed")));
     // Detail may explain a recorded outcome, but must never change its count or invent a match
     // between a tally and an incomplete set of traces.
     const append = (count, statuses, fallback) => {
@@ -212,12 +249,12 @@ export function formatParticipantOutcomes(outcomes, terminalCauses = []) {
     return parts.join(", ");
 }
 /** Presentation details tolerate optional legacy actor payloads without changing their tallies. */
-export function participantOutcomeDetails(streams) {
+export function participantOutcomeDetails(streams, goalSourceOf = cuaGoalSource) {
     return streams.flatMap((stream) => {
         if (!isRecord(stream.actor))
             return [];
         const actor = stream.actor;
-        const goalSource = cuaGoalSource(actor, stream.status);
+        const goalSource = goalSourceOf(actor, stream.status);
         if (!ACTOR_STATUSES.includes(String(actor.status))) {
             return goalSource === "unavailable" ? [{ status: "passed", goalSource }] : [];
         }
@@ -257,6 +294,9 @@ export function withCuaReviewProvenance(review, streams) {
     const { reachedGoal, total } = review.participants;
     const bareLine = `${reachedGoal}/${total} reached the goal`;
     const qualifiedLine = participantCompletionLine(review.participants, details);
+    // Earlier releases qualified the count with the endpoint source (cuaEndpointSource), which
+    // reads a clock end as a participant report.
+    const endpointLine = participantCompletionLine(review.participants, participantOutcomeDetails(streams, cuaEndpointSource));
     // A summary with no count gets it in a header. Earlier releases wrote a header in other words.
     const header = `${plural(total, "participant")} took part: ${outcomes}.${tasks} `;
     const olderHeader = `Run gate: ${review.verdict}. Participants: ${outcomes}.${tasks} Recorded summary: `;
@@ -266,7 +306,9 @@ export function withCuaReviewProvenance(review, streams) {
             ? review.summary.split(bareLine).join(qualifiedLine)
             : review.summary.includes(qualifiedLine)
                 ? review.summary
-                : `${header}${review.summary}`;
+                : review.summary.includes(endpointLine)
+                    ? review.summary.split(endpointLine).join(qualifiedLine)
+                    : `${header}${review.summary}`;
     return {
         ...review,
         summary,

package/dist/run/stream-trace.d.ts

@@ -1,6 +1,7 @@
 import { type RunBundle } from "./bundle.js";
 import { type PreparedOutputRoot } from "./contained-output.js";
-import type { RunStream } from "./streams.js";
+import { type LiveItemsCursor } from "./live-items.js";
+import type { LiveItemsIndex, RunStream } from "./streams.js";
 /** A trace that does not match its index, or cannot be read. The message names the stream. */
 export declare class StreamTraceRefusedError extends Error {
     readonly streamId: string;
@@ -23,15 +24,27 @@ export declare function splitStreamTraces(bundle: RunBundle): {
 /**
  * Where a loader reads trace files from: the bytes at a run-relative path, at most `maxBytes`, or
  * why it could not. With `length`, the first `length` bytes, or all of a shorter file: a live file
- * grows past what run.json indexes, and the loader reads only the indexed prefix. Prepared run
- * paths read through the contained reader; the Observer server passes a reader over its pinned run
+ * grows past what run.json indexes, and the loader reads only the indexed prefix. With `start` as
+ * well, the bytes from `start` to `length`: the items past a reader's cursor. Prepared run paths
+ * read through the contained reader; the Observer server passes a reader over its pinned run
  * folder.
  */
-export type TraceFileReader = (relativePath: string, maxBytes: number, length?: number) => Promise<{
+export type TraceFileReader = (relativePath: string, maxBytes: number, length?: number, start?: number) => Promise<{
     bytes: Buffer;
 } | {
     refused: string;
 }>;
+/**
+ * A live file the loader joined into stream `streamId`: the index it read the items by, and the
+ * cursor it read past when the stream holds only the items after one.
+ */
+export interface LiveItemsRead {
+    streamId: string;
+    index: LiveItemsIndex;
+    after?: LiveItemsCursor;
+}
+/** For a live file's index, the prefix of that file the caller holds already, if any. */
+type LiveAfter = (index: LiveItemsIndex) => LiveItemsCursor | undefined;
 /**
  * The stream as a v1 run.json held it: its actor with every item and every artifact entry. A
  * stream without an index is returned as it is (a v1 stream, or one with no actor). An indexed
@@ -44,6 +57,8 @@ export declare function loadStreamTrace(runPaths: PreparedOutputRoot, stream: Ru
 interface LoadedTraces {
     bundle: RunBundle;
     refused: StreamTraceRefusedError[];
+    /** Each live file joined into a stream that loaded, in stream order. */
+    live: LiveItemsRead[];
 }
 /**
  * Every stream of the bundle loaded through loadStreamTrace, one file at a time, and the refusal
@@ -53,6 +68,11 @@ interface LoadedTraces {
  * receives each trace and live file's path and the bytes the stream was joined from, after they
  * matched the index, so a caller scans exactly what it reads.
  *
+ * `liveAfter` names, for a live file's index, the prefix the caller holds already (the Observer
+ * feed's cursor). The loader then reads and joins only the items past it, checked by liveItemsAfter
+ * without the indexed sha256, and `live` records the cursor; a cursor past the index or off the
+ * file's lines gets the whole prefix, checked as always.
+ *
  * A live file that cannot be read may have been removed by the writer after `bundle` was read: it
  * removes a superseded generation once run.json names the next one, and every live file once the
  * run finished. The loader then reads run.json again, once, through the same reader, and loads
@@ -61,6 +81,7 @@ interface LoadedTraces {
 export declare function loadStreamTraces(source: PreparedOutputRoot | TraceFileReader, bundle: RunBundle, options?: {
     maxBytes?: number;
     onTrace?: (path: string, bytes: Buffer) => void;
+    liveAfter?: LiveAfter;
 }): Promise<LoadedTraces>;
 /**
  * A loaded bundle as a reader that shows a run presents it. A refused stream keeps run.json's