humanish 0.104.3 → 0.106.0

package/skills/humanish/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: humanish
-description: Install and configure Humanish CLI in a JavaScript app as an open-source-safe persona simulation harness. Use when an agent needs to add humanish, run safe first setup, create synthetic personas or scenarios, configure env var names without values, capture the email an app sends so a persona can complete an email-gated flow (e.g. a signup verification link or one-time code), run verification and Observer commands, or draft public-safe feedback issues without GitHub mutation.
+description: Install and configure humanish CLI in a JavaScript app as an open-source-safe persona simulation harness. Use when an agent needs to add humanish, run safe first setup, create synthetic personas or scenarios, configure env var names without values, capture the email an app sends so a persona can complete an email-gated flow (e.g. a signup verification link or one-time code), run verification and Observer commands, or draft public-safe feedback issues without GitHub mutation.
 ---
 
-# Humanish CLI
+# humanish CLI
 
-Use this skill to add Humanish to a target app without relying on chat memory or
+Use this skill to add humanish to a target app without relying on chat memory or
 private artifacts. Keep every example synthetic and public-safe.
 
 ## Hard Boundary
@@ -30,12 +30,12 @@ rendering escape codes into your transcript — but do not invoke it at all.
 
 Everything it shows has a machine-readable equivalent, which is what you want:
 
-| Instead of the TUI | Use |
-| --- | --- |
-| browsing labs | `npx humanish lab list --json` |
-| browsing runs | `npx humanish runs --json` |
-| starting a run | `npx humanish lab run <lab> --json --no-open` |
-| a run's outcome | `npx humanish review --run <id> --json` |
+| Instead of the TUI  | Use                                                                                    |
+| ------------------- | -------------------------------------------------------------------------------------- |
+| browsing labs       | `npx humanish lab list --json`                                                         |
+| browsing runs       | `npx humanish runs --json`                                                             |
+| starting a run      | `npx humanish lab run <lab> --json --no-open`                                          |
+| a run's outcome     | `npx humanish review --run <id> --json`                                                |
 | communication setup | `npx humanish comms providers --json` and `npx humanish comms connections list --json` |
 
 If a human asks you to "open the TUI", tell them the command to type; do not run
@@ -59,7 +59,7 @@ exact returned path, not a basename that could resolve to another manifest.
 
 1. Inspect public target-repo files only: `package.json`, docs, route/app
    structure, test scripts, and `.gitignore`.
