humanish 0.106.0 → 0.107.0

package/docs/architecture/{terminal-product-lane.md → terminal-product-route.md}

@@ -38,15 +38,16 @@ fail-closed cross-validation, and forward-declared warnings.
 | `execution.terminal`                  | `{ transport: exec-stream, stdin: disabled }`                                                                                                             |
 | `execution.runtimeAuth`               | `openai-env` (default) or opt-in `openai-egress`; names-only durable evidence                                                                             |
 | `execution.runtime.version`           | Optional exact `@openai/codex` version; observed before keyed execution                                                                                   |
-| `actors[0].model` / `reasoningEffort` | Forwarded to Codex; retained as declarations, not observed provider identity                                                                              |
+| `actors[0].model` / `reasoningEffort` | Passed to Codex as `--model` (default `gpt-5.6-sol`) and `-c model_reasoning_effort`; declarations, not observed provider identity                        |
 | `scenario.caps`                       | `{ maxUsd, maxJobs, maxMinutes }`: the blast-radius budget; `maxUsd > 0` is refused unless a `costProbe` measures spend                                   |
 | `policies`                            | `allowPrivateRepoAccess` / `allowProviderCredentials` / `allowPaymentCredentials` / `allowGitHubMutation`, all DEFAULT FALSE                              |
 | `actors[0].type`                      | `codex-exec`: a registered terminal actor (`keyPlacement: in-sandbox-command-scoped`)                                                                     |
