humanish 0.111.4 → 0.113.0

package/dist/actors/computer-use/openai-conversation.d.ts

@@ -0,0 +1,96 @@
+import type { CuaTurn, CuaTurnRequest } from "./loop.js";
+import type { ReasoningEffort } from "../reasoning-effort.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 {
+    readonly model: string;
+    readonly reasoningEffort: ReasoningEffort;
+    readonly maxOutputTokens?: number;
+    readonly safetyIdentifier?: string;
+    /** The summaries to ask for until the account or model rejects them; undefined asks for none. */
+    readonly reasoningSummary: OpenAiReasoningSummary | undefined;
+    /** Carry the conversation on the client from the first request (explicit_context). */
+    readonly zeroDataRetention: boolean;
+    /** The clock the trace's record reads. */
+    readonly now: () => number;
+}
+/**
+ * One request of the conversation. Its new items are built once, so every attempt at it, and the
+ * reply it accepts, see the same ones.
+ */
+export interface ConversationRequest {
+    /** The body as the conversation stands now, so an attempt after a rejection shows its effect. */
+    body(): Record<string, unknown>;
+    /**
+     * The request was answered: records a participant request with what it carried, moves the
+     * conversation on to the reply and returns the reply's turn.
+     */
+    accept(reply: unknown): CuaTurn;
+}
+/** Which answer told the provider that the organization keeps no server-side conversation. */
+export type ZdrRejection = NonNullable<ActorConversation["rejection"]>;
+/**
+ * What a closing request asks for: the closing report after a harness-owned stop, or only
+ * impressions after the participant ended the session itself.
+ */
+export type ClosingRequest = "report" | "impressions";
+export declare class OpenAiConversation {
+    private readonly settings;
+    private lastResponseId;
+    /** computer_call ids the next request owes an output for. */
+    private pendingCallIds;
+    /** Accepted replies so far; the next request is number `replies + 1`. */
+    private replies;
+    /** The whole conversation, which explicit-context requests carry within its token budget. */
+    private readonly carried;
+    private mode;
+    /** Undefined once the account or model rejected reasoning summaries. */
+    private reasoningSummary;
+    private readonly evidence;
+    constructor(settings: OpenAiConversationSettings);
+    /**
+     * The next request, carrying `req`'s screen: the opening request, or the outputs the latest
+     * reply's computer calls are owed. A closing request asks for strict JSON and no tools.
+     */
+    request(req: CuaTurnRequest, closing?: ClosingRequest): ConversationRequest;
+    /**
+     * The organization rejected server-side state: carry the conversation on the client from the
+     * request being sent, and record which answer made the switch. False when the conversation is
+     * already carried, so the rejection stands.
+     */
+    switchToExplicitContext(rejection: ZdrRejection): boolean;
+    /**
+     * The account or model rejected reasoning summaries: stop asking for the rest of the session,
+     * from the request being sent. False when none are asked for, so the rejection stands.
+     */
+    dropReasoningSummaries(): boolean;
+    /**
+     * Whether the server holds the whole session, so a closing report threaded on it reads every
+     * turn. An explicit-context conversation summarizes its oldest turns past its budget, configured
+     * or switched to at runtime.
+     */
+    get serverHoldsSession(): boolean;
+    /** The trace's account of how the conversation was carried (ActorConversation). */
+    record(): ActorConversation;
+    /**
+     * The items a request adds to the conversation: the opening message with the first screen, or
+     * an output for each pending computer_call with the latest screenshot and any hint.
+     */
+    private newItems;
+    private context;
+    /**
+     * A participant request: the opening request, or a continuation carrying `sent`. A threaded
+     * continuation names the previous response; an explicit-context one carries the conversation
+     * ahead of `sent`.
+     */
+    private turnBody;
+    /** A read-only closing request: no tools, its own output limit, a strict schema. */
+    private closingBody;
+    /**
+     * Move the conversation on to a reply to a request that added `sent`. A participant reply cut
+     * off by the output limit is set aside, so the next request is the same one again
+     * (outputLimitRetry); its actions never run, so no call output is owed for them.
+     */
+    private accept;
+}

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