-2. Install Humanish with the repo's package manager:
+2. Install humanish with the repo's package manager:
 
    ```bash
    npm i -D humanish
@@ -141,7 +141,7 @@ for setup and provider limits. Speech uses the same continuing Codex participant
 not a second conversation. Do not claim that installing the CLI also installs
 Docker or Lima, or qualifies a machine for arbitrary participant counts.
 
-For continuous desktop playback, independent computer-use lanes can opt into
+For continuous desktop playback, independent computer-use participants can opt into
 `execution.desktop.recording: { audio: true }` (`false` for screen-only video).
 Screenshots remain the default. Recording does not enable camera or speech;
 the raw media stays local-only. See [desktop recording](../../docs/architecture/desktop-recording.md)
@@ -149,12 +149,10 @@ for runtime requirements and export limits.
 
 ## Format Stack
 
-When creating or editing Humanish files:
+When creating or editing humanish files:
 
-- use `.yaml` for human-authored Humanish source: personas, scenarios,
-  policies, labs, review vocabulary, and milestones;
-- use `.ts` for executable integration: `humanish/config.ts`, adapters, route
-  catalogs, and app launch logic;
+- use `.yaml` for human-authored humanish source: labs, personas and scenarios;
+- use `.mjs` for executable adopter scorers named by `review.scorer.ref`;
 - use `.json` or `.ndjson` for generated machine artifacts, Observer data, run
   bundles, event streams, and synthetic fixtures.
 
@@ -167,25 +165,53 @@ or JSON does not serve.
 
 Create or edit only synthetic files under `humanish/`.
 
-Personas should describe motivations, accessibility needs, experience level,
-device assumptions, and risk tolerance. Avoid names, emails, addresses,
-accounts, screenshots, logs, tickets, transcripts, analytics rows, or anything
-copied from a real user.
+Personas describe the participant's relevant experience, motivations, habits and
+access needs. A short profile is enough; use optional multiline `background` for
+richer context (up to 32 KiB of UTF-8 text, never silently truncated). `summary` is
+a short description, capped at 280 characters with a warning. Unknown fields such
+as `backstory` are ignored with a warning; put that material in `background`.
+Use synthetic or de-identified research synthesis, never raw customer interviews
+or personal data in committed files.
 
-Scenarios should define the target app surface, start URL, task intent,
-success signals, and failure signals. Keep app-specific truth in the target
-repo's `humanish/` files, not in the package or this skill.
+```yaml
+schema: humanish.persona.v1
+id: volunteer-organizer
+name: Morgan
+summary: A volunteer organizer trying an unfamiliar planning app.
+background: |
+  Morgan coordinates twelve volunteers using spreadsheets and email.
+  They know those tools well but have never used this product.
+  Reconciling replies takes time. They worry about making the roster
+  public and want to keep a usable copy if the group changes tools.
+```
 
-When the app can run locally, make at least one scenario executable with a
-`browser.steps` manifest so `humanish run --app-url` can drive the app instead
-of falling back to the generic two-step proof:
+A profile with `background` receives only explicitly declared trait directives.
+Legacy profiles without it retain medium defaults for missing patience and
+technical confidence. Avoid contradictory prose and traits; inspect the compiled
+brief with `humanish lab inspect <lab> --json` before running.
+
+For an autonomous participant study, use a computer-use/local-agent lab and write
+its `mission` as a believable situation and desired outcome. Supply fixture facts
+needed to act, but do not supply selectors, click sequences, hidden success rules,
+expected defects or recovery tricks. For example: “Saturday's event needs two
+setup volunteers and one cleanup volunteer. See whether this app helps you
+organize the event and keep people informed.” Do not instruct a participant to
+find a specific UI control merely to make the study succeed. Allow discovery,
+recovery and stopping appropriate to the participant. Keep researcher criteria in
+`tasks[].success`, separate from participant-facing `tasks[].goal`.
+
+Scripted regression checks are a different use of scenarios. When the requested
+work is deterministic verification of a known path, a `browser.steps` manifest
+can drive it with explicit selectors and assertions. It does not establish
+independent persona behavior or discoverability. Keep app-specific paths and
+fixtures in the target repo's `humanish/` files.
 
 ```yaml
 schema: humanish.scenario.v1
 id: product-core-flow
-title: Product core flow
+title: Scripted product regression
 persona: synthetic-new-user
-goal: Reach and verify the first meaningful app state with synthetic data.
+goal: Verify a known path with synthetic data.
 mode: browser
 browser:
   startPath: /
@@ -196,17 +222,6 @@ browser:
       path: /
       expect:
         text: "Get started"