-| `LabBackend`                          | `terminal` → `runTerminalProductLab` ([`src/routes/terminal/route.ts`](https://github.com/danielgwilson/humanish/blob/main/src/routes/terminal/route.ts)) |
+| route                                 | `terminal` → `runTerminalProductLab` ([`src/routes/terminal/route.ts`](https://github.com/danielgwilson/humanish/blob/main/src/routes/terminal/route.ts)) |
 
 Routing is `routeOf` (`src/lab/plan.ts`). It sends every `terminal-product` subject to
 this route, even with an unregistered actor, so this route refuses the actor.
-`routesToTerminalProduct(config)` also feeds the forward-declared warnings.
+`isTerminalProductComposition(config)` (`src/lab/routing.ts`) also feeds the forward-declared
+warnings.
 
 ## Repeating a terminal study with the same runtime
 
@@ -70,16 +71,24 @@ and reclaims its owned sandbox. When the version is omitted, the probe resolves
 
 `actor.json`, the bundle's terminal actor, and `terminal-ledgers.json` retain
 `humanish.actor-runtime.v1`: requested and observed versions, verification status,
-declared model/effort, and the usage granularity. The observed executable version
-also appears as `providerVersion`. An undeclared model stays explicitly
-`runtime_default_unobserved`; humanish does not label the runtime name as a model.
+the requested model and where it came from, declared effort, and the usage granularity.
+The observed executable version also appears as `providerVersion`.
+
+Codex's `--json` stream does not name the model it used, and its built-in default can change
+with any release. So the route always passes `--model`: the lab's `actors[0].model`
+(`modelStatus: declared`), or humanish's participant default `gpt-5.6-sol`
+(`modelStatus: humanish_default`). Bundles written before 0.107.0 record
+`runtime_default_unobserved` with no requested model.
 Dry runs record declarations only, in a `terminal-lab.runtime.declared` event.
 
 These settings make a study's request reproducible, but do not attest the actual
-provider model or add a provider spending limit. Codex `turn.completed` usage can
-aggregate several model requests, so humanish does not use a declared model to
-infer per-request pricing tiers or fill in unknown costs. Runtime-token costs
-and the studied product's no-spend boundary still need separate interpretation.
+provider model or add a provider spending limit. humanish prices the agent's tokens from the
+requested model. Codex `turn.completed` usage sums every request in a turn, so no request's own
+size is known and no per-request long-context tier can be applied. The estimate prices every token
+at the base tier, with cached input at the cached rate, and says so with
+`basis: aggregated_turns_base_rate`. It is an estimate, not a measurement. The cost ledger
+checked against `scenario.caps.maxUsd` keeps the provider line unmeasured, and the studied
+product's no-spend boundary still needs separate interpretation.
 
 ## Runtime auth: raw-key placement and remaining provider access
 
@@ -238,11 +247,10 @@ At SLICE 1, a non-dry-run call returned a structured
 SLICE 2 implemented the real session.
 
 SLICE 1 declared the DI seams SLICE 2 needed (`loadModule`, `buildSandbox`,
-`runtimeAuthEnv`, `detachedTimers`) on `TerminalProductLabHooks`; only the dry-run
-path was implemented in that slice. The hook bag now carries `loadModule`, `env`,
-`renderObserverFn`, `now`, `costProbe`, `score` and `deriveFeedback`
-(`src/routes/terminal/types.ts`), and `TerminalProductLabHooks` itself is deprecated
-in favor of `RunLabOptions`.
+`runtimeAuthEnv`, `detachedTimers`) on a terminal hook bag; only the dry-run path was
+implemented in that slice. The bag is gone. The route reads `env` and `scorer` from its
+options (`src/routes/terminal/types.ts`), and a test passes its seams (`desktopModule`,
+`renderObserver`, `now`, `costProbe`) as `LabDeps` (`src/lab/lab-deps.ts`).
 
 ## SLICE 4: the product-adapter extension seam (layer 6)
 
@@ -263,7 +271,7 @@ lives in the adopter's repo:
   `AdapterScorerModule`): `score?(ctx) => RunAdapterScore | Promise<…>` and
   `deriveFeedback?(ctx) => RunFeedbackCandidate[] | Promise<…>`, where this route's
   `ctx` is a `TerminalProductScoringContext`. The older `terminalHooks.score` and
-  `terminalHooks.deriveFeedback` still work and warn as deprecated. The route calls the
+  `terminalHooks.deriveFeedback` were removed with the bag. The route calls the
   hooks over the FULLY-ASSEMBLED, redacted evidence and attaches the results
   (`bundle.adapterScore`, appended `bundle.feedbackCandidates`) WITHOUT core knowing
   any product noun. Default (no hook) behavior is unchanged: the mission-based verdict

package/docs/contracts/run-bundle.md

@@ -267,12 +267,14 @@ A local scripted run (no model request, no hosted desktop) is such a run; a scri
 a provisioned clone records the clone's desktop as a `laneId: subject` line. A live bundle
 without `cost` has an unmeasured spend. A live terminal run's `cost` prices the E2B terminal
 sandbox as a `desktop-minutes` line from its acquired-to-cleanup span and `e2b.getInfo` size.
-Its Codex `model-tokens` line stays `null` (`no_rate_for_model` with model `codex`, or
-`no_token_usage` when Codex reported none): the participant prices against its provider id `codex`
-even when `actors[0].model` is passed as `--model`, and `terminal-ledgers.json` counts those
-tokens without a price.
-So a terminal total is a lower bound (`fullyEstimated: false`), and the unpriced tokens are
-not $0. Each participant's own estimate also rides its
+Its Codex `model-tokens` line prices the agent's tokens from the model passed as `--model`
+(`actors[0].model`, else `gpt-5.6-sol`). Codex reports usage per turn, summed over the turn's
+requests, so the line prices every token at the base tier and carries
+`basis: aggregated_turns_base_rate`. It stays `null` with `no_token_usage` when Codex reported
+none. `terminal-ledgers.json` still counts those tokens without a price, because its provider line
+takes only provider-reported cost. Bundles written before 0.107.0 price against the provider id
+`codex` and record `no_rate_for_model`, so their total is a lower bound
+(`fullyEstimated: false`) and the unpriced tokens are not $0. Each participant's own estimate also rides its
 `stream.actor.estimatedCost` (`humanish.actor-estimated-cost.v1`), kept distinct
 from the reserved provider-returned `tokenUsage.costUsd`. See
 [`schemas.md`](schemas.md) → Run Cost Summary And Estimated Actor Cost.
@@ -532,11 +534,11 @@ in-progress bundle that can pass every check. When the run is not finished,
 `warnings[]` carries one entry starting with the stable code `RUN_NOT_FINISHED`.
 `ok` and `shareSafety` do not change. Verify decides "not finished" by the run
 index's rule, which the TUI and `humanish stats` use: the run's `status.json` when
-it is well formed and names the run, else a simulation still `running` in the
+it is well formed and names the run, else a `simulations[]` entry still `running` in the
 bundle. A `running` record updated within the stale window reads as still
 writing; an older one reads as interrupted. The warning names what verify saw:
 
-- the record's state and its last `updatedAt`, or the running simulations when
+- the record's state and its last `updatedAt`, or the running `simulations[]` entries when
   there is no usable record;
 - how many streams are still `running`;
 - what `reclaim-receipt.json` records: how many of the run's sandboxes are gone

package/docs/contracts/schemas.md

@@ -3,7 +3,7 @@
 Date: 2026-06-02 (current-state note updated 2026-07-14)
 
 Status: reference map for the major contracts shipped through source version
-`0.106.0`; it is not an exhaustive inventory of command/result envelopes. Exported types,
+`0.107.0`; it is not an exhaustive inventory of command/result envelopes. Exported types,
 schema constants, parsers, and validators in `src/` are authoritative. Rows
 marked "reserved" name layering intent only; no code emits or validates them
 yet. Do not emit a reserved schema.
@@ -117,7 +117,7 @@ A lab is a composition over code primitives, not a hardcoded kind:
   (invariant 5). `serve`/`clone`/`state`/`repos`/`appUrl` are rejected on a
   terminal-product subject (a field that cannot act on the route is a parse
   error, not silently dropped). See
-  [`docs/architecture/terminal-product-lane.md`](../architecture/terminal-product-lane.md);
+  [`docs/architecture/terminal-product-route.md`](../architecture/terminal-product-route.md);
 - `subject.state` (clone or local-tree subjects, computer-use route): the
   subject's state story. `state.seed[]` declares ordered, bounded
   seed/migration/fixture steps (`{ name, command, when: before-build |
@@ -172,7 +172,7 @@ dwell? }`. The parser expands it into
 - `execution.concurrency` (computer-use E2B routes, including shared-world): a
   CAP on participants in flight at once. When omitted, every participant runs
   simultaneously: independent participants resolve it from the final participant count,
-  after any `--count` override, and the parser fills `concurrency = laneCount`
+  after any `--count` override, and the parser fills `concurrency = participantCount`
   for multi-participant shared-world labs. Total sessions and spend are identical either way; only wall-clock
   and simultaneity differ. Declaring a value below the participant count runs participants in
   waves and emits a warning saying so, because a green waved run is otherwise
@@ -324,7 +324,12 @@ dwell? }`. The parser expands it into
   pass for a catch), the teardown drain over `GET /deliveries`, and the same
   digest-only evidence. `authTokenEnv` names an env var holding a bearer token
   for the drain read. The NAME is recorded as evidence; the value never
-  persists. Declaring `external` on a harness-provisioned subject warns: two
+  persists. A live run refuses a token shorter than 16 characters, or not
+  well-formed Unicode, before it probes the catch
+  (`HUMANISH_CUA_LAB_COMMS_TOKEN_INVALID`,
+  `HUMANISH_CONCURRENT_SHARED_WORLD_LAB_COMMS_TOKEN_INVALID`), as
+  `humanish comms catch --token` does, and scrubs the token and its encoded
+  forms from every comms warning. Declaring `external` on a harness-provisioned subject warns: two
   catches would exist and the app would point at humanish's own. `linkOrigin`
   is an optional operator-declared origin the app bakes into links when it
   differs from the serve origin; the harness rewrites captured links through it
@@ -396,13 +401,18 @@ where a dry-run participant is ok as contract evidence and a live participant mu
 error, engaged, and no self-reported blocker.
 
 Explicit failed-participant reruns are supported on the CUA fan-out route via
-`humanish lab run <lab> --rerun-failed-from <run-id> [--lanes lane-a,lane-b]`.
+`humanish lab run <lab> --rerun-failed-from <run-id> [--participants <ids>]`, where a
+participant id is a declared `actors[0].lanes[].id`, or `lane-01`, `lane-02`, … by position.
 The source run must be a live CUA fan-out bundle. humanish creates a NEW run for
 the selected failed/blocked/timed-out/hollow participants (or explicit participant ids), leaves
 the source verdict unchanged, and records lineage as `run.rerun` plus a
 `cua-lab.fanout.rerun` event: source run id, selected participant ids, and previous participant
 statuses/reasons. This is intentionally not automatic retry; a passing rerun is a
 nondeterminism candidate for human/product scoring, not a rewrite of the old run.
+Without `--participants`, a participant is selected when its stream's `judgedStatus` is not `passed`.
+That field is the judge's status (`judgedStatus` in `src/run/judge.ts`), so a goal_satisfied
+session that reported a blocker counts as blocked. A source bundle without `judgedStatus` falls back
+to the stream's trace status, its actor status and completion reason, and a zero-action check.
 
 Manifests are human-authored `.yaml` source under `humanish/labs/*.yaml` for
 committed public-safe labs, or ignored `.humanish/labs/*.yaml` /
@@ -558,7 +568,7 @@ feedbackCandidates: []
 ## Shared-World Evidence
 
 The shared-world topology (#164) is the DECLARED override of the `per-lane-worlds`
-default: N distinct actor ROLES drive ONE provisioned, mutable service plane (one
+default: N distinct participants drive ONE provisioned, mutable service plane (one
 app + one seeded DB) so their actions interact through shared state. The ONE
 subject plane is provisioned via `subject.source: clone` (a fresh `git clone`) or
 `subject.source: local-tree` (the operator's own working tree, packed on the host
@@ -603,8 +613,8 @@ cause, maxTotalUsd?, estimatedTotalUsd? }`. Each ordered `roles` entry names
     predecessor must have a matching `harness_error`, explicit `session_error`,
     `usage_unreported`, or measured `study_spend_limit`. Only the last cause
     carries budget figures, using the same per-participant estimates as the
-    tracker. Blocked participants need matching simulation, stream and blocked-event
-    evidence, with no actor, trace, screenshot or invented timeline turn.
+    tracker. Blocked participants need a matching `simulations[]` entry, stream and
+    blocked-event evidence, with no actor, trace, screenshot or invented timeline turn.
     Historical bundles without this field still require every role in the timeline.
   - `timeline: (checkpoint | turn)[]`: a harness-clocked, strictly alternating
     timeline that starts `cp-baseline`, alternates checkpoint → turn → checkpoint,
@@ -662,7 +672,7 @@ synthetic-subject gate); stateSeries snapshots are digest-only (allowed-keys tri
 all laneWindows share ONE plane provenance; and the CONCURRENCY-ON-PASS gate: a PASSED
 run MUST show ≥2 overlapping laneWindows AND a stateSeries delta whose timestamp is
 AT/AFTER an overlap interval start (otherwise it was not actually concurrent, or the
-world never changed under load). The per-role no-engagement guard applies to both.
+world never changed under load). The per-participant no-engagement guard applies to both.
 Checkpoints / stateSeries persist digest-only by DEFAULT until the #108 PII/PHI
 detector lands.
 
@@ -1076,14 +1086,39 @@ proof claims zero on a `null` line, or when known spend exceeds the declared cap
 `humanish.run-status.v1` is `status.json`, written inside each run directory by
 every backend at run start, refreshed on a fixed cadence while the run is
 alive, and finalized when it ends: `{ schema, runId, state: running |
-finished, mode, lab?, pid, startedAt, updatedAt, completedAt?, outcome? }`.
+finished | interrupted, mode, lab?, pid, startedAt, updatedAt, completedAt?,
+signal?, outcome? }`.
 `outcome` carries the bundle's `verdict`, `participants` and `estimatedCostUsd`
 when the run finishes, then the result's `ok` and `execution: { succeeded,
-failures: [{ kind, message }] }` once the Observer has rendered. The verdict is
-what the participants experienced; `execution` is whether the run worked as an
-execution (`kind` is `harness`, `provider-cleanup`, `sandbox-cleanup`,
-`evidence`, `cap` or `run`), and `ok` reads both under the route's policy
-(`OUTCOME_POLICIES` in `src/run/judge.ts`).
+failures: [{ kind, message }], warnings? }` once the Observer has rendered. The
+verdict is what the participants experienced; `execution` is whether the run
+worked as an execution (`kind` is `harness`, `provider-cleanup`,
+`provider-policy`, `sandbox-cleanup`, `evidence`, `cap` or `run`), and `ok`
+reads both under the route's policy (`OUTCOME_POLICIES` in `src/run/judge.ts`).
+`provider-policy` names a computer-use or shared-world participant whose Codex
+app-server reported a disallowed item at any point in the session, or whose
+output could not be checked (a byte, frame or event limit, a malformed line, or
+a last frame cut off by anything but humanish's own signal, which is a run
+warning with its byte count). It is recorded even when a request already failed for it,
+because a step that tolerates a failed request (the debrief) would otherwise
+absorb it, and it fails the run on every route.
+`warnings`, in the same shape, holds the failures the policy lets warn and is
+omitted when empty: on computer-use, shared-world and scripted runs, a
+`sandbox-cleanup` entry for each sandbox whose release was not confirmed, with
+the participant (or `subject`), the release warning and the
+`humanish reclaim --run <id>` command. A local VM writes no receipt, so its
+entry names the container and the `docker rm --force --volumes <container>`
+command that removes it (through `limactl shell` on a Mac).
+
+`interrupted` with `signal` (`SIGINT`, `SIGTERM` or `SIGHUP`) is written by
+the CLI's run command when that signal stops a live run outside post-run
+analysis. It then kills the E2B sandboxes the run's `sandbox-receipts.ndjson`
+names, writes `reclaim-receipt.json` as `humanish reclaim` does, and exits
+128+n. The bundle is not finished: run.json keeps its last live flush, and no
+`outcome` is written. A `running` record that stopped refreshing still reads as
+interrupted once stale. A library caller of `runLab` gets no signal handling. A
+humanish older than this field rejects the state and falls back to the bundle's
+own liveness.
 
 It answers two questions the filesystem could not answer before: **which lab**
 a run belongs to, and **whether it is still alive**, including for runs an
@@ -1170,7 +1205,9 @@ never authoritative: every dollar figure is a rate-table multiply, labeled
 - `humanish.actor-estimated-cost.v1` (`ActorTrace.estimatedCost`): one participant's
   token-derived model cost, with `estimatedCostUsd` (or `null` + `reason`
   `no_rate_for_model`/`no_token_usage`/`account_billing_unknown`), `ratesAsOf`, `source`, `modelId`,
-  optional `placeholder`, and a `breakdown`.
+  optional `placeholder`, and a `breakdown`. `basis: aggregated_turns_base_rate` marks usage that
+  arrived as turn totals, such as Codex `turn.completed`, priced at the base tier because no single
+  request's size is known; the run summary's `model-tokens` line carries the same `basis`.
 - `humanish.run-cost-summary.v1` (`RunBundle.cost`): the sum of every participant's
   `model-tokens` lines PLUS `desktop-minutes` lines. New independent CUA runs
   price each owned desktop separately; concurrent shared-world runs add one line per participant
@@ -1184,9 +1221,10 @@ never authoritative: every dollar figure is a rate-table multiply, labeled
   unconfirmed allocation adds `desktop_lifetime_incomplete` as a second null line.
   Live terminal-product runs emit the same summary: one `desktop-minutes` line for
   the E2B shell sandbox (its acquired-to-cleanup span and `e2b.getInfo` size) and
-  one `model-tokens` line for the Codex participant, which stays `null` with
-  `no_rate_for_model` (model `codex`) or `no_token_usage`. The terminal trace
-  records that same null `estimatedCost`. The sandbox line is not part of the
+  one `model-tokens` line for the Codex participant, priced from the model the route passed
+  to Codex (`gpt-5.6-sol` unless the lab declares one) with `basis:
+aggregated_turns_base_rate`, or `null` with `no_token_usage`. Older terminal bundles record
+  `no_rate_for_model` (model `codex`). The terminal trace records the same `estimatedCost`. The sandbox line is not part of the
   terminal cost ledger, whose lines are checked against `scenario.caps.maxUsd`.
 
 The summary follows the SAME null discipline as the terminal cost ledger above.
@@ -1321,9 +1359,9 @@ on, and any failed or stalled request stops the session; both stop with `harness
 `stopCause: usage_unreported`, and the label “provider usage unavailable.” It is not recorded as a
 crossed threshold. `singleDispatch: true` disables the OpenAI adapter's HTTP and
 policy-negotiation retries, so each turn makes at most one request.
-`runCuaActorSession({ requireReportedUsageForSpendCap: true })` sets `singleDispatch` itself and
-is deprecated in this minor. It also attaches `trace.estimatedCost` for an injected
-account-billed provider, which the composition does not. The loop cancels its owned request signal when a
+This composition replaces `runCuaActorSession`, which set `singleDispatch` itself and was removed
+in 0.107.0. Unlike `runCuaActorSession`, it attaches no `trace.estimatedCost` for an injected
+account-billed provider. The loop cancels its owned request signal when a
 request ends or its timeout wins; injected providers must honor cancellation
 and remain responsible for their own internal dispatch. Known usage remains in
 the trace alongside an explicit unknown. Reported zero input and output counts
@@ -1383,7 +1421,7 @@ refusal comes back in the route's own result envelope, with no run directory, re
 | Option                                   | What it does                                                                                                                                                                                                                                       | Routes                                                                                                                                                                  |
 | ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `env`                                    | Keys and subject env for the run. Defaults to `process.env`                                                                                                                                                                                        | all                                                                                                                                                                     |
-| `scorer`                                 | An `AdapterScorerModule` (`score`, `deriveFeedback`, and `deriveArtifacts` on browser routes) over the finished evidence                                                                                                                           | computer use, shared world, terminal                                                                                                                                    |
+| `scorer`                                 | An `AdapterScorerModule` (`score`, `deriveFeedback`, and `deriveArtifacts` on browser routes) over the finished evidence. A scorer written for one context passes through `browserScorer` or `terminalScorer`                                      | computer use, shared world, terminal                                                                                                                                    |
 | `createProvider(ctx)`                    | The participant's brain. `ctx` is `ProviderContext`: `config`, `participant { id, index, count }` and `executor`                                                                                                                                   | computer use: E2B, local VM or in process                                                                                                                               |
 | `inProcess.executor({ config, appUrl })` | Drives an `app-url` or `local-app` subject in process, one participant. Requires `createProvider`                                                                                                                                                  | computer use                                                                                                                                                            |
 | `prepareDesktop(desktop, target)`        | Runs on an E2B sandbox before provisioning. `target` is `{ kind: "subject" }` or `{ kind: "participant", participant }`                                                                                                                            | computer use on E2B (each participant); shared world (provisioned: the subject, then each participant; external-public: each participant); scripted clone (the subject) |
@@ -1410,41 +1448,59 @@ Refusals:
 
 - `HUMANISH_LAB_OPTION_UNSUPPORTED`: the route cannot honor the option, for example `scorer` on
   a preview or scripted lab, `createProvider` off computer use, or `prepareDesktop` where no E2B
-  desktop exists. The message names the option and the route.
-- `HUMANISH_LAB_OPTION_CONFLICT`: a new option is set together with the older field it replaces.
-
-The older route hook bags (`cuaHooks`, `scriptedHooks`, `terminalHooks`, `sharedWorldHooks`) and
-`rerun.laneIds` keep their behavior in this minor and are removed in the next. Each old field in
-use emits one `DeprecationWarning` (code `HUMANISH_RUN_LAB_OPTION_DEPRECATED`) per process:
-
-| Old field                                                                                          | New home               |
-| -------------------------------------------------------------------------------------------------- | ---------------------- |
-| `score`, `deriveFeedback` on `cuaHooks`, `sharedWorldHooks` or `terminalHooks`                     | `scorer`               |
-| `deriveArtifacts` on `cuaHooks` or `sharedWorldHooks`                                              | `scorer`               |
-| `cuaHooks.buildProvider`                                                                           | `createProvider`       |
-| `cuaHooks.buildExecutor`                                                                           | `inProcess.executor`   |
-| `prepareDesktop` on `cuaHooks`, `scriptedHooks` or `sharedWorldHooks`                              | `prepareDesktop`       |
-| `cuaHooks.onPreflight`; `onPhase` on `cuaHooks` or `sharedWorldHooks`; `automaticAnalysis.onStart` | `onEvent`              |
-| `onRuntimeStreamReady`, `onRuntimeStreamEnded` on `cuaHooks` or `sharedWorldHooks`                 | `onStream`             |
-| `automaticAnalysis.deps.signal`                                                                    | `analysisSignal`       |
-| `env` on any bag                                                                                   | `env`                  |
-| `rerun.laneIds`                                                                                    | `rerun.participantIds` |
-| `cuaHooks.createDesktopLane`                                                                       | none                   |
-
-`cuaHooks.createDesktopLane` warns and goes in the next minor with no replacement: a run's desktop
-is E2B, the local VM or in process. The bags' other fields are test seams with no public
-replacement, and they do not warn. A
-`scorer` passed through `RunLabOptions` behaves exactly like the same functions in the old bag,
-including the route-specific verdict rules in the next section.
+  desktop exists. The message names the option and the route. The same code refuses a field
+  `RunLabOptions` no longer has (below); that message names the field and where its job went.
+
+`rerun.laneIds`, the older name of `rerun.participantIds`, was removed in 0.107.0. A caller that
+still passes it is refused with `HUMANISH_LAB_OPTION_UNSUPPORTED`; use `rerun.participantIds`.
+
+The route hook bags (`cuaHooks`, `scriptedHooks`, `terminalHooks`, `sharedWorldHooks`,
+`automaticAnalysis`) were removed from `RunLabOptions`, with the hook bag types and the four route
+runners that took them (`runCuaActorLab`, `runScriptedBrowserLab`, `runTerminalProductLab`,
+`runConcurrentSharedWorld`). `lab` and `scorerProvenance` are set only by the humanish CLI. A
+JavaScript caller that passes any of these fields is refused before anything runs. Where each
+bag field's job went:
+
+| Removed field                                                                                      | Use                  |
+| -------------------------------------------------------------------------------------------------- | -------------------- |
+| `score`, `deriveFeedback` on `cuaHooks`, `sharedWorldHooks` or `terminalHooks`                     | `scorer`             |
+| `deriveArtifacts` on `cuaHooks` or `sharedWorldHooks`                                              | `scorer`             |
+| `cuaHooks.buildProvider`                                                                           | `createProvider`     |
+| `cuaHooks.buildExecutor`                                                                           | `inProcess.executor` |
+| `prepareDesktop` on `cuaHooks`, `scriptedHooks` or `sharedWorldHooks`                              | `prepareDesktop`     |
+| `cuaHooks.onPreflight`; `onPhase` on `cuaHooks` or `sharedWorldHooks`; `automaticAnalysis.onStart` | `onEvent`            |
+| `onRuntimeStreamReady`, `onRuntimeStreamEnded` on `cuaHooks` or `sharedWorldHooks`                 | `onStream`           |
+| `automaticAnalysis.deps.signal`                                                                    | `analysisSignal`     |
+| `env` on any bag                                                                                   | `env`                |
+| `cuaHooks.createDesktopLane`                                                                       | none                 |
+
+`cuaHooks.createDesktopLane` has no replacement: a run's desktop is E2B, the local VM or in
+process. The bags' other fields were test seams with no public replacement. `scorer` keeps the
+route-specific verdict rules in the next section.
+
+0.107.0 also removed these exports from `humanish`. A removed function no longer warns; an import
+of it fails.
+
+| Removed export                                                                                                                                 | Use                                                                                                                                                                                                                                                                                                                                    |
+| ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `runDryRun`, `RunOptions`, `RunResult`                                                                                                         | `runLab(config, options)` on a `this-repo` lab; its result is `LabResult<"preview">`                                                                                                                                                                                                                                                   |
+| `runCuaActorSession`                                                                                                                           | `runComputerUseLoop` with `createOpenAiResponsesProvider({ singleDispatch: true })`, `redaction: defaultRedactionHooks` and `now: Date.now`, which `runCuaActorSession` defaulted (the composition above). A caller that passed `desktop` and `executorOptions` writes its own `CuaExecutor`: the E2B desktop executor is not exported |
+| `CuaActorLabResult`, `ScriptedBrowserLabResult`, `TerminalProductLabResult`, `ConcurrentSharedWorldLabResult`                                  | `LabResult<"computer-use">`, `LabResult<"scripted">`, `LabResult<"terminal">`, `LabResult<"shared-world">`                                                                                                                                                                                                                             |
+| `SubjectPhaseEvent`                                                                                                                            | the `subject-phase` `LabEvent` through `onEvent`. Its `type` is `"subject-phase"`; the phase that was `type` is `name`, and `target` is `{ kind: "subject" }` or `{ kind: "participant", participant }`. `message`, `at`, `ok` and `durationMs` are unchanged                                                                          |
+| `LabOutcome.backend`, `LabBackend`                                                                                                             | `outcome.route`                                                                                                                                                                                                                                                                                                                        |
+| `selectLabBackend`, the `routesTo*` predicates, `actorResolvesToTerminal`                                                                      | `routeOf(config)`                                                                                                                                                                                                                                                                                                                      |
+| `resolveLabDryRun`                                                                                                                             | `RunLabOptions.dryRun`; without it, `scenario.mode` decides                                                                                                                                                                                                                                                                            |
+| `cuaLaneCount`                                                                                                                                 | the `plan` `LabEvent`, which lists every participant                                                                                                                                                                                                                                                                                   |
+| `resolveSeatUrl`                                                                                                                               | `parseLabConfig`, which refuses a participant entry that is not same-origin loopback; build the URL with `new URL(entry, serveUrl)`                                                                                                                                                                                                    |
+| `cuaLaneValidationReason`, `sharedWorldValidationReason`, `concurrentSharedWorldValidationReason`, `externalPublicSharedWorldValidationReason` | `parseLabConfig`, which returns the same reason                                                                                                                                                                                                                                                                                        |
+| `MAX_CUA_LANES`                                                                                                                                | none; `parseLabConfig` refuses a roster of more than 16 participants                                                                                                                                                                                                                                                                   |
 
 ## Product-Adapter Extension Seam
 
 The terminal-product and browser/computer-use routes let an adopter attach
 product-specific scoring + feedback as a THIN in-repo extension WITHOUT forking
 core. The seam is `RunLabOptions.scorer`, an `AdapterScorerModule`, for terminal-product,
-computer-use and shared-world runs; the CLI loads the same module with `--scorer`. The older
-`TerminalProductLabHooks`, `CuaActorLabHooks` and `SharedWorldLabHooks` fields still accept the
-same functions in this minor. This is never a built-in product scorer (the adopter's scorecard
+computer-use and shared-world runs; the CLI loads the same module with `--scorer`. This is never a built-in product scorer (the adopter's scorecard
 lives in the adopter's repo).
 
 Three product-agnostic carriers keep core's nouns closed while letting the adapter
@@ -1522,7 +1578,7 @@ terminal-agent candidate names its substrate honestly; browser candidates use
 the existing `e2b-desktop` substrate. The routes invoke hooks over FULLY-ASSEMBLED,
 redacted evidence (`TerminalProductScoringContext` or
 `BrowserLabScoringContext`: `bundle`, runtime-only `runDir`, run identifiers,
-actor/backend metadata; all exported public types), scrub+redact returned
+actor and route metadata; all exported public types), scrub+redact returned
 payloads, and DROP any malformed score, candidate, or artifact reference with a
 warning so a bad extension never poisons a verifiable bundle. On the terminal
 route the context also carries `transcript`: the FULL normalized session

package/docs/contracts/study-analysis.md

@@ -176,6 +176,30 @@ It never includes provider output, exception text, evidence values or IDs.
 Historical artifacts with the generic `analysis_validation_failed` code remain
 valid and unchanged.
 
+A rejected response is never stored in the run directory or in any shareable
+artifact. For diagnosis, humanish keeps it locally at
+`.humanish/analysis-diagnostics/<run>/<analysis>.json`
+(`humanish.analysis-rejected-output.v1`). The record holds:
+
+- the run and analysis IDs, the model and the prompt version;
+- the allowlisted code and every failed rule code;
+- the response, scrubbed. Every string and key loses known transient secret
+  values, including their percent-encoded, escaped and base64 forms, and then gets
+  shape redaction. A number or boolean equal to a known value is replaced. A
+  string with no known value keeps its original spelling.
+
+When validation ran, the response is the one validation saw, after the narrative
+scrub. A schema or scrub rejection keeps the parsed response. An unexpected
+validation exception keeps nothing.
+
+The directory sits outside every run directory, and export, verify and the
+Observer read only run directories. `humanish analyze` returns the file's path as
+`rejectedOutputPath` and prints it, and so does a lab run's automatic analysis.
+Each write removes all but the newest 20 records across runs. It removes a
+record only while its directory is still the listed one, so a directory
+replaced by a symlink after listing is left alone. The record's
+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

package/docs/decisions/0004-participant-desktops-stay-in-the-route.md

@@ -22,7 +22,8 @@ only the interface to `src/substrates/` would split one concept across two folde
 - A reader finds the desktop contract and its implementations in one folder, beside the runner
   that calls them.
 - `src/substrates/` stays free of route types; it does not import from `src/routes/`.
-- Shared-world seats reach the same desktops through computer-use's participant runner.
+- Shared-world participants reach the same desktops through computer-use's `runCuaParticipant`
+  (`src/routes/computer-use/participant-execution.ts`).
 
 ## Enforced by
 

package/docs/product/automatic-analysis.md

@@ -128,6 +128,7 @@ outcomes and the deterministic review verdict are never rewritten by analysis.
 | `AUTOMATIC_ANALYSIS_KEY_MISSING`              | `skipped`                 | No OpenAI API key                                                     |
 | `AUTOMATIC_ANALYSIS_NO_PARTICIPANT_EVIDENCE`  | `skipped`                 | A default analysis found no participant evidence                      |
 | `AUTOMATIC_ANALYSIS_ACTOR_CANCELLED`          | `skipped`                 | The harness cancelled the participants                                |
+| `AUTOMATIC_ANALYSIS_CLEANUP_UNCONFIRMED`      | `skipped`                 | A local VM study could not confirm its cleanup; the command exits 2   |
 | `AUTOMATIC_ANALYSIS_ALREADY_REQUESTED`        | `skipped`                 | Another request already claimed this run's analysis                   |
 | `AUTOMATIC_ANALYSIS_BUSY`                     | `skipped`                 | Another analysis is running                                           |
 | `AUTOMATIC_ANALYSIS_ADMISSION_REFUSED`        | `skipped`                 | The configuration or the cost estimate was refused before any request |

package/docs/ramp/README.md

@@ -288,7 +288,8 @@ adoption problem we already knew about in words no test could produce.
 
 This spends money and needs keys, so it is deliberately NOT part of `release:check`
 and never runs in CI. The lab's caps hold product spend to `$0`; what it costs is
-the agent's own tokens and a few sandbox-minutes. The agent's model key stays outside
+the agent's own tokens (on `gpt-5.6-sol` unless the lab names a model, estimated in `run.json`'s
+`cost`) and a few sandbox-minutes. The agent's model key stays outside
 the sandbox in an E2B egress rule (`runtimeAuth: openai-egress`), and its `web_search`
 fetches run on the model provider's side, so an error from one says nothing about the
 sandbox's network.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.106.0",
+  "version": "0.107.0",
   "description": "Open-source-safe CLI for persona simulation, observer review, and public-safe feedback drafts.",
   "keywords": [
     "agent-harness",
@@ -90,10 +90,10 @@
     "comms:agentmail:contract": "node --import tsx scripts/agentmail-contract-check.mjs",
     "format": "oxfmt",
     "format:check": "oxfmt --check",
-    "lint": "node scripts/check-lint-cap.mjs --max-warnings=444",
+    "lint": "node scripts/check-lint-cap.mjs --max-warnings=442",
     "knip": "knip",
-    "prose:check": "node scripts/check-code-prose.mjs --max-issue-refs=371 --max-fix-tags=23 --max-caps=1743",
-    "vocabulary:check": "tsx scripts/check-retired-words.ts --max-lane=188 --max-seat=6 --max-role=52 --max-sim=51 --max-study=287"
+    "prose:check": "node scripts/check-code-prose.mjs --max-issue-refs=357 --max-fix-tags=0 --max-caps=804 --max-lane-comments=20",
+    "vocabulary:check": "tsx scripts/check-retired-words.ts --max-lane=137 --max-seat=4 --max-role=52 --max-sim=33 --max-study=9"
   },
   "dependencies": {
     "commander": "^15.0.0",

package/skills/humanish/SKILL.md

@@ -361,7 +361,8 @@ 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.
+`authTokenEnv` is an environment variable name, never a credential value; its
+token must be at least 16 characters.
 The in-sandbox catch
 needs `python3` (the stock E2B desktop has it).
 Evidence is digest-only (`humanish.comms-thread.v1` — counts and digests, never
@@ -413,7 +414,7 @@ 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 a scripted-browser
+Do not use `humanish watch --count ...` 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.
 

package/skills/humanish/agents/openai.yaml

@@ -1,7 +1,7 @@
 interface:
   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 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."
+  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 --count` as app behavior proof."
 
 policy:
   allow_implicit_invocation: true