humanish 0.114.0 → 0.115.0

package/CHANGELOG.md

@@ -8,6 +8,25 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.115.0: Closing report limits, admitted analysis cost, concurrent reviewer notes, known-value scrub (2026-10-08)
+
+humanish 0.115.0 asks the OpenAI computer-use participant for its closing report and impressions
+within the limits its reply is checked against, keeps every reviewer note added at the same time,
+and finds more encoded forms of a registered secret. The participant's request schema now carries
+the limits the parser already enforced: a summary of up to 4,000 characters, up to 8 friction
+reports of up to 2,000 characters and up to 6 impressions of up to 500 characters, so a longer
+reply is no longer requested and then dropped. `analyze --json` adds `admission.admittedCostUsd`,
+the smallest `--max-cost` that admits the analysis, and `humanish analyze` names its refusal
+command as `npx humanish analyze` where humanish is a dev dependency. A reviewer note is created
+under its own name, so notes added together from the Observer and `humanish notes --add` are all
+kept. `export --local-only` keeps a `blocked` run `blocked` when its analysis fails the export's
+own check. The known-value scrub exempts only the markers humanish writes, reads text in the same
+five ways as `verify`, and finds a value that overlaps itself in time linear in the text. The TUI's
+study screen shows the expected analysis cost line that `study check` prints, telemetry reads
+`CI=false` as off, and `humanish keys set constructor` is refused with the list of provider keys.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.115.0)
+
 ## 0.114.0: Reviewer notes, expected analysis cost, percent-encoded UTF-8 in verify (2026-10-08)
 
 humanish 0.114.0 lets a reviewer note a moment of a recorded run, admits post-run analysis on its

package/CONTEXT.md

@@ -41,7 +41,7 @@ bundle and output fields keep older spellings; the second table maps them.
 | analysis            | An independent model reading of a finished run's retained evidence, kept apart from participant feedback. Supported live runs request it automatically, and `humanish analyze` runs it on demand. It records findings and observations as `humanish.study-analysis.v1`.                                                                                                                                                                                                                                                               | `src/analysis/`; `runAutomaticAnalysis` in `src/analysis/automatic.ts`; `analyzeRun` in `src/analysis/service.ts`; `ANALYSIS_SCHEMA` in `src/analysis/types.ts`                                                                                                                                                                                                                                             |
 | finding             | A result of analysis, with citations to evidence in the run. Each finding groups the observations that support it.                                                                                                                                                                                                                                                                                                                                                                                                                    | `src/analysis/`                                                                                                                                                                                                                                                                                                                                                                                             |
 | observation         | One claim in analysis with its basis, evidence ids and limitation. `concernReviews[]` gives each material concern's observation a disposition: `finding`, `context` or `unsupported`.                                                                                                                                                                                                                                                                                                                                                 | `src/analysis/`                                                                                                                                                                                                                                                                                                                                                                                             |
-| reviewer note       | Free text a person adds at a moment of a recorded run, for one participant or the whole run, kept in the run directory as its own file, `notes/<id>.json` (`humanish.run-note.v1`). It is not participant feedback or analysis. `humanish notes` and an Observer served on loopback add notes.                                                                                                                                                                                                                                        | `addRunNote` in `src/run/notes.ts`; `readRunNotes` in `src/run/note-files.ts`; `createNotesWriter` in `src/observer/notes-route.ts`                                                                                                                                                                                                                                                                         |
+| reviewer note       | Free text a person adds at a moment of a recorded run, for one participant or the whole run, kept in the run directory as its own file, `notes/<id>.json` (`humanish.run-note.v1`). It is not participant feedback or analysis. `humanish notes` and an Observer served on loopback add notes.                                                                                                                                                                                                                                        | `RunNote` and its limits in `src/run/note-shape.ts`; `addRunNote` in `src/run/notes.ts`; `readRunNotes` in `src/run/note-files.ts`; `createNotesWriter` in `src/observer/notes-route.ts`                                                                                                                                                                                                                    |
 
 ## Read these field spellings as the concept they name
 

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

@@ -0,0 +1,11 @@
+/**
+ * How much a participant's closing report may hold. Participants are asked for no more, and a
+ * reply that holds more is rejected. Characters are counted as `String.length` counts them.
+ */
+export declare const CLOSING_REPORT_LIMITS: Readonly<{
+    summaryChars: 4000;
+    frictionReports: 8;
+    frictionReportChars: 2000;
+    impressions: 6;
+    impressionChars: 500;
+}>;