@@ -0,0 +1,238 @@
+import { PARTICIPANT_IMPRESSION_KINDS } from "../contract.js";
+import { CarriedConversation, estimateTokens } from "./openai-context.js";
+import { buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, openingMessage, parseOpenAiResponse, } from "./openai-wire.js";
+/**
+ * The closing request's output limit: its own cap, or the declared limit when that is lower. It
+ * 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,
+            },
+        },
+    },
+    impressions: {
+        type: "json_schema",
+        name: "participant_impressions",
+        strict: true,
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["impressions"],
+            properties: { impressions: IMPRESSIONS_SCHEMA },
+        },
+    },
+};
+export class OpenAiConversation {
+    settings;
+    lastResponseId;
+    /** computer_call ids the next request owes an output for. */
+    pendingCallIds = [];
+    /** Accepted replies so far; the next request is number `replies + 1`. */
+    replies = 0;
+    /** The whole conversation, which explicit-context requests carry within its token budget. */
+    carried = new CarriedConversation();
+    mode;
+    /** Undefined once the account or model rejected reasoning summaries. */
+    reasoningSummary;
+    evidence;
+    constructor(settings) {
+        this.settings = settings;
+        this.mode = settings.zeroDataRetention ? "explicit_context" : "threaded";
+        this.reasoningSummary = settings.reasoningSummary;
+        this.evidence = new ConversationRecord(settings.zeroDataRetention, settings.now);
+    }
+    /**
+     * The next request, carrying `req`'s screen: the opening request, or the outputs the latest
+     * reply's computer calls are owed. A closing request asks for strict JSON and no tools.
+     */
+    request(req, closing) {
+        const sent = this.newItems(req);
+        return {
+            body: () => closing === undefined ? this.turnBody(req, sent) : this.closingBody(req, sent, closing),
+            accept: (reply) => this.accept(reply, closing !== undefined, sent),
+        };
+    }
+    /**
+     * The organization rejected server-side state: carry the conversation on the client from the
+     * request being sent, and record which answer made the switch. False when the conversation is
+     * already carried, so the rejection stands.
+     */
+    switchToExplicitContext(rejection) {
+        if (this.mode === "explicit_context")
+            return false;
+        this.evidence.switched(rejection);
+        this.mode = "explicit_context";
+        return true;
+    }
+    /**
+     * The account or model rejected reasoning summaries: stop asking for the rest of the session,
+     * from the request being sent. False when none are asked for, so the rejection stands.
+     */
+    dropReasoningSummaries() {
+        if (this.reasoningSummary === undefined)
+            return false;
+        this.reasoningSummary = undefined;
+        return true;
+    }
+    /**
+     * Whether the server holds the whole session, so a closing report threaded on it reads every
+     * turn. An explicit-context conversation summarizes its oldest turns past its budget, configured
+     * or switched to at runtime.
+     */
+    get serverHoldsSession() {
+        return this.mode === "threaded" && this.lastResponseId !== undefined;
+    }
+    /** The trace's account of how the conversation was carried (ActorConversation). */
+    record() {
+        return this.evidence.snapshot(this.mode);
+    }
+    /**
+     * The items a request adds to the conversation: the opening message with the first screen, or
+     * an output for each pending computer_call with the latest screenshot and any hint.
+     */
+    newItems(req) {
+        if (this.replies === 0)
+            return [openingMessage(req.instructions, req.observation.screenshot)];
+        return [
+            ...this.pendingCallIds.map((id) => buildCallOutput(id, req.observation.screenshot, req.acknowledgedSafetyChecks)),
+            ...hintItems(req.contextHint),
+        ];
+    }
+    context(instructions) {
+        const { settings } = this;
+        return {
+            stateless: this.mode === "explicit_context",
+            model: settings.model,
+            instructions,
+            reasoningEffort: settings.reasoningEffort,
+            ...(settings.maxOutputTokens === undefined
+                ? {}
+                : { maxOutputTokens: settings.maxOutputTokens }),
+            ...(this.reasoningSummary === undefined ? {} : { reasoningSummary: this.reasoningSummary }),
+            ...(settings.safetyIdentifier === undefined
+                ? {}
+                : { safetyIdentifier: settings.safetyIdentifier }),
+        };
+    }
+    /**
+     * A participant request: the opening request, or a continuation carrying `sent`. A threaded
+     * continuation names the previous response; an explicit-context one carries the conversation
+     * ahead of `sent`.
+     */
+    turnBody(req, sent) {
+        const ctx = this.context(req.instructions);
+        if (this.replies === 0)
+            return buildInitialRequest(ctx, req.observation.screenshot);
+        return buildContinuationRequest({
+            ctx,
+            previousResponseId: this.lastResponseId,
+            callOutputs: [...sent],
+            ...(this.mode === "explicit_context" ? { explicitContextItems: this.carried.carried() } : {}),
+        });
+    }
+    /** A read-only closing request: no tools, its own output limit, a strict schema. */
+    closingBody(req, sent, closing) {
+        return {
+            ...this.turnBody(req, sent),
+            tool_choice: "none",
+            max_output_tokens: Math.min(this.settings.maxOutputTokens ?? CLOSING_OUTPUT_LIMIT, CLOSING_OUTPUT_LIMIT),
+            text: { format: CLOSING_FORMATS[closing] },
+        };
+    }
+    /**
+     * Move the conversation on to a reply to a request that added `sent`. A participant reply cut
+     * off by the output limit is set aside, so the next request is the same one again
+     * (outputLimitRetry); its actions never run, so no call output is owed for them.
+     */
+    accept(reply, closing, sent) {
+        // Recorded before the reply is accepted: accepting can cut the carried history, and the record
+        // counts what this request carried.
+        if (!closing)
+            this.evidence.requested(this.mode, this.carried, sent);
+        const parsed = parseOpenAiResponse(reply);
+        if (!closing && parsed.turn.interruption === "output_limit")
+            return parsed.turn;
+        if (parsed.turn.responseId !== undefined)
+            this.lastResponseId = parsed.turn.responseId;
+        this.pendingCallIds = parsed.callIds;
+        this.replies += 1;
+        this.carried.accept(this.replies, sent, parsed.outputItems);
+        return parsed.turn;
+    }
+}
+/** The trace's account of how a session carried its conversation (ActorConversation). */
+class ConversationRecord {
+    now;
+    explicitReason;
+    rejection;
+    switchedAt;
+    switchedAtRequest;
+    summarizedTurns = 0;
+    requests = [];
+    constructor(configured, now) {
+        this.now = now;
+        if (configured)
+            this.explicitReason = "configured";
+    }
+    /** The organization rejected server-side state, so the request being sent is explicit_context. */
+    switched(rejection) {
+        this.explicitReason = "zdr_rejection";
+        this.rejection = rejection;
+        this.switchedAt = new Date(this.now()).toISOString();
+        // Counted like requests[], which includes replies set aside at their output limit.
+        this.switchedAtRequest = this.requests.length + 1;
+    }
+    /** A participant request went out with `sent` after `conversation`. */
+    requested(mode, conversation, sent) {
+        if (mode !== "explicit_context") {
+            this.requests.push({ mode: "threaded" });
+            return;
+        }
+        const carried = conversation.size();
+        // Only summaries a request carried count; the conversation also trims after the last reply.
+        this.summarizedTurns = carried.notedTurns;
+        this.requests.push({
+            mode: "explicit_context",
+            carriedExchanges: carried.exchanges,
+            carriedScreenshots: carried.screenshots,
+            estimatedInputTokens: carried.estimatedTokens + estimateTokens(sent),
+        });
+    }
+    snapshot(mode) {
+        return {
+            mode,
+            ...(this.explicitReason === undefined ? {} : { explicitReason: this.explicitReason }),
+            ...(this.rejection === undefined ? {} : { rejection: this.rejection }),
+            ...(this.switchedAt === undefined ? {} : { switchedAt: this.switchedAt }),
+            ...(this.switchedAtRequest === undefined
+                ? {}
+                : { switchedAtRequest: this.switchedAtRequest }),
+            summarizedTurns: this.summarizedTurns,
+            requests: this.requests.map((request) => ({ ...request })),
+        };
+    }
+}

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