-    - id: enter-synthetic-input
-      label: Enter synthetic fixture input
-      action: fill
-      selector: "input[name='query']"
-      value: "synthetic fixture"
-    - id: submit-primary-action
-      label: Submit the primary action
-      action: click
-      selector: "button[type='submit']"
-      expect:
-        stateChanged: true
 ```
 
 Supported actions are `goto`, `fill`, `click`, `assertText`, `waitForText`,
@@ -241,21 +256,23 @@ warnings for fields the engine does not consume yet.
 
 ### Many actors at once (fan-out, shared worlds, concurrency)
 
-- **Every declared seat runs live at once by default.** A 6-lane roster is 6
-  simultaneous actors; total sessions and spend are the same either way, only
-  wall-clock and simultaneity differ. `execution.concurrency` is a CAP, not a
-  mode: declare it only to bound simultaneous paid desktops, and expect a parse
-  warning when the cap makes seats run in waves (a green waved run looks
-  identical to the all-live run you meant, so the harness says so up front).
-- **Per-lane worlds vs one shared world.** A plain multi-lane computer-use lab
-  gives each actor its OWN app instance (independent studies in parallel). Add
-  `subject.topology: shared-world` for N actors in ONE world (a lobby, a shared
-  DB, actors seeing each other's changes). `execution.concurrency: 1` on a
-  shared-world lab is the sequential turn-taking variant — one actor at a time,
-  and note comms/email has no wiring there.
-- **Watching it:** each live lane is its own Observer tile/stream; lanes beyond
-  a declared cap start when a slot frees, which on a capped run looks like idle
-  tiles — another reason to leave the cap out unless you need it.
+- **Every declared participant runs live at once by default.** A 6-participant
+  roster is 6 simultaneous actors; total sessions and spend are the same either
+  way, only wall-clock and simultaneity differ. `execution.concurrency` is a
+  CAP, not a mode: declare it only to bound simultaneous paid desktops, and
+  expect a parse warning when the cap makes participants run in waves (a green
+  waved run looks identical to the all-live run you meant, so the harness says
+  so up front).
+- **Separate worlds (`per-lane-worlds`) vs one shared world.** A plain
+  multi-participant computer-use lab gives each actor its OWN app instance
+  (independent studies in parallel). Add `subject.topology: shared-world` for N
+  actors in ONE world (a lobby, a shared DB, actors seeing each other's
+  changes). Shared-world participants run at once; `execution.concurrency` must
+  be at least 2 there.
+- **Watching it:** each live participant is its own Observer tile/stream;
+  participants beyond a declared cap start when a slot frees, which on a capped
+  run looks like idle tiles — another reason to leave the cap out unless you
+  need it.
 
 Use committed `humanish/labs/*.yaml` for public-safe, reproducible labs. Use
 ignored `.humanish/labs/*.yaml` or `.humanish/local/labs/*.yaml` for private repo
@@ -276,7 +293,7 @@ npx humanish lab run first-run --json --no-open
 
 When a flow needs an email from the app — a verification link, one-time code or
 magic link — configure an inbox so the participant can read and use that message.
-Humanish supports local capture and fresh hosted receiving, with different setup
+humanish supports local capture and fresh hosted receiving, with different setup
 and privacy behavior.
 
 Choose the transport to match the app:
@@ -285,10 +302,10 @@ Choose the transport to match the app:
   no external mail service is needed. It tests the email flow without proving
   real delivery.
 - **Real AgentMail receiving**: use `comms.email: { connection: agentmail }`.
-  Humanish acquires one fresh hosted inbox per participant before desktops start.
+  humanish acquires one fresh hosted inbox per participant before desktops start.
   The app sends normally. Requires a configured organization-scoped key and
-  app-url/clone/local-tree hosted computer-use participants; concurrent shared
-  worlds work, sequential shared worlds and local-agent do not. Do not combine
+  app-url/clone/local-tree hosted computer-use participants; shared worlds
+  work, local-agent does not. Do not combine
   connection with capture settings or substitute fresh addresses for existing
   account identities. `allowedOrigins` can name additional trusted link origins.
 
@@ -306,7 +323,8 @@ The following configuration selects **local capture**:
 ```yaml
 comms:
   email:
-    injectEnv: RESEND_API_URL # adopter-named: whatever env var YOUR app reads for its
+    injectEnv:
+      RESEND_API_URL # adopter-named: whatever env var YOUR app reads for its
       # email-API base URL. The harness sets it to the in-sandbox catch — do NOT also
       # list it in subject.env. VERIFY the app actually reads this variable: a stock
       # email SDK does not honor a base-URL env unless the app passes it through, and
@@ -314,46 +332,46 @@ comms:
       # A run where the catch captured zero sends warns at teardown for exactly this.
 ```
 
-That is the whole block for the common case. Every lane automatically gets a
+That is the whole block for the common case. Every participant automatically gets a
 deterministic inbox address (`<laneId>@example.test`), and each actor's prompt is
 extended with the full handoff: its address ("when the app asks for an email
 address, enter exactly that"), the inbox URL to open, and the wait steering
 ("waiting for an email is normal, not a blocker"). Declare `recipients` only to
-customize addresses or limit which lanes do email:
+customize addresses or limit which participants do email:
 
 ```yaml
-    recipients:
-      - lane: signup-01 # this lab's REAL lane id — a roster lane's `id`, or the
-        # generated lane-01..lane-NN names when you use `count`. An unknown lane
-        # is a hard parse error listing the lab's actual lane ids (a mismatch
-        # would silently disable the funnel for that seat, which is how a
-        # 6-actor field run lost every inbox at once). Lanes you leave out get
-        # no inbox and are never told one exists — the parser warns which.
-        address: user@example.test # what the actor signs up with; the evidence
-        # drain matches captured mail against it.
+recipients:
+  - lane: signup-01 # this lab's REAL participant id: a roster entry's `id`, or the
+    # generated lane-01..lane-NN names when you use `count`. An unknown id
+    # is a hard parse error listing the lab's actual participant ids (a mismatch
+    # would silently disable the funnel for that participant, which is how a
+    # 6-actor field run lost every inbox at once). Participants you leave out get
+    # no inbox and are never told one exists — the parser warns which.
+    address: user@example.test # what the actor signs up with; the evidence
+    # drain matches captured mail against it.
 ```
 
 The app keeps calling its email API normally (Resend/SendGrid-shaped, or a custom
 profile); only the base URL is redirected. Route support: the clone/local-tree
 computer-use route (inbox on the sandbox's own loopback) and the CONCURRENT
 shared-world route (inbox getHost-exposed from the subject sandbox; the default
-since every seat now runs live at once). SMTP capture is supported on per-lane
-provisioned routes; shared-world SMTP is rejected because it is not wired there.
+since every participant now runs live at once). SMTP capture is supported on
+provisioned routes with separate worlds (`per-lane-worlds`); shared-world SMTP
+is rejected because it is not wired there.
 For app-url/operator-provided subjects, run `humanish comms catch` on a reachable
 host, point the app's email sends at that catch, and declare
 `comms.email.external.catchBaseUrl` (plus `inboxBaseUrl` if different). A declared
 `authTokenEnv` is an environment variable name, never a credential value.
-Sequential `concurrency: 1` shared-world email remains unwired; do not silently
-change study concurrency to work around that limitation. The in-sandbox catch
+The in-sandbox catch
 needs `python3` (the stock E2B desktop has it).
 Evidence is digest-only (`humanish.comms-thread.v1` — counts and digests, never
-raw mail); the *readable* proof a persona saw the email is its screenshots of the
+raw mail); the _readable_ proof a persona saw the email is its screenshots of the
 inbox page. See `docs/contracts/schemas.md` for the full `comms:` shape and
 `humanish <cmd> --help` for run flags — this skill does not restate them.
 
 ## First Proof Run
 
-Run the no-credentials path first. This proves Humanish artifact plumbing, not
+Run the no-credentials path first. This proves humanish artifact plumbing, not
 target app behavior:
 
 ```bash
@@ -374,23 +392,34 @@ The feedback command prints a public-safe Markdown draft. It must not call the
 GitHub API, require a token, update Projects, use provider credits, or claim
 product behavior proof from a dry run.
 
-When the target app can run locally, prove real browser behavior with
-`run --app-url` after starting the app on loopback:
+When the target app can run locally, prove a known browser path with a
+scripted-browser lab after starting the app on loopback. The lab replays a
+`browser.steps` scenario (see above) on a desktop surface, plus a mobile one
+with `count: 2`. The scripted steps make no model requests. Post-run analysis
+still runs by default when `OPENAI_API_KEY` is set, with a $3 cap; keep
+`review.analysis: false` to skip it. Copy the shape of
+[`humanish/labs/scripted-demo.yaml`](https://github.com/danielgwilson/humanish/blob/main/humanish/labs/scripted-demo.yaml)
+or the example in the
+[lab manifest reference](https://humanish.dev/docs/lab-manifests#scripted-browser-scenarios):
+set `subject.appUrl` to the loopback URL, `scenario.ref` to the scenario id,
+and `scenario.mode: live`. Without `mode: live` the lab is a dry run that opens
+no browser.
 
 ```bash
 # in another terminal, start the target app on 127.0.0.1 or localhost
-npx humanish run --app-url http://127.0.0.1:<port> --sims 2 --json
+npx humanish lab inspect <lab> --json
+npx humanish lab run <lab> --json --no-open
 npx humanish verify --run latest --json
 npx humanish watch --run latest --detach --no-open --json
 ```
 
-Do not use `humanish watch --sims ...` as a substitute for app-url proof.
-`watch` renders or follows Observer evidence; `run --app-url` is the command
-that captures live desktop/mobile browser evidence against a running app.
+Do not use `humanish watch --sims ...` as a substitute for a scripted-browser
+lab. `watch` renders or follows Observer evidence; a live scripted-browser lab
+captures desktop and mobile browser evidence against a running app.
 
 ## Optional Live E2B Lab
 
-Live headed E2B desktop lanes are optional. Add the substrate dependency only
+Live headed E2B desktop participants are optional. Add the substrate dependency only
 when the user explicitly wants live E2B execution:
 
 ```bash

package/skills/humanish/agents/openai.yaml

@@ -1,7 +1,7 @@
 interface:
-  display_name: "Humanish CLI"
+  display_name: "humanish CLI"
   short_description: "Set up public-safe persona simulation"
-  default_prompt: "Use $humanish to install Humanish in this repo, scaffold synthetic personas and scenarios, run the safe Observer proof, and report the public-safe artifacts. If the app can run locally, start it on loopback and use `humanish run --app-url http://127.0.0.1:<port> --sims 2` before rendering Observer with `humanish watch --run latest`; do not treat `watch --sims` as app behavior proof."
+  default_prompt: "Use $humanish to install humanish in this repo, scaffold synthetic personas and scenarios, run the safe Observer proof, and report the public-safe artifacts. If the app can run locally, start it on loopback and run a live scripted-browser lab (see https://humanish.dev/docs/lab-manifests#scripted-browser-scenarios; set `scenario.mode: live` and keep `review.analysis: false`) before rendering Observer with `humanish watch --run latest`; do not treat `watch --sims` as app behavior proof."
 
 policy:
   allow_implicit_invocation: true

package/dist/actor-contract.d.ts

@@ -1,288 +0,0 @@
-import type { AffordanceUse } from "./affordance.js";
-import type { CodexAppServerRunResult, CodexAppServerStatus } from "./codex-app-server.js";
-import type { ActorEstimatedCost } from "./pricing.js";
-import type { TaskFunnel } from "./tasks.js";
-import { type CuaProviderFailurePhase } from "./cua-provider-error.js";
-export declare const ACTOR_TRACE_SCHEMA = "humanish.actor-trace.v1";
-/**
- * How a session ended, from the point of view of the STUDY rather than the harness.
- *
- * The distinction matters because two of these are participant outcomes and the rest are not. A
- * participant who abandons a task is the single most valuable thing a usability study produces, and
- * recording that as `failed` — as this type used to force — reads as the instrument breaking. See
- * docs/principles/three-roles.md.
- *
- * - `passed`      the participant reached the goal
- * - `abandoned`   the participant stopped trying. A FINDING, not a malfunction
- * - `incomplete`  the session ended (time or budget) before the goal was reached
- * - `blocked`     the participant could not proceed: an approval the run could not give, or a
- *                 blocker they described in their own final words (#476)
- * - `timed_out`   the session hit its deadline with no productive activity at all
- * - `failed`      the HARNESS failed: a dead sandbox, a provider error, a broken artifact
- */
-export type ActorStatus = "passed" | "abandoned" | "incomplete" | "blocked" | "timed_out" | "failed";
-/**
- * What the PARTICIPANT said happened, in a field rather than a paragraph (#570). Providers whose
- * reply is schema-constrained (the local-agent routes) fill it on their final turn; a free-text
- * provider leaves it absent and the lane falls back to reading the closing message. `reached`:
- * the task is finished. `blocked`: something in the app stopped the participant. `not_reached`:
- * the participant stopped for another reason (gave up, ran out of ideas).
- */
-export type ParticipantDeclaredOutcome = "reached" | "not_reached" | "blocked";
-/** Statuses that describe what happened to a PARTICIPANT rather than a harness malfunction. Verify
- *  treats these as study results, so a run whose evidence is sound is not called untrustworthy just
- *  because a persona gave up. */
-export declare const PARTICIPANT_OUTCOME_STATUSES: readonly ActorStatus[];
-/** Optional precise interruption cause; completionReason and status retain their original meaning. */
-export type ActorStopCause = "provider_output_limit" | "provider_token_limit" | "time_limit" | "spend_limit" | "study_spend_limit" | "adapter_limit" | "provider_incomplete" | "provider_status" | "harness_aborted" | "usage_unreported";
-export type ActorCompletionReason = "goal_satisfied" | "turn_completed" | "gave_up" | "blocked_approval" | "timed_out" | "budget_reached" | "actor_error" | "step_failed" | "harness_error";
-export type ActorLane = "code" | "app" | "computer-use" | "scripted-browser" | "terminal";
-export type ActorProtocol = "json-rpc" | "json-stream" | "in-process-sdk" | "cua-loop" | "scripted-steps" | "terminal-exec";
-export type ActorTraceItemKind = "message" | "reasoning" | "tool_call" | "command" | "file_change" | "approval" | "screenshot" | "ui_action" | "plan" | "notice";
-export interface ActorTraceItem {
-    id: string;
-    kind: ActorTraceItemKind;
-    lifecycle: "started" | "completed";
-    status?: string;
-    title: string;
-    tool?: {
-        server?: string;
-        name?: string;
-    };
-    command?: {
-        text?: string;
-        cwd?: string;
-        exitCode?: number;
-        outputTail?: string;
-    };
-    screenshotRef?: {
-        path: string;
-        redaction: "blurred" | "ocr_scrubbed" | "none";
-    };
-    text?: string;
-    /** When the item was recorded (ISO-8601), from the loop's injected clock. Additive
-     *  (#441): items from older bundles and non-stamping producers lack it, so every
-     *  consumer must treat absence as "timing unknown", never as t=0. */
-    at?: string;
-    /** Structured pointer coordinates for click-like `ui_action` items (#441) — the
-     *  recorded fact the Observer's pins previously re-parsed out of the title text. */
-    coord?: {
-        x: number;
-        y: number;
-    };
-}
-export interface ActorCapabilities {
-    headless: boolean;
-    structuredTrace: boolean;
-    lanes: ActorLane[];
-    producesScreenshots: boolean;
-    byoModel: boolean;
-    preGrantableApprovals: boolean;
-    inProcessTools: boolean;
-    license: "open" | "source-available" | "proprietary";
-    /**
-     * WHERE this actor's runtime key lives, per the placement rule (invariants-and-defaults.md):
-     * "keys live where the keyed process runs — and nowhere else." Registry metadata the engine
-     * enforces, NOT a code convention.
-     *   - "external" (the implicit default for every existing actor): the keyed process (e.g. a
-     *     computer-use provider loop) runs OUTSIDE any sandbox, so its key never enters one.
-     *   - "in-sandbox-command-scoped": the keyed process is an agent-harness-under-test that runs
-     *     INSIDE the sandbox; its runtime key is injected ONLY into the per-command `envs` of that
-     *     invocation (never `Sandbox.create({envs})`, which is sandbox-global), the key is presumed
-     *     exfiltratable, and the blast radius is bounded by key scoping + a spend budget.
-     * Absent === "external". On the shipped terminal-product live route, the engine enforces this
-     * declaration before sandbox creation and passes the key only to the agent command.
-     */
-    keyPlacement?: "external" | "in-sandbox-command-scoped";
-}
-export interface ActorPersonaRef {
-    id: string;
-    traitsApplied: string[];
-    promptDigest: string;
-}
-export interface ActorTokenUsage {
-    input?: number;
-    output?: number;
-    /** Of `input`, how many tokens were served from the provider's prompt cache. Optional and
-     *  HONESTLY ABSENT: a provider that does not report it leaves this undefined rather than
-     *  reporting 0, because 0 and "unknown" price very differently (#391). */
-    cachedInput?: number;
-    /** Of `input`, how many tokens were newly WRITTEN to the provider's prompt cache
-     *  (OpenAI 5.6+ bills these at a surcharge and reports `cache_write_tokens`). Same
-     *  honestly-absent discipline as `cachedInput` (#334). */
-    cacheWriteInput?: number;
-    /** Per model-inference request usage, in request order. One provider interaction can contain
-     *  several inferences around native tool calls. A provider that re-prices whole requests past
-     *  an input-size threshold can only be priced exactly from these sizes; totals cannot say which
-     *  requests crossed. Additive and honestly absent on producers that do not record it (#334). */
-    turns?: Array<{
-        input?: number;
-        cachedInput?: number;
-        cacheWriteInput?: number;
-        output?: number;
-    }>;
-    total?: number;
-    costUsd?: number;
-}
-/** Requested execution profile; per-request verification is recorded separately. */
-export interface ActorExecutionProfile {
-    schema: "humanish.actor-execution-profile.v1";
-    transport: "codex-app-server";
-    authentication: "chatgpt-account";
-    billing: "account-unknown";
-    requestedModel: string;
-    reasoningEffort: import("./reasoning-effort.js").ReasoningEffort;
-    cliVersion: "0.154.0";
-    toolPolicy: "restricted-codex-v1" | "codex-ui-tools-v1";
-    participantSchema: "humanish.restricted-participant-turn.v1" | "humanish.codex-ui-tool.v1";
-    memoryPolicy: "recent-eight-16k-v1" | "continuing-thread-v1";
-}
-export interface ProviderRequestReceipt {
-    dispatched: boolean | "unknown";
-    usageComplete: boolean;
-    cleanup: "confirmed" | "unconfirmed";
-}
-export interface ActorProviderRequest extends ProviderRequestReceipt {
-    ordinal: number;
-    kind: "interaction" | "debrief";
-    /** Launcher version, effective config, account, thread and tool-policy checks
-     * passed before turn/start. Does not attest remote execution or completion. */
-    profileVerified: boolean;
-    errorCode?: import("./cua-provider-error.js").CuaProviderErrorCode;
-    failurePhase?: CuaProviderFailurePhase;
-    usage?: ActorTokenUsage;
-}
-/** Durable reader profile. Append new qualified profiles; never rewrite old evidence. */
-export declare function validActorExecutionProfile(value: unknown): value is ActorExecutionProfile;
-/** Closed per-attempt evidence; dollar amounts are never part of account usage. */
-export declare function validActorProviderRequests(value: unknown): value is ActorProviderRequest[];
-/** The participant's account, not an independently confirmed product diagnosis. */
-export interface ParticipantClosingReport {
-    summary: string;
-    frictionReports: string[];
-}
-/** Runtime declarations and executable-version observations; not provider request attestation. */
-export interface ActorRuntimeProvenance {
-    schema: "humanish.actor-runtime.v1";
-    package: string;
-    requestedVersion: string;
-    observedVersion?: string;
-    versionStatus: "unobserved" | "verified" | "failed";
-    requestedModel?: string;
-    modelStatus: "declared" | "runtime_default_unobserved";
-    requestedReasoningEffort?: string;
-    /** Codex turn.completed aggregates requests; it cannot establish per-request pricing tiers. */
-    usageGranularity: "runtime_turn";
-}
-export interface ActorTrace {
-    schema: typeof ACTOR_TRACE_SCHEMA;
-    provider: string;
-    providerVersion?: string;
-    executionProfile?: ActorExecutionProfile;
-    providerRequests?: ActorProviderRequest[];
-    historyTurnsOmitted?: number;
-    runtime?: ActorRuntimeProvenance;
-    protocol: ActorProtocol;
-    lane: ActorLane;
-    persona: ActorPersonaRef;
-    redaction: {
-        status: "passed";
-        screenshots: "n/a" | "raw" | "blurred" | "ocr_scrubbed";
-        notes: string;
-    };
-    startedAt: string;
-    completedAt: string;
-    durationMs: number;
-    status: ActorStatus;
-    completionReason: ActorCompletionReason;
-    /** Absent in older traces and on routes that do not record a precise interruption cause. */
-    stopCause?: ActorStopCause;
-    reason: string;
-    ids: {
-        sessionId?: string;
-        threadId?: string;
-        turnId?: string;
-        model?: string;
-    };
-    /**
-     * ADDITIVE + OPTIONAL record of HOW the model was asked to run (humanish.model-settings.v1,
-     * #497). `ids.model` says which model; this says the reasoning effort the request actually
-     * carried. Present on lanes whose provider declares settings; absent everywhere else and on
-     * every pre-existing bundle, and its absence is tolerated by verify.
-     *
-     * It exists because effort was a silent constant: unreachable from a lab, so every run took the
-     * provider default. Effort is part of WHO the participant was, not of how the instrument was
-     * tuned (docs/principles/actor-fidelity.md), so a trace that does not carry it is a result with
-     * half its sample description missing — and two such traces cannot honestly be compared.
-     */
-    modelSettings?: {
-        reasoningEffort: string;
-        maxOutputTokens?: number;
-    };
-    counts: Record<string, number>;
-    /**
-     * ADDITIVE + OPTIONAL affordance record (humanish.affordance-use.v1, #369): which KIND of route
-     * this actor took — pointer, keyboard, url-navigation, script-execution, devtools,
-     * browser-internal, observation — as per-class counts over the run's dispatched actions.
-     * Present on computer-use lanes that dispatched at least one action; absent elsewhere and on
-     * every pre-existing bundle (its absence is tolerated by verify). The harness records the class
-     * and states NO verdict: whether a class is faithful depends on the population the study
-     * declares, which is product semantics and belongs to the adopter's scorer. See
-     * docs/principles/actor-fidelity.md.
-     */
-    affordanceUse?: AffordanceUse;
-    /**
-     * ADDITIVE + OPTIONAL task funnel (humanish.task-funnel.v1, #414): how far this participant got
-     * through the lab's declared protocol, corroborated per task by observations rather than by the
-     * actor's own narration. Present only when the lab declared `tasks` and the session ran; absent
-     * on every pre-existing bundle and on dry-run contract bundles (honest absence — a funnel that
-     * was never measured is not an empty funnel). Its absence is tolerated by verify.
-     */
-    taskFunnel?: TaskFunnel;
-    /**
-     * ADDITIVE + OPTIONAL (#570): the outcome the participant declared on its final turn, when its
-     * provider's reply carries the field. Absent on free-text providers and on every older bundle.
-     * The lane reads this before it reads the closing paragraph; three regex patches in one month
-     * (#453, #549, #565) 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. */
-    debrief?: {
-        trigger: "stop_when" | "dwell";
-        status: "completed" | "skipped" | "failed";
-        reason: string;
-        /** Absent if no request was made; false means token accounting is incomplete. */
-        usageReported?: boolean;
-        report?: ParticipantClosingReport;
-        /** Links the readable projection so it is not heuristically classified a second time. */
-        messageId?: string;
-    };
-    items: ActorTraceItem[];
-    tokenUsage?: ActorTokenUsage;
-    /** A stalled or adapter-reported ambiguous interaction may have additional unreported usage.
-     *  Known tokenUsage remains usable as a partial total. Absence is not proof of completeness. */
-    interactionUsageIncomplete?: true;
-    /**
-     * ADDITIVE + OPTIONAL token-derived cost ESTIMATE for this lane (humanish.actor-estimated-cost.v1).
-     * Distinct from `tokenUsage.costUsd`, which is RESERVED for a real provider-returned charge: a
-     * bare `costUsd` always means "the provider billed this", while `estimatedCost.estimatedCostUsd`
-     * is a rate-table multiply named honestly as an estimate (invariant 6). Absent on codex/scripted
-     * lanes and on every pre-existing bundle — its absence is tolerated by verify (fail-open on
-     * display). A `null` estimatedCostUsd is DECLARED ABSENT (unknown rate / no usage), never 0.
-     */
-    estimatedCost?: ActorEstimatedCost;
-    capabilities: ActorCapabilities;
-}
-export declare const CODEX_APP_SERVER_CAPABILITIES: ActorCapabilities;
-export declare const PI_AGENT_CORE_CAPABILITIES: ActorCapabilities;
-export declare const CLAUDE_AGENT_SDK_CAPABILITIES: ActorCapabilities;
-export declare const SCRIPTED_BROWSER_CAPABILITIES: ActorCapabilities;
-export declare const TERMINAL_AGENT_CAPABILITIES: ActorCapabilities;
-export declare function codexStatusToCompletionReason(status: CodexAppServerStatus): ActorCompletionReason;
-/**
- * Map a Codex app-server run result into the provider-neutral ActorTrace. Pure
- * and side-effect-free. The persona reference is supplied by the harness; until
- * personas are load-bearing it is a minimal stub ({ id, traitsApplied: [],
- * promptDigest }).
- */
-export declare function codexResultToActorTrace(result: CodexAppServerRunResult, persona: ActorPersonaRef): ActorTrace;