package/dist/actors/closing-report-limits.js

@@ -0,0 +1,13 @@
+// The closing report's limits, kept apart from its zod schema in closing-report.ts so the
+// Observer can read them: it bundles this module, and zod stays out of its page.
+/**
+ * How much a participant's closing report may hold. Participants are asked for no more, and a
+ * reply that holds more is rejected. Characters are counted as `String.length` counts them.
+ */
+export const CLOSING_REPORT_LIMITS = Object.freeze({
+    summaryChars: 4000,
+    frictionReports: 8,
+    frictionReportChars: 2000,
+    impressions: 6,
+    impressionChars: 500,
+});

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

@@ -0,0 +1,68 @@
+import { z } from "zod";
+declare const impressionSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        liked: "liked";
+        missing: "missing";
+        unclear: "unclear";
+        unfinished: "unfinished";
+        unlike_my_work: "unlike_my_work";
+        untrustworthy: "untrustworthy";
+    }>;
+    text: z.ZodString;
+}, z.core.$strict>;
+/** The impressions a participant gave; an empty list means it had none. */
+export declare const participantImpressionsSchema: z.ZodArray<z.ZodObject<{
+    kind: z.ZodEnum<{
+        liked: "liked";
+        missing: "missing";
+        unclear: "unclear";
+        unfinished: "unfinished";
+        unlike_my_work: "unlike_my_work";
+        untrustworthy: "untrustworthy";
+    }>;
+    text: z.ZodString;
+}, z.core.$strict>>;
+/**
+ * A closing report. A report without impressions is still valid: third-party provider ports and
+ * stored traces do not have them.
+ */
+export declare const closingReportSchema: z.ZodObject<{
+    summary: z.ZodString;
+    frictionReports: z.ZodArray<z.ZodString>;
+    impressions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            liked: "liked";
+            missing: "missing";
+            unclear: "unclear";
+            unfinished: "unfinished";
+            unlike_my_work: "unlike_my_work";
+            untrustworthy: "untrustworthy";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+/** The reply to an impressions-only request: the impressions and nothing else. */
+export declare const impressionsReplySchema: z.ZodObject<{
+    impressions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            liked: "liked";
+            missing: "missing";
+            unclear: "unclear";
+            unfinished: "unfinished";
+            unlike_my_work: "unlike_my_work";
+            untrustworthy: "untrustworthy";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** The participant's account, not an independently confirmed product diagnosis. */
+export type ParticipantClosingReport = z.infer<typeof closingReportSchema>;
+/** One first-person impression about something the participant saw in the session. */
+export type ParticipantImpression = z.infer<typeof impressionSchema>;
+/**
+ * The JSON Schema a strict structured-output request sends for `schema`. Strict mode needs every
+ * field, so optional ones become required. `$schema` is left out, so the request carries only
+ * keywords both providers' strict modes are known to accept.
+ */
+export declare function strictOutputSchema(schema: z.ZodObject): Record<string, unknown>;
+export {};

package/dist/actors/closing-report.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { CLOSING_REPORT_LIMITS as LIMITS } from "./closing-report-limits.js";
+// What a participant says at the end of a session: the closing report and its impressions. This
+// schema is the one description of them. The providers send the JSON Schema made from it, and
+// every reply is parsed with it, so a participant is asked for exactly what is accepted.
+/**
+ * What a participant can say about the product at the end of a session, beyond friction.
+ * `unlike_my_work` compares the screen with how the persona does the same task in its own work or
+ * life.
+ */
+const PARTICIPANT_IMPRESSION_KINDS = [
+    "unclear",
+    "unfinished",
+    "untrustworthy",
+    "liked",
+    "missing",
+    "unlike_my_work",
+];
+/**
+ * Text the participant wrote. The JSON Schema carries the length limits; the check that it is not
+ * only whitespace runs on the reply.
+ */
+const said = (maxChars) => z
+    .string()
+    .min(1)
+    .max(maxChars)
+    .refine((text) => text.trim() !== "");
+const impressionSchema = z.strictObject({
+    kind: z.enum(PARTICIPANT_IMPRESSION_KINDS),
+    text: said(LIMITS.impressionChars),
+});
+/** 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
+ * stored traces do not have them.
+ */
+export const closingReportSchema = z.strictObject({
+    summary: said(LIMITS.summaryChars),
+    frictionReports: z.array(said(LIMITS.frictionReportChars)).max(LIMITS.frictionReports),
+    impressions: participantImpressionsSchema.optional(),
+});
+/** The reply to an impressions-only request: the impressions and nothing else. */
+export const impressionsReplySchema = z.strictObject({
+    impressions: participantImpressionsSchema,
+});
+/**
+ * The JSON Schema a strict structured-output request sends for `schema`. Strict mode needs every
+ * field, so optional ones become required. `$schema` is left out, so the request carries only
+ * keywords both providers' strict modes are known to accept.
+ */
+export function strictOutputSchema(schema) {
+    const { $schema: _dialect, ...json } = z.toJSONSchema(schema.required(), { io: "input" });
+    return json;
+}

package/dist/actors/codex/restricted-participant-policy.d.ts

@@ -1,5 +1,6 @@
-import { type CuaTurn } from "../computer-use/loop.js";
-import { type ActorExecutionProfile, type ParticipantClosingReport } from "../contract.js";
+import { type ParticipantClosingReport } from "../closing-report.js";
+import type { CuaTurn } from "../computer-use/loop.js";
+import type { ActorExecutionProfile } from "../contract.js";
 /** The declared profile. A participant replaces cliVersion with its detected CLI release, or with
  * this host's newest qualified release before its first launch. */
 export declare const PARTICIPANT_PROFILE: Readonly<ActorExecutionProfile>;
@@ -16,51 +17,7 @@ export declare const PARTICIPANT_LIMITS: Readonly<{
 }>;
 export declare function participantToolSchema(speechEnabled?: boolean): Record<string, unknown>;
 export declare const PARTICIPANT_TOOL_SCHEMA: Record<string, unknown>;
-export declare const PARTICIPANT_FINAL_SCHEMA: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        outcome: {
-            type: string;
-            enum: string[];
-        };
-        summary: {
-            type: string;
-            minLength: number;
-            maxLength: number;
-        };
-        frictionReports: {
-            type: string;
-            maxItems: number;
-            items: {
-                type: string;
-                minLength: number;
-                maxLength: number;
-            };
-        };
-        impressions: {
-            type: string;
-            maxItems: number;
-            items: {
-                type: string;
-                additionalProperties: boolean;
-                required: string[];
-                properties: {
-                    kind: {
-                        type: string;
-                        enum: ("liked" | "missing" | "unclear" | "unfinished" | "unlike_my_work" | "untrustworthy")[];
-                    };
-                    text: {
-                        type: string;
-                        minLength: number;
-                        maxLength: number;
-                    };
-                };
-            };
-        };
-    };
-};
+export declare const PARTICIPANT_FINAL_SCHEMA: Record<string, unknown>;
 /** humanish tool arguments, validated before the shared executor sees a batch. */
 export declare function parseParticipantTool(value: unknown, speechEnabled?: boolean): CuaTurn;
 export declare function parseParticipantFinal(value: unknown): CuaTurn & {

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

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import { BROWSER_CONTROL_LIMITS, browserControlActionSchema, browserOnlyControlActionSchema, validateBrowserControlAction, } from "../../browser-control/protocol.js";
-import { validClosingReport } from "../computer-use/loop.js";
-import { PARTICIPANT_IMPRESSION_KINDS, } from "../contract.js";
+import { closingReportSchema, strictOutputSchema, } from "../closing-report.js";
 /** The declared profile. A participant replaces cliVersion with its detected CLI release, or with
  * this host's newest qualified release before its first launch. */
 export const PARTICIPANT_PROFILE = Object.freeze({
@@ -38,33 +37,12 @@ export function participantToolSchema(speechEnabled = false) {
     return z.toJSONSchema(toolInput(speechEnabled), { io: "input" });
 }
 export const PARTICIPANT_TOOL_SCHEMA = participantToolSchema();
-export const PARTICIPANT_FINAL_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    required: ["outcome", "summary", "frictionReports", "impressions"],
-    properties: {
-        outcome: { type: "string", enum: ["reached", "not_reached", "blocked"] },
-        summary: { type: "string", minLength: 1, maxLength: 4000 },
-        frictionReports: {
-            type: "array",
-            maxItems: 8,
-            items: { type: "string", minLength: 1, maxLength: 2000 },
-        },
-        impressions: {
-            type: "array",
-            maxItems: 6,
-            items: {
-                type: "object",
-                additionalProperties: false,
-                required: ["kind", "text"],
-                properties: {
-                    kind: { type: "string", enum: [...PARTICIPANT_IMPRESSION_KINDS] },
-                    text: { type: "string", minLength: 1, maxLength: 500 },
-                },
-            },
-        },
-    },
-};
+/** 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,
+});
+export const PARTICIPANT_FINAL_SCHEMA = strictOutputSchema(participantFinal);
 /**
  * Shorten each wait longer than one browser-control request may wait. A failed tool call ends the
  * native run, so a wait that asks too much would otherwise end the whole session.
@@ -107,22 +85,16 @@ export function parseParticipantTool(value, speechEnabled = false) {
     };
 }
 export function parseParticipantFinal(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error("invalid_response");
-    const { outcome, ...report } = value;
-    if ((outcome !== "reached" && outcome !== "not_reached" && outcome !== "blocked") ||
-        !validClosingReport(report))
+    const final = participantFinal.safeParse(value);
+    if (!final.success)
         throw new Error("invalid_response");
+    const { outcome, ...closingReport } = final.data;
     return {
         actions: [],
         pendingSafetyChecks: [],
         done: true,
         outcome,
-        message: [report.summary, ...report.frictionReports].join("\n"),
-        closingReport: {
-            summary: report.summary,
-            frictionReports: [...report.frictionReports],
-            ...(report.impressions === undefined ? {} : { impressions: [...report.impressions] }),
-        },
+        message: [closingReport.summary, ...closingReport.frictionReports].join("\n"),
+        closingReport,
     };
 }

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

@@ -1,4 +1,4 @@
-import { type ActorTrace, type ParticipantClosingReport, type ParticipantImpression } from "../../contract.js";
+import type { ActorTrace } from "../../contract.js";
 import type { DebriefTrigger } from "./ending.js";
 import type { LoopSession } from "./session.js";
 import type { CuaTurnRequest } from "./types.js";
@@ -9,15 +9,6 @@ export interface DebriefContext {
     readonly previousExecution: CuaTurnRequest["previousExecution"];
     readonly acknowledgedSafetyChecks: CuaTurnRequest["acknowledgedSafetyChecks"];
 }
-/**
- * Runtime validation is also required for third-party provider ports. A report without
- * impressions stays valid: older providers and stored traces do not have them.
- */
-export declare function validClosingReport(value: unknown): value is ParticipantClosingReport;
-/** The reply to an impressions-only request: an object with the impressions and nothing else. */
-export declare function validImpressionsReply(value: unknown): value is {
-    impressions: ParticipantImpression[];
-};
 /**
  * Ask the participant for its closing report after a structured stop, or for its impressions only
  * after it ended the session itself, or record why the request was skipped. Either way the result

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

@@ -1,4 +1,4 @@
-import { PARTICIPANT_IMPRESSION_KINDS, } from "../../contract.js";
+import { closingReportSchema, participantImpressionsSchema } from "../../closing-report.js";
 import { isComputerUseAdmissionLimitError } from "../admission-limit.js";
 import { IMPRESSIONS_ASK, IMPRESSIONS_HINT, recordImpressions } from "./impressions.js";
 import { singleDispatch } from "./provider-call.js";
@@ -7,45 +7,6 @@ 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.`;
-/**
- * Runtime validation is also required for third-party provider ports. A report without
- * impressions stays valid: older providers and stored traces do not have them.
- */
-export function validClosingReport(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const report = value;
-    return (Object.keys(report).every((key) => REPORT_KEYS.includes(key)) &&
-        typeof report.summary === "string" &&
-        report.summary.trim().length > 0 &&
-        report.summary.length <= 4_000 &&
-        Array.isArray(report.frictionReports) &&
-        report.frictionReports.length <= 8 &&
-        report.frictionReports.every((item) => typeof item === "string" && item.trim().length > 0 && item.length <= 2_000) &&
-        (report.impressions === undefined || validImpressions(report.impressions)));
-}
-const REPORT_KEYS = ["summary", "frictionReports", "impressions"];
-/** The reply to an impressions-only request: an object with the impressions and nothing else. */
-export function validImpressionsReply(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const reply = value;
-    return Object.keys(reply).length === 1 && validImpressions(reply.impressions);
-}
-function validImpressions(value) {
-    return (Array.isArray(value) &&
-        value.length <= 6 &&
-        value.every((item) => {
-            if (item === null || typeof item !== "object" || Array.isArray(item))
-                return false;
-            const { kind, text, ...rest } = item;
-            return (Object.keys(rest).length === 0 &&
-                PARTICIPANT_IMPRESSION_KINDS.some((known) => known === kind) &&
-                typeof text === "string" &&
-                text.trim().length > 0 &&
-                text.length <= 500);
-        }));
-}
 /**
  * Ask the participant for its closing report after a structured stop, or for its impressions only
  * after it ended the session itself, or record why the request was skipped. Either way the result
@@ -171,22 +132,25 @@ function acceptDebriefTurn(session, turn, trigger, record) {
     if (turn.actions.length > 0 || turn.pendingSafetyChecks.length > 0) {
         return record("failed", "the closing response requested actions or safety checks; none were executed and its report was not accepted", usageReported);
     }
+    // First-party providers parse their replies already; these parses cover third-party ports.
     if (trigger.kind === "participant_end") {
-        if (!validImpressions(turn.impressions)) {
+        const impressions = participantImpressionsSchema.safeParse(turn.impressions);
+        if (!impressions.success) {
             return record("failed", turn.interruption === "output_limit"
                 ? "the reply was cut off by the output limit"
                 : "the reply did not contain valid impressions", usageReported);
         }
-        session.impressions = recordImpressions(session, turn.impressions);
+        session.impressions = recordImpressions(session, impressions.data);
         return record("completed", "one read-only impressions request; no additional desktop actions; the participant's own ending is unchanged", usageReported);
     }
-    if (!validClosingReport(turn.closingReport)) {
+    const closing = closingReportSchema.safeParse(turn.closingReport);
+    if (!closing.success) {
         return record("failed", "the closing response did not contain a valid structured participant report", usageReported);
     }
     const report = {
-        summary: session.redactNarration(turn.closingReport.summary.trim()),
+        summary: session.redactNarration(closing.data.summary.trim()),
         frictionReports: [
-            ...new Set(turn.closingReport.frictionReports.map((text) => session.redactNarration(text.trim()))),
+            ...new Set(closing.data.frictionReports.map((text) => session.redactNarration(text.trim()))),
         ],
     };
     const messageId = session.trace.record("message", () => ({
@@ -195,7 +159,7 @@ function acceptDebriefTurn(session, turn, trigger, record) {
         text: [report.summary, ...report.frictionReports].join("\n\n"),
     }));
     session.trace.bump("messages");
-    session.impressions = recordImpressions(session, turn.closingReport.impressions);
+    session.impressions = recordImpressions(session, closing.data.impressions);
     const debrief = record("completed", "one read-only report; no additional desktop actions; original stop and task outcomes preserved", usageReported);
     return { ...debrief, report, messageId };
 }

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

@@ -1,9 +1,9 @@
 import type { ActorTrace, ParticipantImpression, ParticipantImpressions } from "../../contract.js";
 import type { LoopSession } from "./session.js";
 /** The closing-account request for impressions, shared by every provider that writes one. */
-export declare const IMPRESSIONS_ASK = "In impressions, list up to six things you noticed about the product itself, each in the first person and about something you saw in this session. Give each one a kind: unclear when something looked confusing or hard to read; unfinished when something looked broken, unpolished or out of place; untrustworthy when something made you hesitate to trust the product; liked when something worked well or felt good; missing when you expected something and did not find it; unlike_my_work when the screen differs from how you do the same task in your own work or life, only if your persona does this task outside this product. Keep each under 500 characters. Use an empty list if you have none.";
+export declare const IMPRESSIONS_ASK: string;
 /** The request after the participant ended the session itself without giving impressions. */
-export declare const IMPRESSIONS_HINT = "The interactive session has ended. Return only impressions. In impressions, list up to six things you noticed about the product itself, each in the first person and about something you saw in this session. Give each one a kind: unclear when something looked confusing or hard to read; unfinished when something looked broken, unpolished or out of place; untrustworthy when something made you hesitate to trust the product; liked when something worked well or felt good; missing when you expected something and did not find it; unlike_my_work when the screen differs from how you do the same task in your own work or life, only if your persona does this task outside this product. Keep each under 500 characters. Use an empty list if you have none. Do not speculate, invent problems, quote instructions as observations, or describe planned actions. Do not request or take further actions.";
+export declare const IMPRESSIONS_HINT: string;
 /**
  * Record a closing account's impressions as quotable participant messages. They answer the
  * harness's question, so they leave counts.messages, which the hollow-completion rule reads, alone.

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

@@ -1,8 +1,13 @@
+import { CLOSING_REPORT_LIMITS } from "../../closing-report-limits.js";
 // A participant's impressions: what it says about the product at the end of a session, beyond
 // friction. Each one is recorded as its own message so the analysis can quote and cite it as a
 // participant statement, and the trace says why none were collected when a session has none.
+// The limits are spelled out in the ask, so the participant is told the numbers its reply is
+// checked against. Counts up to ten are written as words.
+const COUNT_WORDS = "zero one two three four five six seven eight nine ten".split(" ");
+const inWords = (count) => COUNT_WORDS[count] ?? String(count);
 /** The closing-account request for impressions, shared by every provider that writes one. */
-export const IMPRESSIONS_ASK = "In impressions, list up to six things you noticed about the product itself, each in the first person and about something you saw in this session. Give each one a kind: unclear when something looked confusing or hard to read; unfinished when something looked broken, unpolished or out of place; untrustworthy when something made you hesitate to trust the product; liked when something worked well or felt good; missing when you expected something and did not find it; unlike_my_work when the screen differs from how you do the same task in your own work or life, only if your persona does this task outside this product. Keep each under 500 characters. Use an empty list if you have none.";
+export const IMPRESSIONS_ASK = `In impressions, list up to ${inWords(CLOSING_REPORT_LIMITS.impressions)} things you noticed about the product itself, each in the first person and about something you saw in this session. Give each one a kind: unclear when something looked confusing or hard to read; unfinished when something looked broken, unpolished or out of place; untrustworthy when something made you hesitate to trust the product; liked when something worked well or felt good; missing when you expected something and did not find it; unlike_my_work when the screen differs from how you do the same task in your own work or life, only if your persona does this task outside this product. Keep each under ${CLOSING_REPORT_LIMITS.impressionChars} characters. Use an empty list if you have none.`;
 /** The request after the participant ended the session itself without giving impressions. */
 export const IMPRESSIONS_HINT = `The interactive session has ended. Return only impressions. ${IMPRESSIONS_ASK} Do not speculate, invent problems, quote instructions as observations, or describe planned actions. Do not request or take further actions.`;
 /**

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

@@ -2,7 +2,6 @@ import type { CuaLoopOptions, CuaLoopResult, LoopRunOptions } from "./loop/types
 export type { CuaAction, CuaExecutor, CuaLiveMetadata, CuaLoopOptions, CuaLoopResult, CuaObservation, CuaProvider, CuaSafetyCheck, CuaSpendGate, CuaTurn, CuaTurnRequest, ShortenedWait, } from "./loop/types.js";
 export { describeCuaAction } from "./loop/actions.js";
 export { stableProgressKey } from "./loop/backstop.js";
-export { validClosingReport, validImpressionsReply } from "./loop/debrief.js";
 export { IMPRESSIONS_ASK } from "./loop/impressions.js";
 /**
  * Drive the loop to one explicit completion and return its CuaLoopResult: status, completion

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

@@ -1,7 +1,8 @@
+import { closingReportSchema } from "../closing-report.js";
 import { ComputerUseProviderError } from "./provider-error.js";
 import { runActionBatch } from "./loop/actions.js";
 import { advanceBackstop, startBackstop } from "./loop/backstop.js";
-import { requestDebrief, validClosingReport } from "./loop/debrief.js";
+import { requestDebrief } from "./loop/debrief.js";
 import * as stops from "./loop/ending.js";
 import { declaredOutcomeOf } from "./loop/ending.js";
 import { notCollected, recordImpressions } from "./loop/impressions.js";
@@ -14,7 +15,6 @@ import { accountBillingConflicts } from "./loop/usage.js";
 import { loopResult, notice } from "./loop/trace.js";
 export { describeCuaAction } from "./loop/actions.js";
 export { stableProgressKey } from "./loop/backstop.js";
-export { validClosingReport, validImpressionsReply } from "./loop/debrief.js";
 export { IMPRESSIONS_ASK } from "./loop/impressions.js";
 /**
  * Drive the loop to one explicit completion and return its CuaLoopResult: status, completion
@@ -120,7 +120,7 @@ async function runTurns(session, conversation) {
             // The declared outcome is kept even if redacting the participant's summary fails.
             session.declaredOutcome = declaredOutcomeOf(turn);
             const ended = stops.participantEnded(turn, session.declaredOutcome, (text) => session.redactNarration(text));
-            const report = validClosingReport(turn.closingReport) ? turn.closingReport : undefined;
+            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-conversation.d.ts

@@ -1,6 +1,6 @@
 import type { CuaTurn, CuaTurnRequest } from "./loop.js";
 import type { ReasoningEffort } from "../reasoning-effort.js";
-import { type ActorConversation } from "../contract.js";
+import type { ActorConversation } from "../contract.js";
 import { type OpenAiReasoningSummary } from "./openai-wire.js";
 /** How a conversation starts. The model settings stay fixed for the whole session. */
 export interface OpenAiConversationSettings {

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

@@ -1,4 +1,4 @@
-import { PARTICIPANT_IMPRESSION_KINDS } from "../contract.js";
+import { closingReportSchema, impressionsReplySchema, strictOutputSchema, } from "../closing-report.js";
 import { CarriedConversation, estimateTokens } from "./openai-context.js";
 import { buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, openingMessage, parseOpenAiResponse, } from "./openai-wire.js";
 /**
@@ -6,44 +6,18 @@ import { buildCallOutput, buildContinuationRequest, buildInitialRequest, hintIte
  * counts reasoning too, and leaves room for six impressions after the summary and friction reports.
  */
 const CLOSING_OUTPUT_LIMIT = 3072;
-const IMPRESSIONS_SCHEMA = {
-    type: "array",
-    items: {
-        type: "object",
-        additionalProperties: false,
-        required: ["kind", "text"],
-        properties: {
-            kind: { type: "string", enum: [...PARTICIPANT_IMPRESSION_KINDS] },
-            text: { type: "string" },
-        },
-    },
-};
 const CLOSING_FORMATS = {
     report: {
         type: "json_schema",
         name: "participant_closing_report",
         strict: true,
-        schema: {
-            type: "object",
-            additionalProperties: false,
-            required: ["summary", "frictionReports", "impressions"],
-            properties: {
-                summary: { type: "string" },
-                frictionReports: { type: "array", items: { type: "string" } },
-                impressions: IMPRESSIONS_SCHEMA,
-            },
-        },
+        schema: strictOutputSchema(closingReportSchema),
     },
     impressions: {
         type: "json_schema",
         name: "participant_impressions",
         strict: true,
-        schema: {
-            type: "object",
-            additionalProperties: false,
-            required: ["impressions"],
-            properties: { impressions: IMPRESSIONS_SCHEMA },
-        },
+        schema: strictOutputSchema(impressionsReplySchema),
     },
 };
 export class OpenAiConversation {

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

@@ -1,4 +1,4 @@
-import { validClosingReport, validImpressionsReply } from "./loop.js";
+import { closingReportSchema, impressionsReplySchema } from "../closing-report.js";
 import { ComputerUseAdmissionLimitError, isComputerUseAdmissionLimitError, } from "./admission-limit.js";
 import { ComputerUsePromptRefusedError } from "./provider-error.js";
 import { OpenAiConversation, } from "./openai-conversation.js";
@@ -469,10 +469,16 @@ export function createOpenAiResponsesProvider(options) {
             try {
                 const reply = JSON.parse(turn.message ?? "");
                 if (asRecord(raw).status === "completed") {
-                    if (closing === "report" && validClosingReport(reply))
-                        return { ...turn, closingReport: reply };
-                    if (closing === "impressions" && validImpressionsReply(reply))
-                        return { ...turn, impressions: reply.impressions };
+                    if (closing === "report") {
+                        const report = closingReportSchema.safeParse(reply);
+                        if (report.success)
+                            return { ...turn, closingReport: report.data };
+                    }
+                    else {
+                        const impressions = impressionsReplySchema.safeParse(reply);
+                        if (impressions.success)
+                            return { ...turn, impressions: impressions.data.impressions };
+                    }
                 }
             }
             catch {