humanish 0.110.4 → 0.111.0

package/dist/study/study-fields.js

@@ -1,51 +1,46 @@
-// The study's fields, read in one place. StudyConfig still has the humanish.lab.v2 shape
-// (`actors[0]`, `execution.caps`, `scenario.mode`), while a humanish.study.v3 file names the same
-// values `actor`, `participants`, `surfaces`, `caps`, `mode`, `scenario` and `route`. Code outside
-// the parser reads them through these functions, and tests/surface/study-config-reads.test.ts
-// refuses a direct read, so the config can take the v3 shape by changing this file.
-/** The actor that runs. A v3 file declares it as `actor`. */
+// The study's fields, read in one place. Participants are the one read that is not a field: a v3
+// study declares them as a count, as `{ count, instruction }` or as a list, and the accessors below
+// read each form. tests/surface/study-config-reads.test.ts refuses a direct read of a humanish.lab.v2
+// field anywhere outside migrate.
+/** The actor that runs. */
 export function actorOf(config) {
-    return config.actors[0];
+    return config.actor;
 }
-/**
- * Every declared actor. parseStudy accepts exactly one; a library config may declare more, and the
- * checks that refuse a second actor's settings read them all.
- */
-export function actorsOf(config) {
-    return config.actors;
-}
-/** The participants listed one by one: a v3 `participants` list. Undefined when none is listed. */
+/** The participants listed one by one: a `participants` list. Undefined when none is listed. */
 export function participantList(config) {
-    return config.actors[0]?.lanes;
+    return Array.isArray(config.participants) ? config.participants : undefined;
 }
-/** The declared number of identical participants: v3 `participants: <n>` or `participants.count`. */
+/** The declared number of identical participants: `participants: <n>` or `participants.count`. */
 export function declaredParticipantCount(config) {
-    return config.actors[0]?.count;
+    const { participants } = config;
+    if (typeof participants === "number")
+        return participants;
+    return isGroup(participants) ? participants.count : undefined;
 }
-/** The steer each of a counted group of participants gets: v3 `participants.instruction`. */
+/** The steer each of a counted group of participants gets: `participants.instruction`. */
 export function participantInstruction(config) {
-    return config.actors[0]?.laneFocus?.instruction;
+    return isGroup(config.participants) ? config.participants.instruction : undefined;
 }
-/** How many scripted surfaces run, 1 for desktop and 2 with mobile. A v3 file lists `surfaces`. */
+/** How many scripted surfaces run, 1 for desktop and 2 with mobile. */
 export function surfaceCount(config) {
-    return config.actors[0]?.count;
+    return config.surfaces?.length;
 }
-/** The declared run mode. A v3 file declares it as `mode`. */
+/** The declared run mode. */
 export function modeOf(config) {
-    return config.scenario?.mode;
+    return config.mode;
 }
-/** The scripted route's scenario id or path. A v3 file declares it as `scenario`. */
+/** The scripted route's scenario id or path. */
 export function scenarioRefOf(config) {
-    return config.scenario?.ref;
+    return config.scenario;
 }
