humanish 0.127.0 → 0.127.1

package/CHANGELOG.md

@@ -8,6 +8,17 @@ 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

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";
@@ -29,10 +29,11 @@ export interface Stop {
  */
 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

@@ -30,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/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/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/routes/computer-use/fanout-bundle.js

@@ -37,14 +37,18 @@ function fanoutPlanEvents(args) {
 }
 /**
  * The run's summary in plain sentences: who took part, what happened to them with the denominator
- * attached, and that the gaps list the participants who did not pass.
+ * attached, and that the gaps list the participants who did not pass. A participant the run
+ * skipped before its session started never used the app, so it is counted in a sentence of its
+ * own.
  */
 function fanoutSummary(args, facts) {
     const count = args.specs.length;
     const people = plural(count, "participant");
     const rerun = args.rerun === undefined ? "" : `Rerun from ${args.rerun.sourceRunId}: `;
+    // The live summary is written once, before any participant starts, so it names the plan: by
+    // the time it is read a participant may still be waiting, or skipped.
     if (args.inProgress === true) {
-        return `${people} ${count === 1 ? "is" : "are"} each using their own copy of the app. The run is still going, so nothing here is final.`;
+        return `${people} ${count === 1 ? "is planned, in its own copy" : "are planned, each in their own copy"} of the app. The run is still going, so nothing here is final.`;
     }
     if (args.dryRun) {
         return `${rerun}Dry run: ${people} would each use their own copy of ${subjectName(publicSafeAppUrlLabel(args.appUrl), args.aggregateSubject)}. No desktops were launched and $0 was spent.`;
@@ -52,7 +56,20 @@ function fanoutSummary(args, facts) {
     const tasks = facts.tasks === undefined ? "" : ` Tasks: ${facts.tasks}.`;
     // A host suspension comes first: it may explain everything after it.
     const host = args.hostSuspension === undefined ? "" : `${args.hostSuspension.summary} `;
-    return `${host}${rerun}${people} took part, each in their own copy of the app: ${facts.outcomes}${gapsListClause(count - facts.passed, count)}.${tasks}`;
+    const tookPart = count - facts.skipped;
+    const outcomes = facts.outcomes ?? `0/${tookPart} finished a session`;
+    const gaps = gapsListClause(tookPart - facts.passed, tookPart);
+    const sentences = [];
+    // A run where every participant was skipped has no one to describe in this sentence.
+    if (tookPart > 0)
+        sentences.push(`${plural(tookPart, "participant")} took part, ${tookPart === 1 ? "in its own copy" : "each in their own copy"} of the app: ${outcomes}${gaps}.`);
+    // The gaps are pointed at once: here only when the sentence before did not.
+    const why = gaps === "" ? "; the gaps say why" : "";
+    if (facts.skipped === 1)
+        sentences.push(`1 participant was skipped before its session started${why}.`);
+    if (facts.skipped > 1)
+        sentences.push(`${facts.skipped} participants were skipped before their sessions started${why}.`);
+    return `${host}${rerun}${sentences.join(" ")}${tasks}`;
 }
 /**
  * The review's gaps: one line for the participants a host suspension likely failed, then a line
@@ -75,6 +92,7 @@ function fanoutReview(args, streams, judgment) {
     // The judge's verdict: live fan-out must prove every participant (judgeParticipants).
     const verdict = args.verdict;
     const passedParticipants = judgment.participants.filter((participant) => participant.judgedStatus === "passed").length;
+    const skippedParticipants = (outcomes ?? []).filter((outcome) => outcome?.skippedReason !== undefined).length;
     // What happened to the participants, with the denominator attached. The verdict above has to
     // collapse the run to one word; this does not (docs/principles/three-roles.md).
     const terminalOutcomes = (outcomes ?? []).filter((outcome) => outcome?.session?.status !== undefined);
@@ -103,9 +121,10 @@ function fanoutReview(args, streams, judgment) {
         // sandbox, so the summary carries its digest, which verify accepts in a shared run.
         summary: fanoutSummary(args, {
             passed: passedParticipants,
-            outcomes: participants === undefined
-                ? `0/${args.specs.length} finished a session`
-                : formatParticipantOutcomes(participants, participantEndings),
+            skipped: skippedParticipants,
+            ...(participants === undefined
+                ? {}
+                : { outcomes: formatParticipantOutcomes(participants, participantEndings) }),
             ...(runTasks === undefined ? {} : { tasks: formatRunTaskFunnel(runTasks) }),
         }),
         gaps: args.inProgress === true

package/docs/architecture/actor-contract.md

@@ -352,14 +352,18 @@ this paragraph is the record of that decision.
 
 `ComputerUseProvider.debrief` is an optional read-only request after a structured
 `stopWhen` or dwell stop. It returns a `ComputerUseTurn` with `closingReport` containing
-`summary`, `frictionReports` and `impressions`; an empty friction or impressions list is valid,
-and a report without `impressions` (an older provider) is still accepted. The loop rejects
+`outcome`, `summary`, `frictionReports` and `impressions`; an empty friction or impressions list
+is valid, and a report without `outcome` or `impressions` (an older provider) is still accepted.
+After a scheduled end or session cap, `outcome` (`reached`, `not_reached` or `blocked`) is the
+trace's `declaredOutcome`, read before the first line of `summary`. The loop rejects
 actions, pending safety checks, and invalid report shapes. It redacts accepted
 reports, records them in `ActorTrace.debrief`, and projects one readable message
 without invoking action or communication callbacks. Each impression becomes its own message
 and goes to `ActorTrace.impressions`; a session without them records why in the same field.
 A turn that ends the session itself may carry `closingReport` too, and the loop keeps its
-impressions the same way without a second request.
+impressions the same way without a second request. Its `declaredOutcome` is the report's
+`outcome`, then the turn's `outcome`, then the first line of its message, the order a closing
+report at a scheduled end is read in.
 
 `ComputerUseProvider.requestImpressions` is the optional request after the participant ended
 the session itself without impressions. It asks for impressions only, returns them as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.127.0",
+  "version": "0.127.1",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",