humanish 0.110.4 → 0.111.1

package/dist/study/plan-base.js

@@ -1,7 +1,6 @@
 // What every route planner shares: the plan fields common to all routes, the frozen residual config,
 // and the requirement and subject helpers.
 import { DEFAULT_OPENAI_CU_MODEL } from "../actors/computer-use/openai-provider.js";
-import { actorOf, capsOf } from "./study-fields.js";
 // A YAML alias can make a parsed record contain itself (an inline persona that names its own
 // anchor), and structuredClone keeps the cycle, so each object is frozen once.
 function deepFreeze(value, frozen = new WeakSet()) {
@@ -14,11 +13,10 @@ function deepFreeze(value, frozen = new WeakSet()) {
     return value;
 }
 function residualOf(config) {
-    const { comms, policies, personas, defaults, review } = config;
+    const { comms, policies, defaults, review } = config;
     return deepFreeze(structuredClone({
         ...(comms === undefined ? {} : { comms }),
         ...(policies === undefined ? {} : { policies }),
-        ...(personas === undefined ? {} : { personas }),
         ...(defaults === undefined ? {} : { defaults }),
         ...(review === undefined ? {} : { review }),
         ...(config.execution?.desktop === undefined && config.execution?.target === undefined
@@ -44,8 +42,8 @@ function residualOf(config) {
 export function isNonEmpty(values) {
     return values.length > 0;
 }
-export function planCaps(config, route) {
-    const caps = capsOf(config, route);
+export function planCaps(config) {
+    const caps = config.caps;
     return {
         ...(caps?.maxUsd === undefined ? {} : { maxUsd: caps.maxUsd }),
         ...(caps?.maxTotalUsd === undefined ? {} : { maxTotalUsd: caps.maxTotalUsd }),
@@ -87,7 +85,7 @@ export function desktopRequirements(config, args) {
     return requirements;
 }
 export function brainOf(config, callerProvider) {
-    const actor = actorOf(config);
+    const actor = config.actor;
     if (callerProvider)
         return callerBrainOf(config);
     const declared = declaredModelOf(config);
@@ -100,7 +98,7 @@ export function callerBrainOf(config) {
     return { kind: "caller", ...declaredModelOf(config) };
 }
 function declaredModelOf(config) {
-    const model = actorOf(config)?.model;
+    const model = config.actor?.model;
     return model === undefined ? {} : { declaredModel: model };
 }
 /** The model a participant's spend is priced at when its provider reports none. */

package/dist/study/plan-participants.d.ts

@@ -9,7 +9,7 @@ export interface Participant {
     readonly id: string;
     /** 0-based position in the roster. Bundle `sim-NNN` and `stream-NNN` ids derive from it. */
     readonly index: number;
-    /** `lanes[i].persona ?? actors[0].persona`. The route compiles the committed persona file. */
+    /** `participants[i].persona ?? actor.persona`. The route compiles the committed persona file. */
     readonly personaId: string | undefined;
     /** The declared mission and per-participant focus. An absent mission takes the route's default. */
     readonly assignment: {
@@ -30,7 +30,7 @@ interface DesktopParticipant extends Participant {
         readonly preset: DevicePreset;
         readonly resolution: [number, number];
     };
-    /** The `lanes[]` entry's value, else actor value, else absent (the provider default is recorded in the trace). */
+    /** The `participants` entry's value, else actor value, else absent (the provider default is recorded in the trace). */
     readonly limits: {
         readonly stopWhen?: StopWhen;
         readonly dwell?: DwellWindow;

package/dist/study/plan-participants.js

@@ -2,9 +2,9 @@
 // Computer-use and shared-world participants share the desktop fields; each kind adds its own.
 import { resolveParticipantDevice } from "./device-presets.js";
 import { isSharedWorldComposition, participantIdAt } from "./routing.js";
-import { actorOf, participantList, declaredParticipantCount, participantInstruction, } from "./study-fields.js";
+import { participantList, declaredParticipantCount, participantInstruction, } from "./study-fields.js";
 function desktopParticipant(config, entry, index, kind, focus) {
-    const actor = actorOf(config);
+    const actor = config.actor;
     const device = resolveParticipantDevice(config, entry?.device);
     const personaId = entry?.persona ?? actor?.persona;
     const mission = actor?.mission;
@@ -39,7 +39,7 @@ function desktopParticipant(config, entry, index, kind, focus) {
  * override (`--count`) applies only when no roster is declared.
  */
 export function computerUseParticipants(config, countOverride) {
-    const actor = actorOf(config);
+    const actor = config.actor;
     const roster = participantList(config);
     const count = roster
         ? roster.length

package/dist/study/plan-types.d.ts

@@ -8,7 +8,7 @@ import type { RunStudyProvenance } from "../run/study-provenance.js";
 import type { ComputerUseRefusal } from "../routes/computer-use/plan.js";
 import type { SharedWorldRefusal } from "../routes/shared-world/plan.js";
 import type { ComputerUseParticipant, ExternalPublicParticipant, ProvisionedParticipant } from "./plan-participants.js";
-import type { StudyConfig, StudyExecutionTerminal, StudyRuntimeAuth, StudyScenarioCaps, StudySubjectProduct, StudySubjectServe, StudySubjectState, StudySubjectStateCheckpoint } from "./types.js";
+import type { StudyConfig, StudyExecutionTerminal, StudyRuntimeAuth, StudyCaps, StudySubjectProduct, StudySubjectServe, StudySubjectState, StudySubjectStateCheckpoint } from "./types.js";
 export type NonEmpty<T> = readonly [T, ...T[]];
 type AtLeastTwo<T> = readonly [T, T, ...T[]];
 /**
@@ -48,7 +48,7 @@ export type Requirement = {
  * VM study read it before a plan exists. Shared world, terminal and scripted still read some config
  * fields at run time.
  */
-export type ResidualConfig = Pick<StudyConfig, "comms" | "policies" | "personas" | "defaults" | "review"> & {
+export type ResidualConfig = Pick<StudyConfig, "comms" | "policies" | "defaults" | "review"> & {
     readonly execution?: Pick<NonNullable<StudyConfig["execution"]>, "desktop" | "target">;
     readonly subject: Pick<StudyConfig["subject"], "clone" | "localTree" | "repos" | "envValues">;
 };
@@ -63,6 +63,8 @@ interface PlanBase {
     /** The study's declared title, which bundles record. */
     readonly title?: string;
     readonly study?: RunStudyProvenance;
+    /** Warnings about the study's own fields, which the run records in its bundle as warn events. */
+    readonly warnings?: readonly string[];
     /** A frozen copy owned by the plan. */
     readonly residual: Readonly<ResidualConfig>;
     readonly dryRun: boolean;
@@ -83,7 +85,7 @@ interface PreviewPlan extends PlanBase {
 }
 /**
  * The model driving a desktop participant. `caller` is the library caller's createProvider.
- * `declaredModel` is actors[0].model as the study wrote it, absent when undeclared: the providers
+ * `declaredModel` is actor.model as the study wrote it, absent when undeclared: the providers
  * take it as written, and spend is priced at it, else the default (pricedModel). An openai
  * brain's `model` is the one its provider runs, with that default applied.
  */
@@ -229,10 +231,10 @@ export type TerminalPlan = PlanBase & {
     readonly stdin?: NonNullable<StudyExecutionTerminal["stdin"]>;
 } & ({
     readonly dryRun: true;
-    readonly caps?: StudyScenarioCaps;
+    readonly caps?: StudyCaps;
 } | {
     readonly dryRun: false;
-    readonly caps: StudyScenarioCaps & {
+    readonly caps: StudyCaps & {
         readonly maxUsd: number;
         readonly maxMinutes: number;
     };

package/dist/study/plan.js

@@ -1,5 +1,5 @@
 // The route decision. A study's route follows from its composition (subject.source,
-// execution.target, the first actor's registered run kind, subject.topology), never from a
+// execution.target, the actor's registered run kind, `route: shared-world`), never from a
 // declared kind. This is the only function that decides it.
 import { resolveAutomaticAnalysis } from "../analysis/automatic-config.js";
 import { callerDrivingOf, planComputerUseStudy } from "../routes/computer-use/plan.js";
@@ -11,17 +11,18 @@ import { THIS_REPO_DRY_RUN_ONLY } from "./composition-rules.js";
 import { planBase } from "./plan-base.js";
 import { routeOf } from "./routing.js";
 import { automaticAnalysisRouteReason, taskProtocolValidationReason } from "./validation.js";
-import { declaredParticipantCount, modeOf } from "./study-fields.js";
+import { declaredParticipantCount } from "./study-fields.js";
+import { egressAllowIgnoredWarning } from "./warnings.js";
 export { routeOf } from "./routing.js";
 /** Resolve dry-run: explicit override wins, else the scenario mode, else the given fallback. */
 export function resolveStudyDryRun(config, override, fallback) {
     if (override !== undefined) {
         return override;
     }
-    if (modeOf(config) === "live") {
+    if (config.mode === "live") {
         return false;
     }
-    if (modeOf(config) === "dry-run") {
+    if (config.mode === "dry-run") {
         return true;
     }
     return fallback;
@@ -73,8 +74,13 @@ export function planStudy(config, options, deps = {}) {
     if (!result.ok)
         return result;
     // The manifest the CLI resolved enters the plan here and nowhere else; the routes read
-    // plan.study for the run's status record and bundle.
-    const plan = options.study === undefined ? result.plan : { ...result.plan, study: options.study };
+    // plan.study for the run's status record and bundle, and plan.warnings for its bundle events.
+    const warning = egressAllowIgnoredWarning(study);
+    const plan = {
+        ...result.plan,
+        ...(options.study === undefined ? {} : { study: options.study }),
+        ...(warning === undefined ? {} : { warnings: [warning] }),
+    };
     return { ok: true, planned: { plan } };
 }
 function planRoute(route, study, options, input, deps) {

package/dist/study/preflight-probes.js

@@ -25,7 +25,7 @@ export async function runPublicPreviewPreflight(ctx) {
             { name: "route", ok: false, message: routeError },
         ]);
     }
-    const rosterTargets = ctx.targets.filter((target) => target.kind === "actors[0].lanes[].target");
+    const rosterTargets = ctx.targets.filter((target) => target.kind === "participants[].target");
     const publicTargets = rosterTargets.length > 0
         ? rosterTargets
         : ctx.targets.filter((target) => target.kind === "subject.appUrl");
@@ -270,7 +270,7 @@ function targetUrlFor(config, target) {
     if (target.kind === "subject.appUrl" && config.subject.appUrl) {
         return config.subject.appUrl;
     }
-    if (target.kind === "actors[0].lanes[].target") {
+    if (target.kind === "participants[].target") {
         const rosterTarget = participantList(config)?.find((entry) => entry.target && digest(entry.target) === target.targetDigest)?.target;
         if (rosterTarget)
             return rosterTarget;

package/dist/study/preflight.d.ts

@@ -12,7 +12,7 @@ export interface StudyPreflightCheck {
 }
 export interface StudyPreflightTarget {
     label: string;
-    kind: "subject.appUrl" | "actors[0].lanes[].target" | "subject.serve.url" | "subject.product.publicSurface";
+    kind: "subject.appUrl" | "participants[].target" | "subject.serve.url" | "subject.product.publicSurface";
     targetDigest: string;
     originDigest?: string;
     loopback: boolean;

package/dist/study/preflight.js

@@ -84,7 +84,7 @@ function collectTargets(config) {
     }
     for (const [index, entry] of (participantList(config) ?? []).entries()) {
         if (entry.target) {
-            targets.push(makeTarget(`actors[0].lanes[${index}].target`, "actors[0].lanes[].target", entry.target));
+            targets.push(makeTarget(`participants[${index}].target`, "participants[].target", entry.target));
         }
     }
     if (config.subject.serve?.url) {

package/dist/study/routing.d.ts

@@ -9,8 +9,8 @@ export declare function registeredScriptedBrowserActors(): string[];
 export declare function actorResolvesToTerminal(type: string | undefined): boolean;
 export declare function registeredTerminalActors(): string[];
 /**
- * The declared fan-out participant count on the computer-use route: a `lanes[]` roster's length, else
- * a homogeneous `count`, else 1. The single source of truth shared by the parser, the engine,
+ * The declared fan-out participant count on the computer-use route: a `participants` list's
+ * length, else a participant count, else 1. The single source of truth shared by the parser, the engine,
  * and the pre-flight plan so the participant count is computed the same way everywhere.
  */
 export declare function computerUseParticipantCount(config: StudyConfig): number;
@@ -36,15 +36,15 @@ export declare function isComputerUseComposition(config: StudyConfig): boolean;
  * `shared-world` topology. Mirror of isComputerUseComposition; the single source of truth shared by
  * routeOf (which checks it before the computer-use route) and the warning logic. Every
  * shared-world study runs its participants at once (`execution.concurrency` >= 2). The same
- * clone/local-tree × e2b-desktop × computer-use composition without `topology: shared-world` stays per-lane-worlds
- * (the computer-use route); the topology declaration is the override switch.
+ * clone/local-tree × e2b-desktop × computer-use composition without `route: shared-world` stays per-lane-worlds
+ * (the computer-use route); the route declaration is the override switch.
  */
 export declare function isSharedWorldComposition(config: StudyConfig): boolean;
 /** The getHost provisioned-subject shared-world shape (clone/local-tree served + exposed in-sandbox). */
 export declare function isProvisionedSharedWorldComposition(config: StudyConfig): boolean;
 /**
  * The external-public shared-world shape: a real public deployment used directly as
- * the shared plane: `source: app-url` + `topology: shared-world` + a computer-use actor on
+ * the shared plane: `source: app-url` + `route: shared-world` + a computer-use actor on
  * e2b-desktop + `policies.allowPublicTargets: true`. No getHost, no clone, no subject sandbox, no
  * seed. The operator-ownership attestation `subject.publicTarget` is required (validated in
  * externalPublicSharedWorldValidationReason, not here; this predicate is the router only, so a

package/dist/study/routing.js

@@ -1,6 +1,6 @@
 import { actorRegistry } from "../actors/registry.js";
 import { isLoopbackUrl } from "./parse/subject.js";
-import { actorOf, participantList, declaredParticipantCount, declaresSharedWorld, } from "./study-fields.js";
+import { participantList, declaredParticipantCount } from "./study-fields.js";
 // Hard cap on computer-use participants. No setting raises it: each participant is a paid desktop,
 // and they all run at once.
 export const MAX_COMPUTER_USE_PARTICIPANTS = 16;
@@ -46,8 +46,8 @@ export function registeredTerminalActors() {
     return registeredActorsOn("terminal");
 }
 /**
- * The declared fan-out participant count on the computer-use route: a `lanes[]` roster's length, else
- * a homogeneous `count`, else 1. The single source of truth shared by the parser, the engine,
+ * The declared fan-out participant count on the computer-use route: a `participants` list's
+ * length, else a participant count, else 1. The single source of truth shared by the parser, the engine,
  * and the pre-flight plan so the participant count is computed the same way everywhere.
  */
 export function computerUseParticipantCount(config) {
@@ -74,7 +74,7 @@ export function isComputerUseComposition(config) {
     // local-app drives the cua loop in-process (a custom executor + a non-vision provider), so it
     // routes to the computer-use route exactly like an app-url subject with a computer-use actor.
     if (config.subject.source === "app-url" || config.subject.source === "local-app") {
-        return actorResolvesToComputerUse(actorOf(config)?.type);
+        return actorResolvesToComputerUse(config.actor?.type);
     }
     // desktop-cli hands the participant a terminal instead of a served page, but it is the
     // same route: same desktop, same actor, same prompt fields. Leaving it out of this predicate told
@@ -82,13 +82,13 @@ export function isComputerUseComposition(config) {
     // person reads a screen.
     if (config.subject.source === "desktop-cli") {
         return ((config.execution?.target === undefined || config.execution.target === "e2b-desktop") &&
-            actorResolvesToComputerUse(actorOf(config)?.type));
+            actorResolvesToComputerUse(config.actor?.type));
     }
     // local-tree packs+uploads the working tree, then serves it exactly like a computer-use clone
     // subject: same e2b-desktop + computer-use-actor gate.
     return ((config.subject.source === "clone" || config.subject.source === "local-tree") &&
         config.execution?.target === "e2b-desktop" &&
-        actorResolvesToComputerUse(actorOf(config)?.type));
+        actorResolvesToComputerUse(config.actor?.type));
 }
 /**
  * True when this config routes to the shared-world route: a clone or local-tree subject
@@ -96,8 +96,8 @@ export function isComputerUseComposition(config) {
  * `shared-world` topology. Mirror of isComputerUseComposition; the single source of truth shared by
  * routeOf (which checks it before the computer-use route) and the warning logic. Every
  * shared-world study runs its participants at once (`execution.concurrency` >= 2). The same
- * clone/local-tree × e2b-desktop × computer-use composition without `topology: shared-world` stays per-lane-worlds
- * (the computer-use route); the topology declaration is the override switch.
+ * clone/local-tree × e2b-desktop × computer-use composition without `route: shared-world` stays per-lane-worlds
+ * (the computer-use route); the route declaration is the override switch.
  */
 export function isSharedWorldComposition(config) {
     return (isProvisionedSharedWorldComposition(config) || isExternalPublicSharedWorldComposition(config));
@@ -105,13 +105,13 @@ export function isSharedWorldComposition(config) {
 /** The getHost provisioned-subject shared-world shape (clone/local-tree served + exposed in-sandbox). */
 export function isProvisionedSharedWorldComposition(config) {
     return ((config.subject.source === "clone" || config.subject.source === "local-tree") &&
-        declaresSharedWorld(config) &&
+        config.route === "shared-world" &&
         config.execution?.target === "e2b-desktop" &&
-        actorResolvesToComputerUse(actorOf(config)?.type));
+        actorResolvesToComputerUse(config.actor?.type));
 }
 /**
  * The external-public shared-world shape: a real public deployment used directly as
- * the shared plane: `source: app-url` + `topology: shared-world` + a computer-use actor on
+ * the shared plane: `source: app-url` + `route: shared-world` + a computer-use actor on
  * e2b-desktop + `policies.allowPublicTargets: true`. No getHost, no clone, no subject sandbox, no
  * seed. The operator-ownership attestation `subject.publicTarget` is required (validated in
  * externalPublicSharedWorldValidationReason, not here; this predicate is the router only, so a
@@ -120,9 +120,9 @@ export function isProvisionedSharedWorldComposition(config) {
  */
 export function isExternalPublicSharedWorldComposition(config) {
     return (config.subject.source === "app-url" &&
-        declaresSharedWorld(config) &&
+        config.route === "shared-world" &&
         config.execution?.target === "e2b-desktop" &&
-        actorResolvesToComputerUse(actorOf(config)?.type) &&
+        actorResolvesToComputerUse(config.actor?.type) &&
         config.policies?.allowPublicTargets === true);
 }
 /**
@@ -159,12 +159,12 @@ export function isScriptedBrowserComposition(config) {
     return (isLocalScriptedBrowserComposition(config) || isProvisionedScriptedBrowserComposition(config));
 }
 function isLocalScriptedBrowserComposition(config) {
-    return (config.subject.source === "app-url" && actorResolvesToScriptedBrowser(actorOf(config)?.type));
+    return config.subject.source === "app-url" && actorResolvesToScriptedBrowser(config.actor?.type);
 }
 export function isProvisionedScriptedBrowserComposition(config) {
     return (config.subject.source === "clone" &&
         config.execution?.target === "e2b-desktop" &&
-        actorResolvesToScriptedBrowser(actorOf(config)?.type));
+        actorResolvesToScriptedBrowser(config.actor?.type));
 }
 /**
  * True when this config routes to the terminal-product backend: a terminal-product subject whose
@@ -173,7 +173,7 @@ export function isProvisionedScriptedBrowserComposition(config) {
  * the single source of truth for routeOf and the warning logic.
  */
 export function isTerminalProductComposition(config) {
-    return (config.subject.source === "terminal-product" && actorResolvesToTerminal(actorOf(config)?.type));
+    return (config.subject.source === "terminal-product" && actorResolvesToTerminal(config.actor?.type));
 }
 /**
  * The route a config takes. It never refuses: a config no route can run still gets the route

package/dist/study/run-study-options.d.ts

@@ -4,7 +4,7 @@ import type { StudyConfig } from "./types.js";
 import { type StudyEvent } from "./run-study-events.js";
 type Refusal = {
     ok: false;
-    code: "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED";
+    code: "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_STUDY_INVALID";
     message: string;
 };
 type Normalized = {

package/dist/study/run-study-options.js

@@ -7,7 +7,7 @@ import { isLocalBrowserStudy } from "../substrates/local/runtime-config.js";
 import { resolveStudyDryRun } from "./plan.js";
 import { knownSecretValues, studyEventEmitter } from "./run-study-events.js";
 import { studyResultIdentity } from "../run/study-result.js";
-import { actorOf, participantList } from "./study-fields.js";
+import { participantList } from "./study-fields.js";
 const unsupported = (option, route, reason) => ({
     ok: false,
     code: "HUMANISH_STUDY_OPTION_UNSUPPORTED",
@@ -105,7 +105,7 @@ export function normalizeRunStudyOptions(config, route, options) {
 export function optionRefusalOutcome(config, route, options, refusal) {
     const cwd = path.resolve(options.cwd);
     const error = { code: refusal.code, message: refusal.message };
-    const actor = actorOf(config)?.type ?? "";
+    const actor = config.actor?.type ?? "";
     const dryRun = resolveStudyDryRun(config, options.dryRun, true) ?? true;
     const runId = options.runId ?? "not-created";
     const common = { ok: false, cwd, actor, dryRun, runId, warnings: [], error };

package/dist/study/study-deps.d.ts

@@ -27,7 +27,7 @@ export interface StudyDeps {
     readonly subjectPhaseSink?: (event: SubjectPhaseEvent, participant?: ParticipantRef) => void;
     /**
      * Shared world: runs each participant's computer-use session in place of the actor's own. The
-     * planner reads whether it is set: a custom runner cannot enforce actors[0].maxOutputTokens.
+     * planner reads whether it is set: a custom runner cannot enforce actor.maxOutputTokens.
      */
     readonly runSession?: (options: CuaActorSessionOptions) => Promise<CuaLoopResult>;
     /**

package/dist/study/study-fields.d.ts

@@ -1,28 +1,7 @@
-import type { StudyRoute } from "./routing.js";
-import type { StudyActor, StudyConfig, StudyParticipantEntry, StudyScenario, StudyScenarioCaps } from "./types.js";
-/** The actor that runs. A v3 file declares it as `actor`. */
-export declare function actorOf(config: StudyConfig): StudyActor | undefined;
-/**
- * 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 declare function actorsOf(config: StudyConfig): readonly StudyActor[];
-/** The participants listed one by one: a v3 `participants` list. Undefined when none is listed. */
+import type { StudyConfig, StudyParticipantEntry } from "./types.js";
+/** The participants listed one by one: a `participants` list. Undefined when none is listed. */
 export declare function participantList(config: StudyConfig): readonly StudyParticipantEntry[] | 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 declare function declaredParticipantCount(config: StudyConfig): number | 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 declare function participantInstruction(config: StudyConfig): string | undefined;
-/** How many scripted surfaces run, 1 for desktop and 2 with mobile. A v3 file lists `surfaces`. */
-export declare function surfaceCount(config: StudyConfig): number | undefined;
-/** The declared run mode. A v3 file declares it as `mode`. */
-export declare function modeOf(config: StudyConfig): StudyScenario["mode"];
-/** The scripted route's scenario id or path. A v3 file declares it as `scenario`. */
-export declare function scenarioRefOf(config: StudyConfig): string | undefined;
-/**
- * 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 declare function capsOf(config: StudyConfig, route: Extract<StudyRoute, "computer-use" | "shared-world" | "terminal">): StudyScenarioCaps | undefined;
-/** True when the participants share one app. A v3 file declares `route: shared-world`. */
-export declare function declaresSharedWorld(config: StudyConfig): boolean;

package/dist/study/study-fields.js

@@ -1,51 +1,22 @@
-// 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`. */
-export function actorOf(config) {
-    return config.actors[0];
-}
-/**
- * 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 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 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;
-}
-/** How many scripted surfaces run, 1 for desktop and 2 with mobile. A v3 file lists `surfaces`. */
-export function surfaceCount(config) {
-    return config.actors[0]?.count;
-}
-/** The declared run mode. A v3 file declares it as `mode`. */
-export function modeOf(config) {
-    return config.scenario?.mode;
-}
-/** The scripted route's scenario id or path. A v3 file declares it as `scenario`. */
-export function scenarioRefOf(config) {
-    return config.scenario?.ref;
-}
-/**
- * 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;
+    return isGroup(config.participants) ? config.participants.instruction : undefined;
 }
-/** True when the participants share one app. A v3 file declares `route: shared-world`. */
-export function declaresSharedWorld(config) {
-    return config.subject.topology === "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 { participantList, declaredParticipantCount } 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
@@ -26,7 +26,7 @@ export const STUDY_SUMMARY_SCHEMA = "humanish.study-summary.v1";
  * reported as the resolved value, exactly as `model` reports its default rather than hiding it.
  */
 function reasoningEffortOf(config) {
-    const fallback = actorOf(config)?.reasoningEffort ?? DEFAULT_OPENAI_CU_REASONING_EFFORT;
+    const fallback = config.actor?.reasoningEffort ?? DEFAULT_OPENAI_CU_REASONING_EFFORT;
     const roster = participantList(config) ?? [];
     const resolved = new Set(roster.map((entry) => entry.reasoningEffort ?? fallback));
     if (resolved.size > 1)
@@ -47,14 +47,19 @@ function subjectOf(config) {
 }
 /** How many participants, and who; collapsed when they are all the same persona. */
 function participantsOf(config) {
-    const actor = actorOf(config);
+    const actor = config.actor;
     if (actor === undefined)
         return undefined;
     const rosterPersonas = (participantList(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) ??
+        config.surfaces?.length ??
+        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 = config.caps;
     return {
         ...(typeof caps?.maxUsd === "number" ? { laneUsd: caps.maxUsd } : {}),
         ...(typeof caps?.maxTotalUsd === "number" ? { studyUsd: caps.maxTotalUsd } : {}),
@@ -134,7 +139,7 @@ export async function readStudySummary(cwd, study, options = {}) {
         : undefined;
     const participantReadiness = options.checkKeys === true &&
         isLocalBrowserStudy(inspected.config) &&
-        actorOf(inspected.config)?.type === "local-agent"
+        inspected.config.actor?.type === "local-agent"
         ? await localCodexParticipantCheck({ env: options.env ?? process.env })
         : undefined;
     return {
@@ -161,7 +166,7 @@ export async function readStudySummary(cwd, study, options = {}) {
         ...(typeof config.description === "string" ? { description: config.description.trim() } : {}),
         ...(subject === undefined ? {} : { subject }),
         ...(participants === undefined ? {} : { participants }),
-        model: actorOf(inspected.config)?.model ?? DEFAULT_OPENAI_CU_MODEL,
+        model: inspected.config.actor?.model ?? DEFAULT_OPENAI_CU_MODEL,
         reasoningEffort: reasoningEffortOf(inspected.config),
         caps: summaryCapsOf(inspected.config),
         ...(keysReady === undefined ? {} : { keysReady }),