-/**
- * The spend caps a route enforces. A v3 file declares them as `caps`. The v2 shape keeps them in
- * `execution.caps` on computer use and shared world, and in `scenario.caps` on terminal.
- */
-export function capsOf(config, route) {
-    return route === "terminal" ? config.scenario?.caps : config.execution?.caps;
+/** The spend caps the route enforces. parseStudy refuses a key the route does not read. */
+export function capsOf(config) {
+    return config.caps;
 }
-/** True when the participants share one app. A v3 file declares `route: shared-world`. */
+/** True when the participants share one app: `route: shared-world`. */
 export function declaresSharedWorld(config) {
-    return config.subject.topology === "shared-world";
+    return config.route === "shared-world";
+}
+function isGroup(participants) {
+    return typeof participants === "object" && participants !== null && !Array.isArray(participants);
 }

package/dist/study/summary.js

@@ -18,7 +18,7 @@ import { inspectStudyManifest } from "./discover.js";
 import { isComputerUseComposition } from "./routing.js";
 import { probeKeySources } from "../keys/key-resolution.js";
 import { receivingRequiredKey } from "../comms/setup.js";
-import { actorOf, participantList, declaredParticipantCount, capsOf } from "./study-fields.js";
+import { actorOf, participantList, declaredParticipantCount, capsOf, surfaceCount, } from "./study-fields.js";
 export const STUDY_SUMMARY_SCHEMA = "humanish.study-summary.v1";
 /**
  * The effort every participant will run at, or `"per-lane"` when they differ. A participant that declares nothing
@@ -54,7 +54,12 @@ function participantsOf(config) {
         .map((entry) => entry.persona)
         .filter((persona) => typeof persona === "string");
     const personas = rosterPersonas.length > 0 ? rosterPersonas : actor.persona === undefined ? [] : [actor.persona];
-    const count = declaredParticipantCount(config) ?? participantList(config)?.length ?? personas.length ?? 1;
+    // A scripted study's participants are its surfaces, one replay on each.
+    const count = declaredParticipantCount(config) ??
+        surfaceCount(config) ??
+        participantList(config)?.length ??
+        personas.length ??
+        1;
     const unique = [...new Set(personas)];
     if (unique.length === 0)
         return `${count} participant${count === 1 ? "" : "s"}`;
@@ -62,11 +67,11 @@ function participantsOf(config) {
     // are named, because which personas are in a study is the study's design.
     return unique.length === 1 ? `${count} × ${unique[0]}` : unique.join(" · ");
 }
-/** The computer-use caps; `execution.caps` is inert on other routes, so none is drawn there. */
+/** The computer-use caps. Other routes draw none. */
 function summaryCapsOf(config) {
     if (!isComputerUseComposition(config))
         return {};
-    const caps = capsOf(config, "computer-use");
+    const caps = capsOf(config);
     return {
         ...(typeof caps?.maxUsd === "number" ? { laneUsd: caps.maxUsd } : {}),
         ...(typeof caps?.maxTotalUsd === "number" ? { studyUsd: caps.maxTotalUsd } : {}),

package/dist/study/types.d.ts

@@ -3,7 +3,6 @@ import type { StudyTask } from "./tasks.js";
 import type { DwellWindow, StopWhen } from "../actors/stop-conditions.js";
 import { type ReasoningEffort } from "../actors/reasoning-effort.js";
 import type { StudyRoute } from "./routing.js";
-export declare const V2_SCHEMA = "humanish.lab.v2";
 /** The study format: it declares its route, one actor, its participants and one caps block. */
 export declare const STUDY_SCHEMA = "humanish.study.v3";
 export declare const ID_PATTERN: RegExp;
@@ -18,16 +17,6 @@ export declare const ID_PATTERN: RegExp;
  * error, never a desktop attempt. See docs/architecture/state-driven-executor.md.
  */
 type StudySubjectSource = "this-repo" | "clone" | "app-url" | "local-app" | "terminal-product" | "desktop-cli" | "local-tree";
-/**
- * How a subject's world relates across participants. `per-lane-worlds` (the default; absent ==
- * this) is the only fan-out topology the computer-use route ships: N participants, N independent
- * worlds, isolation + per-participant attribution. `shared-world` is the declared override: one
- * mutable service plane that N participants use at the same time, so their actions interact through
- * shared state. Consumed only on the shared-world routes (a provisioned clone plane, or an
- * external-public app-url plane) with a computer-use actor; inert/warned everywhere else
- * (claims match mechanism).
- */
-type StudySubjectTopology = "per-lane-worlds" | "shared-world";
 export interface StudySubjectClone {
     /** git clone depth; 1 (shallow) by default. Consumed on the computer-use clone route. */
     depth?: number;
@@ -189,26 +178,18 @@ export interface StudySubjectProduct {
 }
 export interface StudySubject {
     source: StudySubjectSource;
-    /**
-     * World topology across participants. Absent == `per-lane-worlds` (the isolation default; every
-     * existing study is byte-stable). `shared-world` is the declared override: one mutable service
-     * plane, N participants at once, each in its role. Consumed only on the shared-world routes (a
-     * provisioned clone or an external-public app-url plane, a computer-use actor, and a roster of ≥2
-     * participants); inert/warned elsewhere.
-     */
-    topology?: StudySubjectTopology;
     /**
      * Concurrent shared-world route only: the author's required attestation that the
      * subject behind the internet-reachable `getHost` URL is synthetic seeded data. The concurrent
      * route exposes the subject on a tokenless public URL for the run's duration, so real/external
      * data must never sit behind it. This is author-trust + a provenance gate (verify also requires
      * `subject.state.provenance == "seeded"`). It does not guarantee the data is synthetic. Required when
-     * `topology: shared-world` + `execution.concurrency > 1`; inert/warned elsewhere.
+     * `route: shared-world` + `execution.concurrency > 1`; inert/warned elsewhere.
      */
     exposure?: "synthetic";
     /**
      * External-public shared-world route only: the author's required ownership
-     * attestation when a real public deployment (`source: app-url` + `topology: shared-world` +
+     * attestation when a real public deployment (`source: app-url` + `route: shared-world` +
      * `concurrency > 1` + `policies.allowPublicTargets: true`) is used directly as the shared plane.
      * The harness neither provisions nor exposes this target (no getHost, no clone, no seed), so it
      * cannot attest the data is synthetic; instead the operator must attest they own/operate it.
@@ -276,12 +257,6 @@ export interface StudySubject {
      */
     localTree?: StudySubjectLocalTree;
 }
-export interface StudyParticipantFocus {
-    id?: string;
-    label?: string;
-    /** Per-participant steer appended to the actor's mission. Consumed on the app-url route. */
-    instruction?: string;
-}
 /**
  * One participant in a differentiated fan-out on the computer-use E2B route (`per-lane-worlds`).
  * Each entry becomes an independent E2B desktop sandbox with its own persona/device/starting-steer. All
@@ -294,7 +269,7 @@ export interface StudyParticipantEntry {
     id?: string;
     /**
      * App-defined actor type label for grouping simulated users ("operator", "viewer",
-     * "maintainer", etc.). It is separate from the execution actor dispatch key (`actors[0].type`);
+     * "maintainer", etc.). It is separate from the execution actor dispatch key (`actor.type`);
      * it is adapter-owned taxonomy for roster/readback.
      */
     actorType?: string;
@@ -302,7 +277,7 @@ export interface StudyParticipantEntry {
     surface?: string;
     /** App-defined correlation id tying participants to one shared case/account/work item. */
     caseGroup?: string;
-    /** Persona id/label threaded into this participant's actor prompt. Default: actors[0].persona. */
+    /** Persona id/label threaded into this participant's actor prompt. Default: actor.persona. */
     persona?: string;
     /** Named hosted-screen preset for this participant. XOR raw execution.desktop.resolution. */
     device?: string;
@@ -345,17 +320,6 @@ export interface StudyParticipantEntry {
      */
     host?: boolean;
 }
-/**
- * Compact authoring sugar for repeated participant groups. The parser expands each group into concrete
- * `lanes[]` with deterministic ids (`<group.id>-01`, `<group.id>-02`, ...). The runtime never
- * consumes this shape directly; it always sees ordinary `LabActorLane` entries.
- */
-export interface StudyActorRosterGroup extends Omit<StudyParticipantEntry, "id"> {
-    /** Public-safe group id; prefixes generated participant ids. */
-    id: string;
-    /** Number of participants to generate for this group. */
-    count: number;
-}
 export interface StudyActor {
     /**
      * The actor label. On computer-use (including shared-world), scripted-browser, and
@@ -365,18 +329,8 @@ export interface StudyActor {
      * the descriptor for dispatch and capability enforcement.
      */
     type: string;
-    /** Participant count, route-specific (see the scope header in config.ts): synthetic simCount; scripted
-     *  surface roster {1 = desktop, 2 = desktop + mobile, default 1}; computer-use E2B route the
-     *  homogeneous fan-out participant count (cap 16). XOR `lanes`. */
-    count?: number;
-    /** Computer-use E2B route: a differentiated fan-out roster (`per-lane-worlds`). XOR `count`,
-     *  `roster`, and `laneFocus`. Cap 16 participants. Consumed only on the cua E2B route
-     *  (inert/warned elsewhere). */
-    lanes?: StudyParticipantEntry[];
     /** Persona id/label threaded into the actor prompt. Consumed on the app-url route. */
     persona?: string;
-    /** Consumed on the app-url route (laneFocus.instruction appended to the mission). XOR `lanes`. */
-    laneFocus?: StudyParticipantFocus;
     /** Free-form mission threaded into the actor prompt. Consumed on the app-url route. A mission on
      *  its own is a complete, valid study; `tasks` is additive, never required. */
     mission?: string;
@@ -404,7 +358,7 @@ export interface StudyActor {
      */
     localAgent?: "codex" | "claude";
     /**
-     * How hard the model is asked to think, per turn. A `lanes[]` entry's `reasoningEffort` overrides this.
+     * How hard the model is asked to think, per turn. A `participants` entry's `reasoningEffort` overrides this.
      *
      * Absent means the provider's default, and absence is recorded as absence: a run that did not
      * declare an effort does not claim one. Support is model-dependent (see src/actors/reasoning-effort.ts),
@@ -419,12 +373,12 @@ export interface StudyActor {
      */
     reasoningEffort?: ReasoningEffort;
     /**
-     * Deterministic completion guard used as the default for CUA participants. A `lanes[]` entry's stopWhen
+     * Deterministic completion guard used as the default for CUA participants. A `participants` entry's stopWhen
      * overrides this value.
      */
     stopWhen?: StopWhen;
     /**
-     * A declared observation window, the default for every participant; a `lanes[]` entry's dwell overrides
+     * A declared observation window, the default for every participant; a `participants` entry's dwell overrides
      * it. `when` is a stopWhen-shaped condition (absent: the window opens after the first
      * observation); `ms` is the hold, `everyMs` the frame cadence (default 10 s), `then` whether
      * the participant continues afterwards (default) or the session ends. The harness takes no
@@ -545,20 +499,6 @@ export interface StudyExecution {
      */
     concurrency?: number;
     desktop?: StudyExecutionDesktop;
-    /**
-     * Blast-radius budget for each computer-use participant. Consumed on the computer-use route:
-     * `caps.maxUsd`, when set, is a fail-closed abort: the session stops the moment its running
-     * estimated spend crosses it (the runaway-retry guard), and a cap on a model src/run/pricing.ts
-     * cannot price is refused at preflight rather than run uncapped. It is a per-participant cap:
-     * enforced inside each participant's loop, so an N-participant fan-out can spend up to N × maxUsd
-     * before any participant aborts (the run warns with the true ~N × cap ceiling).
-     * `caps.maxTotalUsd` is the shared study budget: one ledger across every participant, the knob a
-     * researcher actually reasons with. Absent = uncapped (the historical CUA behavior); maxUsd: 0
-     * still permits a request before reported usage trips it. Inert (warned) on non-computer-use
-     * routes. Reuses the same StudyScenarioCaps shape as the terminal route's `scenario.caps` (not a
-     * fork).
-     */
-    caps?: StudyScenarioCaps;
     /** `terminal-product` route: the terminal transport + stdin posture. Consumed on that route. */
     terminal?: StudyExecutionTerminal;
     /** `terminal-product` route: runtime key placement, defaulting to openai-egress, an external
@@ -584,48 +524,45 @@ export interface StudyExecution {
      */
     egressAllow?: string[];
 }
-type StudyScenarioMode = "dry-run" | "live";
+type StudyMode = "dry-run" | "live";
 /**
- * The blast-radius budget for a route that passes a live key to an in-sandbox command.
- * Per the safety contract, the live key is never exercised without a fail-closed cap in force.
- * All values are non-negative numbers (0 is the no-spend default). Live runs require maxUsd and a
- * positive maxMinutes; maxUsd/maxJobs are checked after the session against known ledger signals
- * and maxMinutes is enforced as the command wall clock. Codex tokens are unpriced, so a live run
- * refuses a positive maxUsd unless a costProbe measures spend (HUMANISH_TERMINAL_UNPRICED_CAP).
+ * A study's spend, job and time caps, the top-level `caps` block. Each route reads its own keys, and
+ * parseStudy refuses a key the route does not read. All values are non-negative numbers.
+ *
+ * Computer use and shared world read `maxUsd` and `maxTotalUsd`. `maxUsd`, when set, is a
+ * fail-closed abort for each participant: the session stops the moment its running estimated spend
+ * crosses it (the runaway-retry guard), and a cap on a model src/run/pricing.ts cannot price is
+ * refused at preflight rather than run uncapped. It is enforced inside each participant's loop, so
+ * an N-participant fan-out can spend up to N × maxUsd before any participant aborts (the run warns
+ * with the true ~N × cap ceiling). Absent = uncapped; maxUsd: 0 still permits a request before
+ * reported usage trips it.
+ *
+ * The terminal route passes a live key to an in-sandbox command, and per the safety contract the
+ * live key is never exercised without a fail-closed cap in force. It reads `maxUsd`, `maxJobs` and
+ * `maxMinutes` (0 is the no-spend default). Live runs require maxUsd and a positive maxMinutes;
+ * maxUsd/maxJobs are checked after the session against known ledger signals and maxMinutes is
+ * enforced as the command wall clock. Codex tokens are unpriced, so a live run refuses a positive
+ * maxUsd unless a costProbe measures spend (HUMANISH_TERMINAL_UNPRICED_CAP).
  */
-export interface StudyScenarioCaps {
+export interface StudyCaps {
     /** Max USD the run may spend (provider + product). 0 = no-spend. */
     maxUsd?: number;
     /**
      * study-level model-spend budget, the number a researcher actually reasons with: "this
      * study is N participants, roughly $X", decided once, up front, where recruiting decisions are
-     * made. The computer-use route reads it from `execution.caps.maxTotalUsd` only: every participant's
-     * running estimated model spend feeds one shared ledger, and the moment the run total crosses
-     * this, each participant stops at its next turn with `budget_reached` (status `incomplete`:
-     * the participant ran out of budget; never `gave_up`, because a study-level stop is not the
-     * participant's doing). Estimated model spend only; desktop-minutes ride the cost summary but
-     * not this ledger. Independent of the per-participant `maxUsd` backstop; either, both, or neither may
-     * be set. A positive `scenario.caps.maxTotalUsd` on a computer-use study is a parse error; on the
-     * terminal route it is inert (warned), since the single agent's maxUsd already caps the run.
+     * made. Computer use and shared world only: every participant's running estimated model spend
+     * feeds one shared ledger, and the moment the run total crosses this, each participant stops at
+     * its next turn with `budget_reached` (status `incomplete`: the participant ran out of budget;
+     * never `gave_up`, because a study-level stop is not the participant's doing). Estimated model
+     * spend only; desktop-minutes ride the cost summary but not this ledger. Independent of the
+     * per-participant `maxUsd` backstop; either, both, or neither may be set.
      */
     maxTotalUsd?: number;
-    /** Max billable product jobs the agent may trigger. 0 = none. */
+    /** Terminal: max billable product jobs the agent may trigger. 0 = none. */
     maxJobs?: number;
-    /** Max wall-clock minutes for the agent session. */
+    /** Terminal: max wall-clock minutes for the agent session. */
     maxMinutes?: number;
 }
-export interface StudyScenario {
-    /** Reference a committed scenario by id (humanish/scenarios/<ref>.yaml) or path. Consumed
-     *  (and required) on the scripted-browser route; forward-declared elsewhere. */
-    ref?: string;
-    /** Or inline the scenario body. Forward-declared: no route reads it yet, so a set value warns. */
-    inline?: Record<string, unknown>;
-    /** dry-run = a synthetic bundle with no provider spend; live = real run. Consumed. */
-    mode?: StudyScenarioMode;
-    /** Spend/job/time caps. Consumed (recorded in the bundle) on the terminal-product route;
-     *  inert (warned) elsewhere. */
-    caps?: StudyScenarioCaps;
-}
 export interface StudyPolicies {
     /**
      * Redact target repo labels in durable artifacts. Consumed on the computer-use,
@@ -722,7 +659,7 @@ export interface StudyCommsReceivingEmail {
 interface StudyCommsCaptureEmail {
     connection?: never;
     allowedOrigins?: never;
-    /** Which implementation backs the inbox (a backend discriminator, distinct from `scenario.mode`):
+    /** Which implementation backs the inbox (a backend discriminator, distinct from `mode`):
      *  `fake` (default) is an in-harness in-memory inbox in the Fowler test-double sense: an in-sandbox
      *  catch captures the app's sends. Provider-backed receiving uses the separate
      *  StudyCommsReceivingEmail configuration selected by a saved connection. */
@@ -789,45 +726,28 @@ export interface StudyCommsRecipient {
      *  for the persona surface's default address (not drain-matched). */
     address?: string;
 }
-export interface StudyConfig {
-    /** The format the file was written in. Both parse into this one shape. */
-    schema: typeof V2_SCHEMA | typeof STUDY_SCHEMA;
-    id: string;
-    title?: string;
-    description?: string;
-    subject: StudySubject;
-    actors: StudyActor[];
-    execution?: StudyExecution;
-    /** Forward-declared: no route reads it yet, so a set value warns. */
-    personas?: Record<string, unknown>[];
-    scenario?: StudyScenario;
-    policies?: StudyPolicies;
-    review?: StudyReview;
-    defaults?: StudyDefaults;
-    comms?: StudyComms;
-}
 /**
- * A humanish.study.v3 file as src/study/parse/study.ts reads it: the declared route, one actor, its
- * participants and one caps block. It has the keys the file has. parseStudy still returns the
- * StudyConfig above.
+ * A humanish.study.v3 study as parseStudy returns it, with the keys the file has: the declared
+ * route, one actor, its participants and one caps block.
  */
-export interface StudyV3 {
+export interface StudyConfig {
     schema: typeof STUDY_SCHEMA;
     id: string;
     title?: string;
     description?: string;
+    /** The route the study declares. parseStudy refuses one its subject and actor do not take. */
     route: StudyRoute;
     /** Absent: a dry run. */
-    mode?: StudyScenarioMode;
-    subject: Omit<StudySubject, "topology">;
-    actor: Omit<StudyActor, "count" | "lanes" | "laneFocus">;
+    mode?: StudyMode;
+    subject: StudySubject;
+    actor: StudyActor;
     /** Preview, computer-use and shared-world, in the form the file used. */
     participants?: StudyParticipants;
     /** Scripted only. */
     surfaces?: StudySurfaces;
     /** The caps keys the route reads. */
-    caps?: StudyScenarioCaps;
-    execution?: Omit<StudyExecution, "caps">;
+    caps?: StudyCaps;
+    execution?: StudyExecution;
     /** Scripted: a committed scenario id or path. */
     scenario?: string;
     policies?: StudyPolicies;
@@ -836,15 +756,17 @@ export interface StudyV3 {
     comms?: StudyComms;
 }
 /**
- * A count, a count with one instruction for every participant, or a list. A list entry with a
- * `count` is expanded into its participants, `<id>-01` to `<id>-NN`.
+ * A count, a count with one instruction for every participant, or a list. parseStudy expands a list
+ * entry with a `count` into its participants, `<id>-01` to `<id>-NN`.
  */
 type StudyParticipants = number | StudyParticipantGroup | StudyParticipantEntry[];
-interface StudyParticipantGroup {
+/** `participants` as identical participants that share one instruction. */
+export interface StudyParticipantGroup {
     count?: number;
     instruction?: string;
 }
-type StudySurfaces = readonly ["desktop"] | readonly ["desktop", "mobile"];
+/** The scripted surfaces: desktop, or desktop and mobile. */
+export type StudySurfaces = readonly ["desktop"] | readonly ["desktop", "mobile"];
 interface StudyParseSuccess {
     ok: true;
     config: StudyConfig;

package/dist/study/types.js

@@ -1,6 +1,5 @@
 import {} from "../analysis/automatic-config.js";
 import {} from "../actors/reasoning-effort.js";
-export const V2_SCHEMA = "humanish.lab.v2";
 /** The study format: it declares its route, one actor, its participants and one caps block. */
 export const STUDY_SCHEMA = "humanish.study.v3";
 // Must start alphanumeric so an id never collides with the path-vs-id resolver heuristic

package/dist/study/url-credentials.js

@@ -1,8 +1,7 @@
 // Every URL a study config declares, checked for a credential. Route planners call it, since a
 // library caller's config skips the parser that refuses these first.
-import { rosterOf } from "./parse/actors.js";
 import { entryCredentialReason, urlCredentialReason } from "./parse/url-credentials.js";
-import { actorsOf } from "./study-fields.js";
+import { participantList } from "./study-fields.js";
 /**
  * The first URL in `config` that carries a credential, with why: the subject's app, serve and
  * public surface URLs, and each participant's target and entry.
@@ -17,14 +16,14 @@ export function studyUrlCredentialReason(config) {
             ? undefined
             : urlCredentialReason("subject.serve.url", subject.serve.url),
         ...(subject.product?.publicSurfaces ?? []).map((surface) => () => urlCredentialReason("subject.product.publicSurfaces", surface)),
-        ...actorsOf(config).flatMap((actor) => (rosterOf(actor) ?? []).flatMap((participant, index) => [
+        ...(participantList(config) ?? []).flatMap((participant, index) => [
             () => participant.target === undefined
                 ? undefined
                 : urlCredentialReason(`participants[${index}].target`, participant.target),
             () => participant.entry === undefined
                 ? undefined
                 : entryCredentialReason(`participants[${index}].entry`, participant.entry),
-        ])),
+        ]),
     ];
     for (const reason of reasons) {
         const found = reason();

package/dist/study/validation.d.ts

@@ -7,7 +7,7 @@ import type { StudyConfig } from "./types.js";
  */
 export declare function computerUseValidationReason(config: StudyConfig): string | null;
 /**
- * Cross-validate a `topology: shared-world` declaration. Returns the failure message, or
+ * Cross-validate a `route: shared-world` declaration. Returns the failure message, or
  * null when the one shared-world route can run it: the external-public checks for an app-url
  * subject, the provisioned checks otherwise. Enforced at parse and again by the route, since
  * runStudyWith takes a config that skipped the parser.
@@ -34,14 +34,6 @@ export declare function taskProtocolValidationReason(config: StudyConfig, suppor
  * at parse and again on the computer-use and scripted-browser routes for library callers.
  */
 export declare function cloneTargetValidationReason(config: StudyConfig): string | null;
-/**
- * Refuse a positive `scenario.caps.maxUsd` or `maxTotalUsd` on a computer-use study.
- * `scenario.caps` belongs to the terminal route; the computer-use route stops on `execution.caps`,
- * so a dollar figure here would read as a cap while the study ran uncapped. Zero spends nothing
- * either way and stays a warning. Enforced at parse and again on the computer-use routes for
- * library callers.
- */
-export declare function scenarioCapsValidationReason(config: StudyConfig): string | null;
 /** Refuse a claimed output bound when the route cannot pass it to the first-party provider. */
 export declare function outputTokenLimitValidationReason(config: StudyConfig): string | null;
 /**
@@ -60,7 +52,7 @@ export declare function concurrentSharedWorldValidationReason(config: StudyConfi
  * it rejects every provisioned-subject field (serve/state.seed/state.checkpoint/exposure/clone/repos
  * are inert with no sandbox, so they fail closed), and requires a
  * non-loopback appUrl + allowPublicTargets + the operator-ownership attestation subject.publicTarget +
- * concurrency >= 2 + an actors[0].lanes roster of ≥2 with exactly one host participant. The getHost synthetic
+ * concurrency >= 2 + a `participants` list of ≥2 with exactly one host participant. The getHost synthetic
  * gate is deliberately unreachable here (there is no internet-reachable harness-owned URL to attest).
  * Enforced at parse and re-enforced in the engine (runStudyWith takes a config that skipped the parser).
  */