@@ -1,16 +1,16 @@
-import { validClosingReport } from "./loop.js";
+import { validClosingReport, validImpressionsReply } from "./loop.js";
 import { ComputerUseAdmissionLimitError, isComputerUseAdmissionLimitError, } from "./admission-limit.js";
 import { ComputerUsePromptRefusedError } from "./provider-error.js";
-import { CarriedConversation } from "./openai-context.js";
-import { acceptReply, ConversationRecord, debriefRequestBody, turnInputItems, turnRequestBody, } from "./openai-requests.js";
-import { asRecord, optionalString, parseOpenAiResponse, } from "./openai-wire.js";
+import { OpenAiConversation, } from "./openai-conversation.js";
+import { asRecord, optionalString } from "./openai-wire.js";
 import { redactText } from "../../evidence/redaction.js";
 import { isMaxOutputTokens } from "../output-token-limit.js";
 import { prepareContainedOutputFile, prepareSelectedOutputDirectory, writeContainedOutputFile, } from "../../run/contained-output.js";
 import { OPENAI_RESPONSES_URL } from "../openai-endpoint.js";
 // A public-safe re-derivation of the OpenAI Responses API computer-use provider,
 // behind the CuaProvider port from src/actors/computer-use/loop.ts. The pure wire mapping
-// (openAiActionToCua, parseOpenAiResponse and the request builders) is in openai-wire.ts.
+// (openAiActionToCua, parseOpenAiResponse and the request builders) is in openai-wire.ts, and
+// what each request carries, with the trace's record of it, is in openai-conversation.ts.
 // This module is the live shim: createOpenAiResponsesProvider does a raw POST to the
 // Responses endpoint (no SDK dependency) through an injectable FetchLike seam, so the retry,
 // ZDR fallback, and state threading are testable with a fake.
