humanish 0.111.4 → 0.112.0

package/dist/verify/liveness.d.ts

@@ -14,8 +14,8 @@ export interface UnfinishedRun {
 }
 /**
  * One warning, and the unfinished-run facts, when the run is not finished, by the run index's
- * rule: its status record when it has a usable one, else a participant still `running` in its
- * bundle's `simulations[]`. Nothing for a finished run.
+ * rule: its bundle outcome first, then usable status, then the bundle's simulations. Nothing
+ * for a finished run.
  */
 export declare function runNotFinished(runPaths: PreparedRunArtifactPaths, bundle: RunBundle, nowMs?: number): Promise<{
     warnings: string[];

package/dist/verify/liveness.js

@@ -7,7 +7,7 @@ import path from "node:path";
 import { readRunJsonIfExists, readRunTextIfExists } from "../run/locate.js";
 import { isRecord } from "../run/type-guards.js";
 import { RECLAIM_RECEIPT_ARTIFACT } from "../run/reclaim.js";
-import { runLiveness } from "../run/run-index.js";
+import { runLiveness } from "../run/liveness.js";
 import { parseSandboxReceipts, SANDBOX_RECEIPTS_ARTIFACT } from "../run/sandbox-receipts.js";
 import { RUN_STATUS_FILE } from "../run/status.js";
 import { plural } from "../run/text.js";
@@ -17,8 +17,8 @@ const RUN_NOT_FINISHED = "RUN_NOT_FINISHED";
 const GONE_STATES = new Set(["killed", "already-gone"]);
 /**
  * One warning, and the unfinished-run facts, when the run is not finished, by the run index's
- * rule: its status record when it has a usable one, else a participant still `running` in its
- * bundle's `simulations[]`. Nothing for a finished run.
+ * rule: its bundle outcome first, then usable status, then the bundle's simulations. Nothing
+ * for a finished run.
  */
 export async function runNotFinished(runPaths, bundle, nowMs = Date.now()) {
     const runId = path.basename(runPaths.absoluteRunRoot);
@@ -27,7 +27,10 @@ export async function runNotFinished(runPaths, bundle, nowMs = Date.now()) {
     if (liveness === "finished")
         return { warnings: [] };
     const seen = [];
-    if (record === undefined) {
+    if (bundle.outcome?.state === "interrupted") {
+        seen.push(`run.json records interruption by ${bundle.outcome.signal} at ${bundle.outcome.at}`);
+    }
+    else if (record === undefined) {
         const running = bundle.simulations.filter((simulation) => simulation.status === "running");
         seen.push(`the run has no usable ${RUN_STATUS_FILE} and ${running.length} of ${bundle.simulations.length} simulations are still running`);
     }

package/docs/architecture/terminal-product-route.md

@@ -84,6 +84,20 @@ at the base tier, with cached input at the cached rate, and says so with
 checked against `caps.maxUsd` keeps the provider line unmeasured, and the studied
 product's no-spend boundary still needs separate interpretation.
 
+## Participant telemetry
+
+Terminal participant commands and product setup receive `DO_NOT_TRACK=1` by default.
+Their child processes inherit it, so studied CLIs that honor the convention can exclude
+synthetic usage. To study the product's telemetry behavior, set
+`execution.terminal.doNotTrack: false`; humanish then leaves the variable unset.
+Only booleans are accepted, and `true` or an omitted field enables the default.
+
+The resolved `doNotTrack` boolean is recorded with `humanish.actor-runtime.v1` in
+`actor.json`, `streams[].actor.runtime` in `run.json`, and `runtime` in
+`terminal-ledgers.json`. A dry run records it in the JSON message of its
+`terminal-lab.runtime.declared` event. Older bundles omit it. This records the
+command environment policy; it does not prove that the studied CLI honors the variable.
+
 ## Runtime auth: raw-key placement and remaining provider access
 
 `execution.runtimeAuth: openai-egress` is the default: a study that declares no

package/docs/contracts/run-bundle.md

@@ -6,6 +6,13 @@
 source of truth. This page explains the stable public fields and the extension rules; it does not
 version the runtime separately.
 
+Terminal runs record the resolved telemetry setting as `doNotTrack` in
+`streams[].actor.runtime` (`humanish.actor-runtime.v1`), also retained in `actor.json`
+and `terminal-ledgers.json`. `true` means participant and product setup commands receive
+`DO_NOT_TRACK=1`; `false` means humanish leaves it unset. Dry runs record the same boolean
+in the JSON message of the `terminal-lab.runtime.declared` event. Older bundles omit it.
+The setting does not attest that the studied CLI honors the variable.
+
 ## Purpose
 
 A run bundle is the durable evidence packet for one harness run. It should be
@@ -154,6 +161,9 @@ writing it, and on runs recorded before the field existed. For those, readers
 take liveness from `status.json` and, for an older finished run, its `ok` and
 `execution` from `status.json`'s `outcome`. That record is the only copy of an
 older run's `ok`; for a run with `outcome` in `run.json`, `status.json` copies it.
+The bundle's outcome wins even if the process stopped before updating `status.json`.
+Without an outcome or a usable status record naming the run, a bundle with a simulation still
+`running` reads as interrupted. A fresh status record keeps an in-progress bundle running.
 
 Every surface that shows whether a run passed calls `runDisplay`
 (`src/run/display.ts`) with the run's liveness, verdict and `ok`: the Observer

package/docs/contracts/schemas.md

@@ -35,7 +35,7 @@ workflow without leaking private upstream truth into core.
 | Substrate                         | reserved (never shipped)                                                                                                                                                       | none                                                                                |
 | Evidence stream                   | reserved (streams live inside the run bundle)                                                                                                                                  | see [`run-bundle.md`](run-bundle.md)                                                |
 | Review                            | `humanish.review.v1`                                                                                                                                                           | `contract-proof-review`                                                             |
-| Study analysis                    | `humanish.study-analysis.v1`                                                                                                                                                   | see [study analysis](study-analysis.md) and synthetic analysis fixtures in `tests/` |
+| Study analysis                    | `humanish.study-analysis.v1` (prompt `study-evidence-7` adds `findings[].headline`, `findings[].experience` and `designFindings[]`; older artifacts omit them)                 | see [study analysis](study-analysis.md) and synthetic analysis fixtures in `tests/` |
 | Study analysis correction         | `humanish.study-analysis-correction.v1`                                                                                                                                        | see [study analysis](study-analysis.md#human-review-and-sharing)                    |
 | Analysis findings view            | `humanish.analysis-findings.v1` (`review --json` field `analysis`; read-only projection of the selected analysis)                                                              | see [study analysis](study-analysis.md#reading-findings)                            |
 | Analysis execution receipt        | `humanish.analysis-execution.v1`                                                                                                                                               | see [study analysis](study-analysis.md#durable-records)                             |
@@ -296,6 +296,14 @@ instruction?, target?, entry?, host?, reasoningEffort?, stopWhen?, dwell? }` bec
   metadata; with `openai-egress` it stays in the host-side E2B header transform
   set at sandbox creation, and the agent gets a placeholder. A dry-run neither
   reads nor injects it;
+- `execution.terminal.doNotTrack`: boolean, default `true`. Terminal participant and product
+  setup commands receive `DO_NOT_TRACK=1`. Set `false` to leave that variable unset when
+  studying the product's telemetry behavior. Non-boolean values are refused at parse.
+  The resolved boolean is `doNotTrack` in `humanish.actor-runtime.v1`: `actor.json`,
+  `streams[].actor.runtime` in `run.json`, and `runtime` in `terminal-ledgers.json` for live
+  runs; the JSON message of the `terminal-lab.runtime.declared` event for dry runs.
+  Older bundles omit this field. It records the command environment policy, not whether
+  the studied CLI honored it;
 - `mode`: `dry-run` (a synthetic bundle, no spend; the default) or `live`. On the
   scripted route `live` gates real browser actuation against the declared app.
   Provider spend stays $0 there by mechanism (no model runs);

package/docs/contracts/study-analysis.md

@@ -161,6 +161,42 @@ thought. Older reports may omit this field and remain readable. The disclosure
 is model-generated assessment, not an independent completeness audit or a human
 reviewer annotation.
 
+## Headlines and design findings
+
+The `study-evidence-7` prompt writes each finding twice. `headline` is one plain sentence about what
+happened, for a designer, product manager or developer who did not watch the session.
+`experience` is one to three plain sentences: what the person tried, what got in their way, and
+how it seemed to feel. Neither names participant or evidence IDs. A concern known only from what
+participants said still reads as something they said. `title`, `summary` and `observations` keep
+their evidence-level wording, and validation applies to them as before.
+
+The same prompt adds `designFindings`: problems a product designer would notice in the supplied
+captures, whether or not a participant mentioned them. Each has an `id` (`D1`, `D2`, ...), a
+`headline`, the `screen` in plain words, what a designer would `notice`, `whyItMatters` to a
+person using the product, one `suggestion`, a `severity` (`major` when it misleads or blocks,
+`moderate` when it slows or confuses, `minor` when it is polish), a `confidence`,
+`seenByStreamIds` and `evidenceIds`. Validation rejects a design finding that cites no retained
+capture, cites evidence outside the packet, repeats an ID, or lists a participant in
+`seenByStreamIds` without a cited capture of that participant. An empty list means the review found no design
+problem in the captures. The model judges legibility and size from images alone; it does not
+measure text or control sizes.
+
+New provider responses must include `headline` and `experience` on every finding and a
+`designFindings` list. A stored artifact with prompt `study-evidence-7` or later must carry them
+too. Artifacts from earlier prompts load without them and render by title and summary. The
+Observer applies the same prompt-version rules and the same field limits when it reads a saved
+analysis, and treats an analysis that breaks them as unavailable.
+
+The narrative scrub removes a run's known transient values, such as a received one-time code or
+link, from every generated text field. It finds each value as written and in its encoded forms:
+percent-encoded, JSON-escaped, base64, base64url and hex, and where escapes split it. A field
+with a value is stored decoded with the value replaced; a field without one keeps its spelling. A
+known value in any of these forms in an ID, enum or reference refuses the response.
+
+When a reviewer amends a finding, its headline and experience describe the replaced claim.
+Text output, the Observer and feedback drafts show the reviewer's claim in their place and say the
+finding was corrected; the stored analysis keeps the original.
+
 Every observation cites packet-local evidence IDs. The model cannot choose a
 filesystem path or fetch another resource. Validation checks participant
 membership, unique counts, quote fidelity, evidence type and reference
@@ -203,7 +239,7 @@ feedback quotes cite evidence IDs that the run's own `analysis.json` resolves.
 Participant reviews cite distinct packet-local evidence IDs belonging only to
 that participant's stream; source event IDs are not citation IDs. Shared
 interactions can cite multiple included participants in findings and concern
-reviews under the existing exposure rules. The `study-evidence-6` prompt makes
+reviews under the existing exposure rules. The `study-evidence-6` prompt made
 this distinction explicit without changing the validator or historical reports.
 
 Elapsed replay time starts at the first retained capture. It is not a video
@@ -219,6 +255,12 @@ guarantee that the selected capture is the most relevant. Context-only and
 nonvisual evidence retain their basis and original event. All cited moments stay
 available, with exact recording links.
 
+A finding with a headline leads its Observer row with the headline and its open panel with the
+experience. The title, summary, assessment and observations sit in a closed **Evidence**
+disclosure beneath. A **Design findings** section follows the ranked findings, grouped by
+severity, with each cited capture as a thumbnail that opens that frame. Findings without a
+headline render as described below.
+
 Confidence, recovery and the first full evidence limitation remain visible when
 a finding opens. Exposure and remaining unique limits are one disclosure away;
 observation details retain each original claim and its specific limitation.
@@ -291,31 +333,35 @@ is disabled. Existing adapter captures and logs retain their contained routes.
 ## Reading findings
 
 `humanish review` prints a run's analysis findings after its participant review, and
-`humanish analyze show` prints them alone. Each finding shows its title, impact, confidence and
-recovery, the participants it affected out of those exposed, the frames its evidence cites with
-their time since the first retained capture, the capture files, its next step and the latest
-human review note. A live run's human output ends with up to three findings, one line each, and
-the `review` command that prints all of them. `analyze show --json` prints the validated
+`humanish analyze show` prints them alone. Each finding leads with its headline and experience,
+then shows its title as `evidence:`, its impact, confidence and recovery, the participants it
+affected out of those exposed, the frames its evidence cites with their time since the first
+retained capture, the capture files, its next step and the latest human review note. A finding
+without a headline starts at its title. Design findings follow, most severe first, each with its
+screen, notice, why it matters, suggestion, who saw it and its capture files. A live run's human
+output ends with up to three findings and up to three design findings, one line each, and the
+`review` command that prints all of them. `analyze show --json` prints the validated
 analysis record and its corrections, as before. Reading findings never starts an analysis.
 
 `review --json` carries the same view as its `analysis` field, schema
 `humanish.analysis-findings.v1`, built in `src/cli/findings.ts`:
 
-| Field                                                                          | Meaning                                                                                                                                                                                                                                                                                                                                       |
-| ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `schema`                                                                       | `humanish.analysis-findings.v1`.                                                                                                                                                                                                                                                                                                              |
-| `runId`                                                                        | The run the view reads.                                                                                                                                                                                                                                                                                                                       |
-| `state`                                                                        | `ready`, `stale`, `running`, `none`, `skipped`, `failed`, `dry_run` or `unavailable`. Only `ready` and `stale` carry findings.                                                                                                                                                                                                                |
-| `reason`                                                                       | The stable code behind a state other than `ready`, or null: an automatic analysis reason such as `AUTOMATIC_ANALYSIS_KEY_MISSING`, a failed attempt's error code, or a load warning such as `ANALYSIS_SOURCE_CHANGED`.                                                                                                                        |
-| `message`                                                                      | What happened, in words.                                                                                                                                                                                                                                                                                                                      |
-| `next`                                                                         | The command that gets findings for this run, or for a dry run the command that starts a live one. Null when no command can, as for a run whose participants left no evidence.                                                                                                                                                                 |
-| `analysisId`, `status`, `provider`, `model`, `completedAt`, `estimatedCostUsd` | The analysis version `analyze show` selects: the newest ready one, else the newest stale one. Null without one.                                                                                                                                                                                                                               |
-| `runPath`, `path`                                                              | The run directory and the version's `analysis.json`, relative to the project directory.                                                                                                                                                                                                                                                       |
-| `summary`, `limitations`                                                       | The analysis's own summary and limitations.                                                                                                                                                                                                                                                                                                   |
-| `findings[]`                                                                   | Highest priority first: `id`, `title`, `summary`, `impact` (`blocked_task`, `friction`, `recovery`, `uncertain`), `confidence` (`low`, `medium`, `high`), `recovery` (`recovered`, `not_observed`, `unknown`), `affected[]` (`streamId`, `label`), `exposedCount`, `evidence[]`, `nextStep` and `correction`.                                 |
-| `findings[].evidence[]`                                                        | Each cited item once: `id`, `streamId`, `kind`, `bases` (how the observations used it), `frame` (the latest retained capture's index from 0, null before any capture), `elapsedMs` (time since the first retained capture, not a video offset), `at` and `capture` (the file relative to the project directory, null for nonvisual evidence). |
-| `findings[].correction`                                                        | The latest `analyze correct` note on that finding version (`status`, `reason`, `replacementClaim`), or null.                                                                                                                                                                                                                                  |
-| `warnings`                                                                     | Load warnings for the selected version.                                                                                                                                                                                                                                                                                                       |
+| Field                                                                          | Meaning                                                                                                                                                                                                                                                                                                                                                                                 |
+| ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `schema`                                                                       | `humanish.analysis-findings.v1`.                                                                                                                                                                                                                                                                                                                                                        |
+| `runId`                                                                        | The run the view reads.                                                                                                                                                                                                                                                                                                                                                                 |
+| `state`                                                                        | `ready`, `stale`, `running`, `none`, `skipped`, `failed`, `dry_run` or `unavailable`. Only `ready` and `stale` carry findings.                                                                                                                                                                                                                                                          |
+| `reason`                                                                       | The stable code behind a state other than `ready`, or null: an automatic analysis reason such as `AUTOMATIC_ANALYSIS_KEY_MISSING`, a failed attempt's error code, or a load warning such as `ANALYSIS_SOURCE_CHANGED`.                                                                                                                                                                  |
+| `message`                                                                      | What happened, in words.                                                                                                                                                                                                                                                                                                                                                                |
+| `next`                                                                         | The command that gets findings for this run, or for a dry run the command that starts a live one. Null when no command can, as for a run whose participants left no evidence.                                                                                                                                                                                                           |
+| `analysisId`, `status`, `provider`, `model`, `completedAt`, `estimatedCostUsd` | The analysis version `analyze show` selects: the newest ready one, else the newest stale one. Null without one.                                                                                                                                                                                                                                                                         |
+| `runPath`, `path`                                                              | The run directory and the version's `analysis.json`, relative to the project directory.                                                                                                                                                                                                                                                                                                 |
+| `summary`, `limitations`                                                       | The analysis's own summary and limitations.                                                                                                                                                                                                                                                                                                                                             |
+| `findings[]`                                                                   | Highest priority first: `id`, `headline` and `experience` (null in analyses before `study-evidence-7`), `title`, `summary`, `impact` (`blocked_task`, `friction`, `recovery`, `uncertain`), `confidence` (`low`, `medium`, `high`), `recovery` (`recovered`, `not_observed`, `unknown`), `affected[]` (`streamId`, `label`), `exposedCount`, `evidence[]`, `nextStep` and `correction`. |
+| `findings[].evidence[]`                                                        | Each cited item once: `id`, `streamId`, `kind`, `bases` (how the observations used it), `frame` (the latest retained capture's index from 0, null before any capture), `elapsedMs` (time since the first retained capture, not a video offset), `at` and `capture` (the file relative to the project directory, null for nonvisual evidence).                                           |
+| `findings[].correction`                                                        | The latest `analyze correct` note on that finding version (`status`, `reason`, `replacementClaim`), or null. When `status` is `amended`, `replacementClaim` replaces the finding's headline and experience.                                                                                                                                                                             |
+| `designFindings`                                                               | Most severe first: `id`, `headline`, `screen`, `notice`, `whyItMatters`, `suggestion`, `severity` (`major`, `moderate`, `minor`), `confidence`, `seenBy[]` (`streamId`, `label`) and `evidence[]` (as `findings[].evidence[]`, without `bases`). Null without an analysis result, or for an analysis written before design findings.                                                    |
+| `warnings`                                                                     | Load warnings for the selected version.                                                                                                                                                                                                                                                                                                                                                 |
 
 The states without findings:
 
@@ -352,7 +398,10 @@ humanish feedback issue --run latest --analysis <id> --finding F1 --repo owner/r
 
 Corrections append against exact analysis and finding hashes. Confirming one
 version does not approve a later claim. Dismissed findings cannot become feedback
-drafts; amendments preserve the original and record the replacement. Feedback
+drafts; amendments preserve the original and record the replacement. A reason or replacement
+claim that matches a sensitive pattern is refused. When the correction is made inside the run's
+own invocation, one that holds a known transient value, as written or encoded, is refused too; a
+separate `analyze correct` command has no transient values to check against. Feedback
 drafts include source/version/evidence references and remain explicitly
 independent of participant-authored candidates. No command above posts to GitHub.
 Each analysis has room for 256 correction inventory entries, including interrupted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.111.4",
+  "version": "0.112.0",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",
@@ -76,6 +76,7 @@
     "tui:test": "pnpm --filter humanish-tui test",
     "release:dogfood": "node scripts/release-dogfood.mjs",
     "bench": "tsx bench/run.ts",
+    "arch:bench": "tsx scripts/arch-bench.ts",
     "browser-control:proof": "node scripts/browser-control-proof.mjs",
     "docs:generate": "tsx scripts/generate-cli-docs.ts",
     "docs:check": "tsx scripts/generate-cli-docs.ts --check && tsx scripts/check-doc-paths.ts && tsx scripts/check-doc-symbols.ts && tsx scripts/check-doc-comments.ts && tsx scripts/check-doc-study-fields.ts",

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

@@ -1,62 +0,0 @@
-import type { CuaTurnRequest } from "./loop.js";
-import type { ReasoningEffort } from "../reasoning-effort.js";
-import type { ActorConversation } from "../contract.js";
-import { CarriedConversation } from "./openai-context.js";
-import { type OpenAiReasoningSummary, type ParsedOpenAiResponse } from "./openai-wire.js";
-/** Request settings fixed for a provider's whole session. */
-export interface OpenAiRequestSettings {
-    readonly model: string;
-    readonly reasoningEffort: ReasoningEffort;
-    readonly maxOutputTokens?: number;
-    readonly safetyIdentifier?: string;
-}
-/** The conversation as the provider has it after its last accepted reply. */
-export interface OpenAiConversationState {
-    lastResponseId: string | undefined;
-    /** computer_call ids the next request owes an output for. */
-    pendingCallIds: string[];
-    /** Accepted replies so far; the next request is number `replies + 1`. */
-    replies: number;
-    /** The whole conversation, which explicit-context requests carry within its token budget. */
-    conversation: CarriedConversation;
-    /** explicit_context after a zero-data-retention rejection or when configured. */
-    mode: "previous_response_id" | "explicit_context";
-    /** Undefined once the account or model rejected reasoning summaries. */
-    reasoningSummary: OpenAiReasoningSummary | undefined;
-}
-/**
- * The items the next 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.
- * Built once per turn, so every attempt at the request and the accepted reply see the same items.
- */
-export declare function turnInputItems(state: OpenAiConversationState, req: CuaTurnRequest): readonly unknown[];
-/**
- * The body of the next participant request: the opening request, or a continuation carrying
- * `sent` (turnInputItems). A threaded continuation names the previous response; an
- * explicit-context one carries the conversation ahead of `sent`.
- */
-export declare function turnRequestBody(settings: OpenAiRequestSettings, state: OpenAiConversationState, req: CuaTurnRequest, sent: readonly unknown[]): Record<string, unknown>;
-/** The body of the read-only closing report: no tools, a small output limit, a strict schema. */
-export declare function debriefRequestBody(settings: OpenAiRequestSettings, state: OpenAiConversationState, req: CuaTurnRequest, sent: readonly unknown[]): Record<string, unknown>;
-/**
- * Move the conversation on to an accepted 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.
- */
-export declare function acceptReply(state: OpenAiConversationState, parsed: ParsedOpenAiResponse, closing: boolean, sent: readonly unknown[]): void;
-/** The trace's account of how a session carried its conversation (ActorConversation). */
-export declare class ConversationRecord {
-    private readonly now;
-    private explicitReason;
-    private rejection;
-    private switchedAt;
-    private switchedAtRequest;
-    private summarizedTurns;
-    private readonly requests;
-    constructor(configured: boolean, now: () => number);
-    /** The organization rejected server-side state, so the request being sent is explicit_context. */
-    switched(rejection: NonNullable<ActorConversation["rejection"]>): void;
-    /** A participant request just went out with `sent` after the carried conversation. */
-    requested(state: OpenAiConversationState, sent: readonly unknown[]): void;
-    snapshot(state: OpenAiConversationState): ActorConversation;
-}

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

@@ -1,144 +0,0 @@
-import { CarriedConversation, estimateTokens } from "./openai-context.js";
-import { buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, openingMessage, } from "./openai-wire.js";
-/** The closing report's output limit: its own cap, or the declared limit when that is lower. */
-const CLOSING_OUTPUT_LIMIT = 1024;
-function requestContext(settings, state, instructions) {
-    return {
-        stateless: state.mode === "explicit_context",
-        model: settings.model,
-        instructions,
-        reasoningEffort: settings.reasoningEffort,
-        ...(settings.maxOutputTokens === undefined
-            ? {}
-            : { maxOutputTokens: settings.maxOutputTokens }),
-        ...(state.reasoningSummary === undefined ? {} : { reasoningSummary: state.reasoningSummary }),
-        ...(settings.safetyIdentifier === undefined
-            ? {}
-            : { safetyIdentifier: settings.safetyIdentifier }),
-    };
-}
-/** No reply has been accepted yet, so the next request opens the conversation. */
-function isFirstTurn(state) {
-    return state.replies === 0;
-}
-/**
- * The items the next 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.
- * Built once per turn, so every attempt at the request and the accepted reply see the same items.
- */
-export function turnInputItems(state, req) {
-    if (isFirstTurn(state))
-        return [openingMessage(req.instructions, req.observation.screenshot)];
-    return [
-        ...state.pendingCallIds.map((id) => buildCallOutput(id, req.observation.screenshot, req.acknowledgedSafetyChecks)),
-        ...hintItems(req.contextHint),
-    ];
-}
-/**
- * The body of the next participant request: the opening request, or a continuation carrying
- * `sent` (turnInputItems). A threaded continuation names the previous response; an
- * explicit-context one carries the conversation ahead of `sent`.
- */
-export function turnRequestBody(settings, state, req, sent) {
-    const ctx = requestContext(settings, state, req.instructions);
-    if (isFirstTurn(state))
-        return buildInitialRequest(ctx, req.observation.screenshot);
-    return buildContinuationRequest({
-        ctx,
-        previousResponseId: state.lastResponseId,
-        callOutputs: [...sent],
-        ...(state.mode === "explicit_context"
-            ? { explicitContextItems: state.conversation.carried() }
-            : {}),
-    });
-}
-/** The body of the read-only closing report: no tools, a small output limit, a strict schema. */
-export function debriefRequestBody(settings, state, req, sent) {
-    return {
-        ...turnRequestBody(settings, state, req, sent),
-        tool_choice: "none",
-        max_output_tokens: Math.min(settings.maxOutputTokens ?? CLOSING_OUTPUT_LIMIT, CLOSING_OUTPUT_LIMIT),
-        text: {
-            format: {
-                type: "json_schema",
-                name: "participant_closing_report",
-                strict: true,
-                schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["summary", "frictionReports"],
-                    properties: {
-                        summary: { type: "string" },
-                        frictionReports: { type: "array", items: { type: "string" } },
-                    },
-                },
-            },
-        },
-    };
-}
-/**
- * Move the conversation on to an accepted 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.
- */
-export function acceptReply(state, parsed, closing, sent) {
-    if (!closing && parsed.turn.interruption === "output_limit")
-        return;
-    if (parsed.turn.responseId !== undefined)
-        state.lastResponseId = parsed.turn.responseId;
-    state.pendingCallIds = parsed.callIds;
-    state.replies += 1;
-    state.conversation.accept(state.replies, sent, parsed.outputItems);
-}
-/** The trace's account of how a session carried its conversation (ActorConversation). */
-export 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 just went out with `sent` after the carried conversation. */
-    requested(state, sent) {
-        if (state.mode !== "explicit_context") {
-            this.requests.push({ mode: "threaded" });
-            return;
-        }
-        const carried = state.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(state) {
-        return {
-            mode: state.mode === "explicit_context" ? "explicit_context" : "threaded",
-            ...(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 })),
-        };
-    }
-}