humanish 0.131.1 → 0.132.0

package/CHANGELOG.md

@@ -8,6 +8,18 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.132.0: An OpenAI participant's closing report reads the prompt cache (2026-10-13)
+
+humanish 0.132.0 cuts the cost of an OpenAI computer-use participant's closing report. The closing
+report and impressions requests set `text.format`, which is part of the prompt cache's prefix, so
+each one was billed as a fresh write of the whole session: 25% to 42% of a run's model spend in the
+8 runs measured on 0.131.0. They now send the schema in their input instead and read the session
+from the cache. In two live 12-minute runs the closing request cost $0.026 and $0.025 where it
+would have cost $0.14. A reply that does not match the schema is asked once more with the strict
+schema, after the same budget and time checks.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.132.0)
+
 ## 0.131.1: Hosted desktops keep their screens on while participants wait (2026-10-13)
 
 humanish 0.131.1 keeps a hosted desktop's screen on while a participant waits without input.

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

@@ -86,36 +86,68 @@ function planDebrief(session, ask, trigger) {
     }
     return { send, boundMs };
 }
-async function debriefExchange(session, context, trigger, ask, { send, boundMs }, record) {
+async function debriefExchange(session, context, trigger, ask, plan, record) {
+    const { provider } = session;
+    const request = {
+        instructions: session.settings.instructions,
+        observation: trigger.observation,
+        ...(provider.requestPolicy !== "fail_closed" || context.previousExecution === undefined
+            ? {}
+            : { previousExecution: context.previousExecution }),
+        ...(context.previousResponseId === undefined
+            ? {}
+            : { previousResponseId: context.previousResponseId }),
+        ...(context.acknowledgedSafetyChecks === undefined
+            ? {}
+            : { acknowledgedSafetyChecks: context.acknowledgedSafetyChecks }),
+        contextHint: ask.contextHint,
+    };
+    const first = await sendClosing(session, ask, request, plan);
+    if (!("turn" in first)) {
+        return first.status === "skipped"
+            ? record("skipped", `${first.detail}; no closing request was sent`)
+            : record("failed", first.detail, first.usageReported);
+    }
+    if (first.turn.closingRetry !== true)
+        return acceptDebriefTurn(session, first.turn, trigger, ask, record, first.usageReported);
+    // The first reply's usage is already recorded, so the checks see it. Under a cap, a reply
+    // without complete usage stops another paid request, as it does after a participant turn.
+    const again = session.capDeclared && !first.usageReported
+        ? {
+            skip: "the closing request did not report complete usage, so the remaining model budget is unknown",
+        }
+        : planDebrief(session, ask, trigger);
+    const second = "skip" in again
+        ? { status: "skipped", detail: again.skip }
+        : await sendClosing(session, ask, request, again);
+    if ("turn" in second) {
+        const usageReported = first.usageReported && second.usageReported;
+        return acceptDebriefTurn(session, second.turn, trigger, ask, record, usageReported, "; asked twice: the first reply was not the JSON the request asked for");
+    }
+    // The first reply stands, with why no second one replaced it.
+    const skipped = second.status === "skipped";
+    return acceptDebriefTurn(session, first.turn, trigger, ask, record, first.usageReported && (skipped || second.usageReported), `; ${skipped ? "not asked again" : "asked once more"}: ${second.detail}`);
+}
+/** Send one closing request within its time bound, and record the usage its reply reports. */
+async function sendClosing(session, ask, request, { send, boundMs }) {
     const { signal, provider } = session;
     const scope = requestScope(signal);
     const timer = setTimeout(() => scope.end(), boundMs);
     timer.unref?.();
     session.trace.bump("debriefCalls");
     try {
-        const request = {
-            instructions: session.settings.instructions,
-            observation: trigger.observation,
-            ...(provider.requestPolicy !== "fail_closed" || context.previousExecution === undefined
-                ? {}
-                : { previousExecution: context.previousExecution }),
-            ...(context.previousResponseId === undefined
-                ? {}
-                : { previousResponseId: context.previousResponseId }),
-            ...(context.acknowledgedSafetyChecks === undefined
-                ? {}
-                : { acknowledgedSafetyChecks: context.acknowledgedSafetyChecks }),
-            contextHint: ask.contextHint,
-        };
         const turn = provider.requestPolicy === "fail_closed"
             ? await singleDispatch(session, "debrief", (dispatchSignal) => send(request, dispatchSignal), boundMs)
             : await raceSessionDeadline(send(request, scope.signal), boundMs, signal);
-        return acceptDebriefTurn(session, turn, trigger, ask, record);
+        return { turn, usageReported: recordClosingUsage(session, turn) };
     }
     catch (error) {
         // A failed optional report cannot rewrite the already observed structured completion.
         if (isComputerUseAdmissionLimitError(error)) {
-            return record("skipped", "the adapter reported a local admission limit before provider dispatch; no closing request was sent");
+            return {
+                status: "skipped",
+                detail: "the adapter reported a local admission limit before provider dispatch",
+            };
         }
         const detail = signal?.aborted
             ? "cancelled"
@@ -126,14 +158,19 @@ async function debriefExchange(session, context, trigger, ask, { send, boundMs }
                     : String(error);
         const debriefReceipt = provider.requestPolicy === "fail_closed" ? session.usage.requests.at(-1) : undefined;
         const usageReported = debriefReceipt?.usageComplete === true && isCompleteTurnUsage(debriefReceipt.usage);
-        return record("failed", `${detail}; closing request usage is ${usageReported ? "reported" : "unreported"}`, usageReported);
+        return {
+            status: "failed",
+            detail: `${detail}; closing request usage is ${usageReported ? "reported" : "unreported"}`,
+            usageReported,
+        };
     }
     finally {
         clearTimeout(timer);
         scope.end();
     }
 }
-function acceptDebriefTurn(session, turn, trigger, ask, record) {
+/** Record a closing reply's usage, and say whether it was complete. */
+function recordClosingUsage(session, turn) {
     const { maxUsd, overRunBudget, estimateTurnCostUsd } = session.settings;
     session.usage.record(turn, "debrief");
     session.lastResponseId = turn.responseId ?? session.lastResponseId;
@@ -144,13 +181,16 @@ function acceptDebriefTurn(session, turn, trigger, ask, record) {
         (maxUsd !== undefined && finalEstimate != null && finalEstimate > maxUsd)) {
         session.trace.record("notice", () => notice("warn", "model budget reached during closing report", "The closing request crossed an estimated budget; no further requests or actions followed. Task completion is unchanged."));
     }
-    const usageReported = isCompleteTurnUsage(turn.usage) && turn.providerRequest?.usageComplete !== false;
+    return isCompleteTurnUsage(turn.usage) && turn.providerRequest?.usageComplete !== false;
+}
+/** Accept a closing reply as the debrief's result; `note` adds why no later reply replaced it. */
+function acceptDebriefTurn(session, turn, trigger, ask, record, usageReported, note = "") {
     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);
+        return record("failed", `the closing response requested actions or safety checks; none were executed and its report was not accepted${note}`, usageReported);
     }
     // First-party providers parse their replies already; these parses cover third-party ports.
     const { status, detail, ...added } = ask.read(session, turn, trigger);
-    return { ...record(status, detail, usageReported), ...added };
+    return { ...record(status, `${detail}${note}`, usageReported), ...added };
 }
 /**
  * A closing report: its summary and friction as one participant message, then its impressions.
@@ -205,6 +245,6 @@ function readImpressions(session, turn) {
     session.impressions = recordImpressions(session, impressions.data);
     return {
         status: "completed",
-        detail: "one read-only impressions request; no additional desktop actions; the participant's own ending is unchanged",
+        detail: "a read-only impressions request; no additional desktop actions; the participant's own ending is unchanged",
     };
 }

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

@@ -203,6 +203,12 @@ export interface CuaTurn {
     closingReport?: ParticipantClosingReport;
     /** Present only for an accepted impressions-only closing reply. */
     impressions?: ParticipantImpression[];
+    /**
+     * Set on a closing reply that was not the JSON its request asked for, when the provider's next
+     * closing request would ask for it more strictly. The loop may then call the same closing method
+     * once more, after the checks the first request passed and with a time bound of its own.
+     */
+    closingRetry?: true;
 }
 /** The model side of the loop. Self-describes its identity and capabilities. */
 export interface CuaProvider {
@@ -246,7 +252,10 @@ export interface CuaProvider {
     /** Latest known usage of the continuing request. Used only for runtime spend guards. */
     readonly pendingRequestUsage?: CuaTurn["usage"];
     nextTurn(req: CuaTurnRequest, signal: AbortSignal, spend?: CuaSpendGate): Promise<CuaTurn>;
-    /** Optional read-only closing report. Implementations must disable tools and make no retries. */
+    /**
+     * Optional read-only closing report. Implementations must disable tools and send one request per
+     * call, with no retries of their own; a second request is the loop's call (`closingRetry`).
+     */
     debrief?: ((req: CuaTurnRequest, signal: AbortSignal) => Promise<CuaTurn>) | undefined;
     /**
      * Optional read-only request for impressions only, after the participant ended the session

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

@@ -48,12 +48,22 @@ export declare class OpenAiConversation {
     /** Undefined once the account or model rejected reasoning summaries. */
     private reasoningSummary;
     private readonly evidence;
+    /** The items of a closing request whose reply was not the stated JSON, for its strict retry. */
+    private openClosing;
     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.
+     * The next participant turn's request, carrying `req`'s screen: the opening request, or the
+     * outputs the latest reply's computer calls are owed.
      */
-    request(req: CuaTurnRequest, closing?: ClosingRequest): ConversationRequest;
+    request(req: CuaTurnRequest): ConversationRequest;
+    /**
+     * The read-only closing request carrying `req`'s screen, sent once with `send`. It goes out
+     * without text.format, which is part of the cached prefix, so it reads the session from the
+     * cache. A completed reply that is not JSON the schema accepts comes back marked closingRetry and
+     * leaves the conversation where it was, so the next closing request is the same one with the
+     * strict schema set. Returns the reply's turn with the account it gave.
+     */
+    close(req: CuaTurnRequest, closing: ClosingRequest, send: (body: Record<string, unknown>) => Promise<unknown>): Promise<CuaTurn>;
     /**
      * 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
@@ -79,12 +89,17 @@ export declare class OpenAiConversation {
      * ahead of `sent`.
      */
     private turnBody;
-    /** A read-only closing request: no tools, its own output limit, a strict schema. */
+    /**
+     * A read-only closing request: the next turn's body with tools off and its own output limit,
+     * and the strict schema only when `schema` is set.
+     */
     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.
+     * A participant turn's reply to a request that added `sent`. A 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;
+    /** Move the conversation on to a reply to a request that added `sent`. */
+    private moveOn;
 }

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

@@ -1,6 +1,6 @@
 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";
+import { asArray, asRecord, buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, inputMessage, 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.
@@ -33,6 +33,8 @@ export class OpenAiConversation {
     /** Undefined once the account or model rejected reasoning summaries. */
     reasoningSummary;
     evidence;
+    /** The items of a closing request whose reply was not the stated JSON, for its strict retry. */
+    openClosing;
     constructor(settings) {
         this.settings = settings;
         this.mode = settings.zeroDataRetention ? "explicit_context" : "threaded";
@@ -40,16 +42,44 @@ export class OpenAiConversation {
         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.
+     * The next participant turn's request, carrying `req`'s screen: the opening request, or the
+     * outputs the latest reply's computer calls are owed.
      */
-    request(req, closing) {
+    request(req) {
         const sent = this.newItems(req);
         return {
-            body: () => closing === undefined ? this.turnBody(req, sent) : this.closingBody(req, sent, closing),
-            accept: (reply) => this.accept(reply, closing, sent),
+            body: () => this.turnBody(req, sent),
+            accept: (reply) => this.accept(reply, sent),
         };
     }
+    /**
+     * The read-only closing request carrying `req`'s screen, sent once with `send`. It goes out
+     * without text.format, which is part of the cached prefix, so it reads the session from the
+     * cache. A completed reply that is not JSON the schema accepts comes back marked closingRetry and
+     * leaves the conversation where it was, so the next closing request is the same one with the
+     * strict schema set. Returns the reply's turn with the account it gave.
+     */
+    async close(req, closing, send) {
+        const strict = this.openClosing !== undefined;
+        // Before any accepted reply the request is the opening one, which carries no hint of its own.
+        const ask = this.replies === 0 ? hintItems(req.contextHint) : [];
+        const sent = this.openClosing ?? [...this.newItems(req), ...ask, replyForm(closing)];
+        this.openClosing = undefined;
+        const reply = await send(this.closingBody(req, sent, closing, strict));
+        // Recorded before the reply is accepted, as a participant turn is.
+        if (closing === "impressions")
+            this.evidence.requested(this.mode, this.carried, sent, closing);
+        const completed = asRecord(reply).status === "completed";
+        const parsed = parseOpenAiResponse(reply);
+        const account = completed ? closingAccount(parsed.turn.message, closing, strict) : undefined;
+        // A refusal would most likely stand under the strict schema too, so it is not asked again.
+        if (completed && account === undefined && !strict && !refused(reply)) {
+            this.openClosing = sent;
+            return { ...parsed.turn, closingRetry: true };
+        }
+        this.moveOn(parsed, sent);
+        return { ...parsed.turn, ...account };
+    }
     /**
      * 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
@@ -111,8 +141,9 @@ export class OpenAiConversation {
      */
     turnBody(req, sent) {
         const ctx = this.context(req.instructions);
+        // `sent` is the opening message, and on a closing request also the ask and the reply's form.
         if (this.replies === 0)
-            return buildInitialRequest(ctx, req.observation.screenshot);
+            return { ...buildInitialRequest(ctx, req.observation.screenshot), input: [...sent] };
         return buildContinuationRequest({
             ctx,
             previousResponseId: this.lastResponseId,
@@ -120,36 +151,76 @@ export class OpenAiConversation {
             ...(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) {
+    /**
+     * A read-only closing request: the next turn's body with tools off and its own output limit,
+     * and the strict schema only when `schema` is set.
+     */
+    closingBody(req, sent, closing, schema) {
         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] },
+            ...(schema ? { 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.
+     * A participant turn's reply to a request that added `sent`. A 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) {
+    accept(reply, sent) {
         // Recorded before the reply is accepted: accepting can cut the carried history, and the record
         // counts what this request carried.
-        if (closing !== "report")
-            this.evidence.requested(this.mode, this.carried, sent, closing);
+        this.evidence.requested(this.mode, this.carried, sent);
         const parsed = parseOpenAiResponse(reply);
-        if (closing === undefined && parsed.turn.interruption === "output_limit")
+        if (parsed.turn.interruption === "output_limit")
             return parsed.turn;
+        this.moveOn(parsed, sent);
+        return parsed.turn;
+    }
+    /** Move the conversation on to a reply to a request that added `sent`. */
+    moveOn(parsed, sent) {
         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;
     }
 }
+/**
+ * What form a closing reply takes, said in the request itself because text.format would rewrite
+ * the cached prefix: the schema the strict retry sets.
+ */
+function replyForm(closing) {
+    const text = `Reply with only a JSON object that matches this JSON Schema, with no other text: ${JSON.stringify(CLOSING_FORMATS[closing].schema)}`;
+    return inputMessage("user", [{ type: "input_text", text }]);
+}
+/**
+ * The account a closing reply's text gives: JSON the request's schema accepts, or none. A reply
+ * sent without text.format must give every field the stated schema requires. With text.format the
+ * provider holds the reply to that schema, and the check is the one any provider's report gets.
+ */
+function closingAccount(message, closing, strict) {
+    // Without text.format a model may set the object in a code fence or after a message of its own.
+    const text = message ?? "";
+    let reply;
+    try {
+        reply = JSON.parse(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1));
+    }
+    catch {
+        return undefined;
+    }
+    if (closing === "report") {
+        const report = (strict ? closingReportSchema : closingReportSchema.required()).safeParse(reply);
+        return report.success ? { closingReport: report.data } : undefined;
+    }
+    const impressions = impressionsReplySchema.safeParse(reply);
+    return impressions.success ? { impressions: impressions.data.impressions } : undefined;
+}
+/** Whether a reply's messages include a refusal, which carries no output_text. */
+function refused(reply) {
+    return asArray(asRecord(reply).output).some((item) => asArray(asRecord(item).content).some((part) => asRecord(part).type === "refusal"));
+}
 /** The trace's account of how a session carried its conversation (ActorConversation). */
 class ConversationRecord {
     now;

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

@@ -1,8 +1,7 @@
-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";
-import { asRecord, optionalString } from "./openai-wire.js";
+import { 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";
@@ -455,38 +454,15 @@ export function createOpenAiResponsesProvider(options) {
             }
         }
     };
-    const requestTurn = async (req, signal, closing, spend) => {
+    const requestTurn = async (req, signal, spend) => {
         await capture.prepareNext();
-        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 reply = JSON.parse(turn.message ?? "");
-                if (asRecord(raw).status === "completed") {
-                    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 {
-                /* A failed optional closing account keeps its usage and no report. */
-            }
-        }
-        return turn;
+        const request = conversation.request(req);
+        return request.accept(await postTurn(request, signal, spend));
     };
+    // Each closing request is posted once: no HTTP or policy-latch retries. A reply with no valid
+    // account keeps its usage and gives no report: refusals, incomplete output, malformed JSON and
+    // invalid shapes are never promoted into a structured finding.
+    const requestClosing = (req, signal, closing) => conversation.close(req, closing, (body) => post(body, signal, 0, false));
     return {
         id: "openai-responses-cu",
         version: model,
@@ -505,7 +481,7 @@ export function createOpenAiResponsesProvider(options) {
         get interactionUsageIncomplete() {
             return interactionUsageIncomplete;
         },
-        nextTurn: (req, signal, spend) => requestTurn(req, signal, undefined, spend),
+        nextTurn: (req, signal, spend) => requestTurn(req, signal, spend),
         get conversation() {
             return conversation.record();
         },
@@ -513,7 +489,7 @@ export function createOpenAiResponsesProvider(options) {
         // explicit_context one carries its newest screens whole and its oldest turns summarized past
         // the budget, which the trace's conversation record counts. A participant that worked a long
         // session writes its closing account from what it carries, as a person writes one from memory.
-        debrief: (req, signal) => requestTurn(req, signal, "report"),
-        requestImpressions: (req, signal) => requestTurn(req, signal, "impressions"),
+        debrief: (req, signal) => requestClosing(req, signal, "report"),
+        requestImpressions: (req, signal) => requestClosing(req, signal, "impressions"),
     };
 }

package/docs/architecture/actor-contract.md

@@ -387,9 +387,14 @@ request), without provider support, or without remaining time and known budget.
 unreported usage remains an unknown cost line. `counts.debriefCalls` is separate
 from interaction turns, and reported usage contributes to aggregate cost.
 
-The OpenAI implementation makes one request with tools disabled and structured
-output; no HTTP or policy retries. Its output limit is 3072 tokens, or the declared
-`maxOutputTokens` when lower. Stateless/ZDR mode does not offer retrospective
+The OpenAI implementation sends each closing request with tools disabled and no HTTP or
+policy retries. The request sends no `text.format`, so it reads the session from the prompt
+cache, and states the JSON Schema in its input. The reply's JSON object is read from its text,
+also from inside a code fence or after a message of its own. A completed reply with no JSON that
+schema accepts, apart from a refusal, comes back with `closingRetry` set. The loop may then call
+the same method once more, after the checks the first request passed and with a time bound of
+its own, and that request sets the strict schema. `counts.debriefCalls` counts each request. Its
+output limit is 3072 tokens, or the declared `maxOutputTokens` when lower. Stateless/ZDR mode does not offer retrospective
 reporting: its client-carried conversation summarizes its oldest turns past a token
 budget, so it may not hold the whole session a retrospective report needs. It does offer
 the impressions-only request, which reads the carried conversation: its newest

package/docs/contracts/schemas.md

@@ -1199,7 +1199,14 @@ Core-owned fields:
   `estimatedInputTokens`. The impressions-only request has `kind: impressions`;
   the optional `kind` field is absent on participant turns and in older bundles.
   Impressions carry the context the next turn would carry, with the same budget
-  and summarization of older turns. Billed input per request is in `tokenUsage.turns`. A
+  and summarization of older turns. The closing report and impressions requests
+  send no `text.format`, so they can read the session from the prompt cache; the
+  request states the JSON Schema in its input instead. A completed reply with no
+  JSON the schema accepts, apart from a refusal, can be sent once more with the
+  strict schema, only after the budget and time checks the first passed and with
+  a time bound of its own. An impressions request sent twice has two entries. The
+  closing report has no entry here. Each closing request that reported usage has
+  its own row in `tokenUsage.turns` after the participant's requests. Billed input per request is in `tokenUsage.turns`. A
   participant that ran in `explicit_context` gets a run warning. Absent on other
   providers and on earlier bundles
 - optional `affordanceUse` (`humanish.affordance-use.v1`): which kind of route this

package/package.json

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