@@ -412,24 +412,17 @@ export function createOpenAiResponsesProvider(options) {
     // An unset or empty capture variable leaves capture off.
     const capture = createWireCapture(optionalString((options.env ?? process.env)[WIRE_CAPTURE_ENV]?.trim()));
     let interactionUsageIncomplete = false;
-    const settings = {
+    const conversation = new OpenAiConversation({
         model,
         reasoningEffort,
         ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
         ...(options.safetyIdentifier === undefined
             ? {}
             : { safetyIdentifier: options.safetyIdentifier }),
-    };
-    const state = {
-        lastResponseId: undefined,
-        pendingCallIds: [],
-        replies: 0,
-        conversation: new CarriedConversation(),
-        mode: options.zeroDataRetention ? "explicit_context" : "previous_response_id",
-        // Latches to undefined (stop asking) for the rest of the session when the
-        // account/model rejects the summary request; see OpenAiResponsesProviderOptions.
         reasoningSummary: options.reasoningSummary === "off" ? undefined : (options.reasoningSummary ?? "auto"),
-    };
+        zeroDataRetention: options.zeroDataRetention === true,
+        now: options.now ?? Date.now,
+    });
     const transport = {
         endpoint: options.endpoint ?? OPENAI_RESPONSES_URL,
         apiKey: options.apiKey,
@@ -441,56 +434,52 @@ export function createOpenAiResponsesProvider(options) {
         },
     };
     const post = (body, signal, retries = maxRetries, interaction = true, spend) => postResponse(transport, body, signal, retries, interaction, spend);
-    const record = new ConversationRecord(options.zeroDataRetention === true, options.now ?? Date.now);
     // POST with the recoverable-policy latches: a ZDR rejection switches to explicit-context mode; a
     // reasoning-summary rejection latches summaries off. Each latch can flip only once, so the loop
     // is bounded; anything else rethrows. The body is rebuilt per attempt so a flipped latch shows.
-    const postTurn = async (req, sent, signal, spend) => {
+    const postTurn = async (request, signal, spend) => {
         if (options.singleDispatch === true)
-            return post(turnRequestBody(settings, state, req, sent), signal, 0);
+            return post(request.body(), signal, 0);
         for (;;) {
             try {
-                return await post(turnRequestBody(settings, state, req, sent), signal, maxRetries, true, spend);
+                return await post(request.body(), signal, maxRetries, true, spend);
             }
             catch (error) {
-                if (error instanceof SummaryRejectionError && state.reasoningSummary !== undefined) {
-                    state.reasoningSummary = undefined;
+                if (error instanceof SummaryRejectionError && conversation.dropReasoningSummaries()) {
                     continue;
                 }
-                if (error instanceof ZdrError && state.mode !== "explicit_context") {
-                    record.switched(error.rejection);
-                    state.mode = "explicit_context";
+                if (error instanceof ZdrError && conversation.switchToExplicitContext(error.rejection)) {
                     continue;
                 }
                 throw error;
             }
         }
     };
-    const requestTurn = async (req, signal, closing = false, spend) => {
+    const requestTurn = async (req, signal, closing, spend) => {
         await capture.prepareNext();
-        const sent = turnInputItems(state, req);
-        // A closing report makes exactly one request: no HTTP or policy-latch retries.
-        const raw = closing
-            ? await post(debriefRequestBody(settings, state, req, sent), signal, 0, false)
-            : await postTurn(req, sent, signal, spend);
-        if (!closing)
-            record.requested(state, sent);
-        const parsed = parseOpenAiResponse(raw);
-        acceptReply(state, parsed, closing, sent);
-        if (closing) {
+        const request = conversation.request(req, closing);
+        // A closing request makes exactly one request: no HTTP or policy-latch retries.
+        const raw = closing === undefined
+            ? await postTurn(request, signal, spend)
+            : await post(request.body(), signal, 0, false);
+        const turn = request.accept(raw);
+        if (closing !== undefined) {
             // Refusals, incomplete output, malformed JSON, and invalid shapes remain no-report results.
             // Never promote raw JSON or a fallback paragraph into a structured finding.
             try {
-                const report = JSON.parse(parsed.turn.message ?? "");
-                if (asRecord(raw).status === "completed" && validClosingReport(report)) {
-                    return { ...parsed.turn, closingReport: report };
+                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 };
                 }
             }
             catch {
                 /* A failed optional closing account keeps its usage and no report. */
             }
         }
-        return parsed.turn;
+        return turn;
     };
     return {
         id: "openai-responses-cu",
@@ -510,17 +499,18 @@ export function createOpenAiResponsesProvider(options) {
         get interactionUsageIncomplete() {
             return interactionUsageIncomplete;
         },
-        nextTurn: (req, signal, spend) => requestTurn(req, signal, false, spend),
+        nextTurn: (req, signal, spend) => requestTurn(req, signal, undefined, spend),
         get conversation() {
-            return record.snapshot(state);
+            return conversation.record();
         },
-        // An explicit-context conversation summarizes its oldest turns past its budget, so it may not
-        // hold the whole session a retrospective report needs. This getter follows both configured
-        // ZDR and a runtime policy latch.
+        // A retrospective report reads the session the server holds; see serverHoldsSession.
         get debrief() {
-            return state.mode === "explicit_context" || state.lastResponseId === undefined
-                ? undefined
-                : (req, signal) => requestTurn(req, signal, true);
+            return conversation.serverHoldsSession
+                ? (req, signal) => requestTurn(req, signal, "report")
+                : undefined;
         },
+        // Offered in both modes. An explicit_context conversation carries its newest screens whole and
+        // earlier turns as text, which serves impressions; a closing report needs the whole session.
+        requestImpressions: (req, signal) => requestTurn(req, signal, "impressions"),
     };
 }

package/dist/actors/contract.d.ts

@@ -186,11 +186,43 @@ export declare function validActorProviderRequests(value: unknown): value is Act
 export interface ParticipantClosingReport {
     summary: string;
     frictionReports: string[];
+    /** Absent when the provider did not ask for impressions; empty when the participant had none. */
+    impressions?: ParticipantImpression[];
 }
+/**
+ * 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.
+ */
+export declare const PARTICIPANT_IMPRESSION_KINDS: readonly ["unclear", "unfinished", "untrustworthy", "liked", "missing", "unlike_my_work"];
+type ParticipantImpressionKind = (typeof PARTICIPANT_IMPRESSION_KINDS)[number];
+/** One first-person impression about something the participant saw in the session. */
+export interface ParticipantImpression {
+    kind: ParticipantImpressionKind;
+    text: string;
+}
+/** An impression as the trace keeps it, with the message that quotes it. */
+interface RecordedImpression extends ParticipantImpression {
+    /** The trace message carrying the impression, which the analysis quotes and cites. */
+    messageId: string;
+}
+/**
+ * The impressions a session collected, or why it collected none. An empty `items` list means the
+ * participant had none to give.
+ */
+export type ParticipantImpressions = {
+    status: "collected";
+    items: RecordedImpression[];
+} | {
+    status: "not_collected";
+    reason: string;
+};
 /** Runtime declarations and executable-version observations; not provider request attestation. */
 export interface ActorRuntimeProvenance {
     schema: "humanish.actor-runtime.v1";
     package: string;
+    /** Terminal command telemetry opt-out; absent in older bundles. */
+    doNotTrack?: boolean;
     requestedVersion: string;
     observedVersion?: string;
     versionStatus: "unobserved" | "verified" | "failed";
@@ -313,17 +345,27 @@ export interface ActorTrace {
      * each fixed a false refusal and each left the next shape unhandled.
      */
     declaredOutcome?: ParticipantDeclaredOutcome;
-    /** Closing report after a harness-owned stop. Does not change task outcomes or permit actions. */
+    /**
+     * The read-only closing request: a closing report after a harness-owned stop (`stop_when`,
+     * `dwell`), or impressions only after the participant ended the session itself
+     * (`participant_end`, never with `report`). Does not change task outcomes or permit actions.
+     */
     debrief?: {
-        trigger: "stop_when" | "dwell";
+        trigger: "stop_when" | "dwell" | "participant_end";
         status: "completed" | "skipped" | "failed";
         reason: string;
         /** Absent if no request was made; false means token accounting is incomplete. */
         usageReported?: boolean;
-        report?: ParticipantClosingReport;
+        /** The report's impressions are kept in `impressions`, with the messages that quote them. */
+        report?: Omit<ParticipantClosingReport, "impressions">;
         /** Links the readable projection so it is not heuristically classified a second time. */
         messageId?: string;
     };
+    /**
+     * What the participant said about the product at the end of a computer-use session, or why
+     * nothing was collected. Absent on other routes and on older traces.
+     */
+    impressions?: ParticipantImpressions;
     items: ActorTraceItem[];
     tokenUsage?: ActorTokenUsage;
     /** A stalled or adapter-reported ambiguous interaction may have additional unreported usage.

package/dist/actors/contract.js

@@ -168,6 +168,19 @@ export function validActorProviderRequests(value) {
                     usage.input));
     });
 }
+/**
+ * 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.
+ */
+export const PARTICIPANT_IMPRESSION_KINDS = [
+    "unclear",
+    "unfinished",
+    "untrustworthy",
+    "liked",
+    "missing",
+    "unlike_my_work",
+];
 export const CODEX_APP_SERVER_CAPABILITIES = {
     headless: true,
     structuredTrace: true,

package/dist/analysis/diagnostics.js

@@ -1,9 +1,8 @@
 import { lstat, readdir, rmdir, unlink } from "node:fs/promises";
 import path from "node:path";
-import { decodeEscapes } from "../evidence/encoded-text.js";
 import { redactText } from "../evidence/redaction.js";
 import { assertPreparedSelectedOutputDirectory, assertSafeOutputPathSegment, bindExistingManagedHumanishOutputDirectory, prepareManagedHumanishOutputDirectory, writeContainedOutputFile, } from "../run/contained-output.js";
-import { scrubTransientCommsText, transientCommsEncodedScrub, } from "../run/transient-comms-secrets.js";
+import { transientCommsKnownValueScrub } from "../run/transient-comms-secrets.js";
 import { ANALYSIS_ID_PATTERN } from "./types.js";
 // A rejected analyst response is kept for diagnosis under .humanish/analysis-diagnostics/<run>/,
 // outside every run directory. Export, verify and the Observer read run directories only, so the
@@ -14,19 +13,15 @@ const ANALYSIS_DIAGNOSTIC_SCHEMA = "humanish.analysis-rejected-output.v1";
 /** How many rejected outputs are kept across all runs; older ones are removed on each write. */
 export const MAX_ANALYSIS_DIAGNOSTICS = 20;
 const REDACTED = "[REDACTED_SECRET]";
-const markers = (text) => text.split(REDACTED).length - 1;
 /**
- * Scrub every string, key and scalar in the output. The encoded scrub finds a known value written
- * percent-encoded, escaped or base64-encoded and returns decoded text; a string where it finds
- * nothing keeps its original spelling, so an escape in a rejected quote stays visible, and still
- * gets the literal scrub. A number or boolean equal to a known value becomes the marker.
+ * Scrub every string, key and scalar in the output. The known-value scrub finds a value written
+ * percent-encoded, escaped or base64-encoded; a string where it finds nothing keeps its original
+ * spelling, so an escape in a rejected quote stays visible. A number or boolean equal to a known
+ * value becomes the marker.
  */
 function scrubber() {
-    const encoded = transientCommsEncodedScrub();
-    const text = (value) => {
-        const found = encoded(value);
-        return redactText(markers(found) > markers(decodeEscapes(value)) ? found : scrubTransientCommsText(value));
-    };
+    const known = transientCommsKnownValueScrub();
+    const text = (value) => redactText(known(value));
     const scrub = (value) => {
         if (typeof value === "string")
             return text(value);

package/dist/analysis/evidence-sources.d.ts

@@ -20,4 +20,6 @@ export interface SourceEntry {
 export declare function sourceEntries(bundle: RunBundle, stream: RunStream, captureVersion?: CaptureVersion): SourceEntry[];
 /** Max-min allocation; stable ID order breaks a remainder tie by at most one slot. */
 export declare function fairShares(budget: number, capacities: number[]): number[];
-export declare function sourceOrder(entries: SourceEntry[], capturesOnly: boolean): SourceEntry[];
+/** The trace messages that carry a participant's closing impressions. */
+export declare function impressionEventIds(stream: RunStream): ReadonlySet<string>;
+export declare function sourceOrder(entries: SourceEntry[], capturesOnly: boolean, impressions?: ReadonlySet<string>): SourceEntry[];

package/dist/analysis/evidence-sources.js

@@ -204,7 +204,12 @@ function spreadOrder(entries) {
     }
     return result;
 }
-export function sourceOrder(entries, capturesOnly) {
+/** The trace messages that carry a participant's closing impressions. */
+export function impressionEventIds(stream) {
+    const impressions = stream.actor?.impressions;
+    return new Set(impressions?.status === "collected" ? impressions.items.map((item) => item.messageId) : []);
+}
+export function sourceOrder(entries, capturesOnly, impressions = new Set()) {
     const candidates = capturesOnly ? entries.filter((entry) => entry.capturePath !== null) : entries;
     const ordered = new Set();
     const admit = (entry) => {
@@ -214,6 +219,10 @@ export function sourceOrder(entries, capturesOnly) {
     // Actor endings precede appended run bookkeeping when text slots are scarce.
     if (!capturesOnly)
         admit(entries.findLast((entry) => !entry.kind.startsWith("run_event:")));
+    // The participant's closing impressions are its only opinions of the product; keep them all.
+    for (const entry of entries)
+        if (impressions.has(entry.eventId))
+            admit(entry);
     admit(candidates.at(-1));
     admit(candidates[0]);
     const afterCapture = [];