humanish 0.108.0 → 0.109.0

package/dist/routes/computer-use/participant-prompt.d.ts

@@ -1,7 +1,7 @@
 import type { ActorPersonaRef } from "../../actors/contract.js";
-import type { DevicePreset } from "../../lab/device-presets.js";
-import { type ResolvedPersona } from "../../lab/persona.js";
-import { type LabTask } from "../../lab/tasks.js";
+import type { DevicePreset } from "../../study/device-presets.js";
+import { type ResolvedPersona } from "../../study/persona.js";
+import { type StudyTask } from "../../study/tasks.js";
 import type { DesktopParticipantRun } from "./types.js";
 export declare const DEFAULT_MISSION = "You are testing a web application. The browser is already open at the subject URL. Explore it, accomplish what the scenario asks, and stop when done.";
 /**
@@ -21,9 +21,9 @@ export declare function composeParticipantInstructions(args: {
     mission: string;
     persona?: string;
     instruction?: string;
-    /** The lab's declared protocol. Only the participant-facing `goal` halves are rendered
+    /** The study's declared protocol. Only the participant-facing `goal` halves are rendered
      *  into the prompt; the `success` criteria never appear here. */
-    tasks?: readonly LabTask[];
+    tasks?: readonly StudyTask[];
     device: {
         name: string;
         preset: DevicePreset;

package/dist/routes/computer-use/participant-prompt.js

@@ -3,8 +3,8 @@
 // the email inbox at run time. Shared by the computer-use and concurrent shared-world routes.
 import { recipientInboxUrl } from "../../comms/capture-surface.js";
 import { digestText } from "../../evidence/redaction.js";
-import { personaBrief, personaToDirectives, renderPersonaPromptSection, } from "../../lab/persona.js";
-import { renderTaskPrompt } from "../../lab/tasks.js";
+import { personaBrief, personaToDirectives, renderPersonaPromptSection, } from "../../study/persona.js";
+import { renderTaskPrompt } from "../../study/tasks.js";
 export const DEFAULT_MISSION = "You are testing a web application. The browser is already open at the subject URL. Explore it, accomplish what the scenario asks, and stop when done.";
 /**
  * The participant's outcome as one fixed first line of its last message. The
@@ -28,7 +28,7 @@ export function composeParticipantInstructions(args) {
         : `You are a desktop user (${name}, ${preset.width}x${preset.height}).`;
     // The protocol as the participant reads it: numbered goals, nothing else. The success criteria
     // are the researcher's instrument and must never reach this prompt: a persona told how it will
-    // be measured optimizes for the measurement instead of using the product (src/lab/tasks.ts).
+    // be measured optimizes for the measurement instead of using the product (src/study/tasks.ts).
     const taskLines = renderTaskPrompt(args.tasks ?? []);
     // A resolved persona contributes its compiled directives (friction tolerance, skill bias,
     // accessibility behavior, constraints) through the same persona.ts compiler the terminal route

package/dist/routes/computer-use/participant-runs.d.ts

@@ -1,19 +1,19 @@
-import type { ComputerUsePlan } from "../../lab/plan-types.js";
-import { type LabConfig } from "../../lab/types.js";
-import { type ResolvedPersona } from "../../lab/persona.js";
+import type { ComputerUsePlan } from "../../study/plan-types.js";
+import { type StudyConfig } from "../../study/types.js";
+import { type ResolvedPersona } from "../../study/persona.js";
 import { type RunRerunLineage } from "../../run/bundle.js";
 import type { PreparedSelectedOutputDirectory } from "../../run/contained-output.js";
-import { type CuaActorLabErrorCode, type CuaParticipantPlan, type CuaParticipantPlanEntry, type DesktopParticipantRun } from "./types.js";
-export declare function defaultSessionTimeoutMs(config: LabConfig): number;
+import { type CuaActorStudyErrorCode, type CuaParticipantPlan, type CuaParticipantPlanEntry, type DesktopParticipantRun } from "./types.js";
+export declare function defaultSessionTimeoutMs(config: StudyConfig): number;
 /** Per-participant sandbox deadline (each one owns its own desktop). Mirrors the
  *  single-participant formula verbatim so N=1 stays byte-stable: explicit sandboxTimeoutMs, else session budget + (clone
  *  or local-tree: provision budget + Σ state-step budgets) + the server-side
  *  reclamation buffer. Local-tree shares the clone route's provisioning budget: it swaps a
  *  git clone for an upload+extract, but the shared install/build/state/start/probe pipeline
  *  costs the same wall-clock room either way. */
-export declare function resolveParticipantSandboxMs(config: LabConfig): number;
+export declare function resolveParticipantSandboxMs(config: StudyConfig): number;
 /**
- * The in-flight participant bound a lab declares. Defaults to the participant count: every
+ * The in-flight participant bound a study declares. Defaults to the participant count: every
  * declared participant runs at once, because a throttle nobody asked for silently turns "N actors
  * live" into waves; total session count and spend are the same either way, only wall-clock
  * and simultaneity differ. A declared execution.concurrency is a cap, clamped to [1, participants].
@@ -26,7 +26,7 @@ export declare function boundedConcurrency(declared: number | undefined, partici
  * sandbox-minutes, before any sandbox or provider call. The same plan appears in dry-run,
  * marked $0 (dryRun: true).
  */
-export declare function resolveCuaParticipantPlan(config: LabConfig, opts?: {
+export declare function resolveCuaParticipantPlan(config: StudyConfig, opts?: {
     countOverride?: number;
     env?: Record<string, string | undefined>;
     dryRun?: boolean;
@@ -34,7 +34,7 @@ export declare function resolveCuaParticipantPlan(config: LabConfig, opts?: {
 }): CuaParticipantPlan;
 /** Print the participant plan to stderr before any sandbox/provider call (public-safe: ids, devices,
  *  digests, and budgets only; no prompt text, no secrets). */
-export declare function emitPreflightPlan(participantPlan: CuaParticipantPlan, labId: string): void;
+export declare function emitPreflightPlan(participantPlan: CuaParticipantPlan, studyId: string): void;
 export declare function formatParticipantPlanEntry(entry: CuaParticipantPlanEntry): string;
 /**
  * Compile the committed persona files the participants use, printing a warning for each one that
@@ -60,7 +60,7 @@ export declare function loadCuaParticipants(args: {
     rerunLineage?: RunRerunLineage;
 } | {
     ok: false;
-    code: CuaActorLabErrorCode;
+    code: CuaActorStudyErrorCode;
     message: string;
 }>;
 /** Scrub known secret values from each participant's declarative snapshot before any bundle uses it. */

package/dist/routes/computer-use/participant-runs.js

@@ -1,23 +1,24 @@
-// The participant runs a computer-use lab drives, built before anything is created: the sandbox
+// The participant runs a computer-use study drives, built before anything is created: the sandbox
 // and session budgets, the concurrency bound, each participant's prompt, bundle ids and artifact
 // paths, and the public plan printed before any sandbox or provider call. loadCuaParticipants
 // compiles the committed personas first and narrows a rerun to its selected participants.
-import { isLocalBrowserLab, LOCAL_BROWSER_LIFETIME_MS, } from "../../substrates/local/runtime-config.js";
+import { isLocalBrowserStudy, LOCAL_BROWSER_LIFETIME_MS, } from "../../substrates/local/runtime-config.js";
 import { DEFAULT_STATE_STEP_TIMEOUT_MS } from "../../subject/state.js";
-import { computerUseParticipants, } from "../../lab/plan-participants.js";
+import { computerUseParticipants, } from "../../study/plan-participants.js";
 import { resolveParticipant } from "../../run/participant.js";
-import {} from "../../lab/types.js";
-import { scrubPersonaBrief } from "../../lab/persona.js";
+import {} from "../../study/types.js";
+import { scrubPersonaBrief } from "../../study/persona.js";
 import { redactText } from "../../evidence/redaction.js";
 import {} from "../../run/bundle.js";
-import { participantAssignment } from "../../lab/participant-assignment.js";
-import { resolveCommittedPersonas } from "../../lab/persona-resolve.js";
+import { participantAssignment } from "../../study/participant-assignment.js";
+import { resolveCommittedPersonas } from "../../study/persona-resolve.js";
 import { CUA_FANOUT_STRATEGY, CUA_MAX_CONCURRENCY_ENV, DEFAULT_APP_URL_SESSION_TIMEOUT_MS, MIN_DERIVED_SESSION_TIMEOUT_MS, } from "./types.js";
 import { MAX_SANDBOX_MS, SANDBOX_TIMEOUT_BUFFER_MS, SUBJECT_PROVISION_BUDGET_MS, } from "../../substrates/e2b/lifetime.js";
-import { readPositiveInt } from "../../lab/parse/values.js";
+import { readPositiveInt } from "../../study/parse/values.js";
 import { digestUrl } from "./bundle-parts.js";
 import { composeParticipantInstructions, DEFAULT_MISSION } from "./participant-prompt.js";
 import { resolveCuaRerunSelection } from "./rerun-selection.js";
+import { plural } from "../../run/text.js";
 export function defaultSessionTimeoutMs(config) {
     const provisionedRoute = config.subject.source === "clone" || config.subject.source === "local-tree";
     if (!provisionedRoute)
@@ -33,7 +34,7 @@ export function defaultSessionTimeoutMs(config) {
  *  git clone for an upload+extract, but the shared install/build/state/start/probe pipeline
  *  costs the same wall-clock room either way. */
 export function resolveParticipantSandboxMs(config) {
-    if (isLocalBrowserLab(config))
+    if (isLocalBrowserStudy(config))
         return LOCAL_BROWSER_LIFETIME_MS;
     const timeoutMs = config.execution?.timeoutMs ?? defaultSessionTimeoutMs(config);
     const provisionedRoute = config.subject.source === "clone" || config.subject.source === "local-tree";
@@ -46,7 +47,7 @@ export function resolveParticipantSandboxMs(config) {
             SANDBOX_TIMEOUT_BUFFER_MS);
 }
 /**
- * The in-flight participant bound a lab declares. Defaults to the participant count: every
+ * The in-flight participant bound a study declares. Defaults to the participant count: every
  * declared participant runs at once, because a throttle nobody asked for silently turns "N actors
  * live" into waves; total session count and spend are the same either way, only wall-clock
  * and simultaneity differ. A declared execution.concurrency is a cap, clamped to [1, participants].
@@ -173,9 +174,9 @@ export function resolveCuaParticipantPlan(config, opts = {}) {
 }
 /** Print the participant plan to stderr before any sandbox/provider call (public-safe: ids, devices,
  *  digests, and budgets only; no prompt text, no secrets). */
-export function emitPreflightPlan(participantPlan, labId) {
+export function emitPreflightPlan(participantPlan, studyId) {
     const lines = [];
-    lines.push(`humanish computer-use fan-out plan (${labId}): ${participantPlan.laneCount} participant(s), strategy ${participantPlan.strategy}, concurrency ${participantPlan.concurrency}${participantPlan.envLoweredConcurrencyFrom === undefined ? "" : ` (lowered from ${participantPlan.envLoweredConcurrencyFrom} by ${CUA_MAX_CONCURRENCY_ENV})`}, ${participantPlan.waves} wave(s).`);
+    lines.push(`humanish computer-use fan-out plan (${studyId}): ${plural(participantPlan.laneCount, "participant")}, strategy ${participantPlan.strategy}, concurrency ${participantPlan.concurrency}${participantPlan.envLoweredConcurrencyFrom === undefined ? "" : ` (lowered from ${participantPlan.envLoweredConcurrencyFrom} by ${CUA_MAX_CONCURRENCY_ENV})`}, ${plural(participantPlan.waves, "wave")}.`);
     lines.push(`  session budget ${Math.round(participantPlan.perLaneSessionBudgetMs / 1000)}s per participant; worst-case ~${participantPlan.worstCaseSandboxMinutes} sandbox-minutes total${participantPlan.dryRun ? " (dry-run: $0)" : ""}.`);
     for (const entry of participantPlan.lanes) {
         lines.push(`  - ${formatParticipantPlanEntry(entry)}`);
@@ -227,7 +228,7 @@ export async function loadCuaParticipants(args) {
         return { ok: true, participantRuns, participantPlan };
     const selected = await resolveCuaRerunSelection({
         cwd: args.cwd,
-        labId: plan.labId,
+        studyId: plan.studyId,
         sandboxMs: plan.sandboxMs,
         sourceRunId: rerun.sourceRunId,
         ...(rerun.participantIds === undefined ? {} : { participantIds: [...rerun.participantIds] }),

package/dist/routes/computer-use/plan.d.ts

@@ -1,9 +1,9 @@
 import { type CuaActorDescriptor } from "../../actors/registry.js";
-import type { ComputerUsePlan, ComputerUseRunner, RoutePlanResult, RouteRefusal } from "../../lab/plan-types.js";
-import type { LabConfig, LabSubjectState } from "../../lab/types.js";
-import { type CuaActorLabErrorCode, type RunCuaActorLabOptions } from "./types.js";
-/** The error a computer-use lab returns before a run starts. */
-export interface ComputerUseRefusal extends RouteRefusal<"computer-use", CuaActorLabErrorCode> {
+import type { ComputerUsePlan, ComputerUseRunner, RoutePlanResult, RouteRefusal } from "../../study/plan-types.js";
+import type { StudyConfig, StudySubjectState } from "../../study/types.js";
+import { type CuaActorStudyErrorCode, type RunCuaActorStudyOptions } from "./types.js";
+/** The error a computer-use study returns before a run starts. */
+export interface ComputerUseRefusal extends RouteRefusal<"computer-use", CuaActorStudyErrorCode> {
     /**
      * Where the route returns it. "before-scope": analysis and tasks, returned before the run scope
      * with no automatic-analysis record. "in-scope": after the cwd checks. "after-personas": after
@@ -15,7 +15,7 @@ export interface ComputerUseRefusal extends RouteRefusal<"computer-use", CuaActo
     readonly actor?: string;
 }
 export type ComputerUsePlanResult = RoutePlanResult<ComputerUsePlan, ComputerUseRefusal>;
-/** The registered descriptor for a planned actor id; planComputerUseLab checked the registry. */
+/** The registered descriptor for a planned actor id; planComputerUseStudy checked the registry. */
 export declare function cuaDescriptorOf(actor: string): CuaActorDescriptor;
 /** Which of the caller's driving homes, createProvider and inProcess, a run has. */
 export interface CallerDriving {
@@ -28,21 +28,21 @@ export declare function callerDrivingOf(options: {
     readonly createProvider?: unknown;
 }): CallerDriving;
 /** The state a planned run's provisioned subject declares. Other subjects declare none. */
-export declare function cuaDeclaredState(plan: ComputerUsePlan): LabSubjectState | undefined;
-/** The URL a refused lab's result names, from its declaration: a provisioned subject's serve URL. */
-export declare function declaredAppUrl(config: LabConfig): string;
+export declare function cuaDeclaredState(plan: ComputerUsePlan): StudySubjectState | undefined;
+/** The URL a refused study's result names, from its declaration: a provisioned subject's serve URL. */
+export declare function declaredAppUrl(config: StudyConfig): string;
 /** The URL a planned run's participants open: a provisioned subject's served URL, else its own. */
 export declare function plannedAppUrl(subject: ComputerUseRunner["subject"]): string;
 /**
- * Plan a computer-use lab. It is called for any config handed to the computer-use runner, not only
+ * Plan a computer-use study. It is called for any config handed to the computer-use runner, not only
  * one routeOf sends here, so a config for another route gets this route's refusal.
  */
-export declare function planComputerUseLab(config: LabConfig, input: {
+export declare function planComputerUseStudy(config: StudyConfig, input: {
     readonly dryRun: boolean;
     /** Whether deps.runSession is set: a caller's session runner cannot enforce maxOutputTokens. */
     readonly hasRunSession?: boolean;
     /** Which of the caller's driving homes are set; neither when absent. */
     readonly driving?: CallerDriving;
     readonly countOverride?: number;
-    readonly rerun?: RunCuaActorLabOptions["rerun"];
+    readonly rerun?: RunCuaActorStudyOptions["rerun"];
 }): ComputerUsePlanResult;

package/dist/routes/computer-use/plan.js

@@ -4,18 +4,18 @@
 // values, spend-cap prices and the comms catch.
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { actorRegistry, isCuaActorDescriptor, } from "../../actors/registry.js";
-import { isHttpUrl, isLoopbackUrl } from "../../lab/parse/subject.js";
-import { subjectStateInvalidReason } from "../../lab/parse/subject-state.js";
-import { brainOf, callerBrainOf, capsOf, desktopRequirements, planBase, provisionedSubject, } from "../../lab/plan-base.js";
-import { computerUseParticipants, declaredTargets } from "../../lab/plan-participants.js";
-import { MAX_COMPUTER_USE_PARTICIPANTS } from "../../lab/routing.js";
-import { cloneTargetValidationReason, computerUseValidationReason, desktopMediaValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, scenarioCapsValidationReason, taskProtocolValidationReason, } from "../../lab/validation.js";
-import { desktopCliProductReason } from "../../lab/composition-rules.js";
-import { isLocalBrowserLab } from "../../substrates/local/runtime-config.js";
+import { isHttpUrl, isLoopbackUrl } from "../../study/parse/subject.js";
+import { subjectStateInvalidReason } from "../../study/parse/subject-state.js";
+import { brainOf, callerBrainOf, capsOf, desktopRequirements, planBase, provisionedSubject, } from "../../study/plan-base.js";
+import { computerUseParticipants, declaredTargets } from "../../study/plan-participants.js";
+import { MAX_COMPUTER_USE_PARTICIPANTS } from "../../study/routing.js";
+import { cloneTargetValidationReason, computerUseValidationReason, desktopMediaValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, scenarioCapsValidationReason, taskProtocolValidationReason, } from "../../study/validation.js";
+import { desktopCliProductReason } from "../../study/composition-rules.js";
+import { isLocalBrowserStudy } from "../../substrates/local/runtime-config.js";
 import { boundedConcurrency, defaultSessionTimeoutMs, resolveParticipantSandboxMs, } from "./participant-runs.js";
 import { MAX_SANDBOX_MS } from "../../substrates/e2b/lifetime.js";
 import {} from "./types.js";
-/** The registered descriptor for a planned actor id; planComputerUseLab checked the registry. */
+/** The registered descriptor for a planned actor id; planComputerUseStudy checked the registry. */
 export function cuaDescriptorOf(actor) {
     const descriptor = actorRegistry[actor];
     if (!descriptor || !isCuaActorDescriptor(descriptor))
@@ -52,7 +52,7 @@ export function cuaDeclaredState(plan) {
     const { subject } = plan.runner;
     return subject.kind === "clone" || subject.kind === "local-tree" ? subject.state : undefined;
 }
-/** The URL a refused lab's result names, from its declaration: a provisioned subject's serve URL. */
+/** The URL a refused study's result names, from its declaration: a provisioned subject's serve URL. */
 export function declaredAppUrl(config) {
     const { subject } = config;
     const provisioned = subject.source === "clone" || subject.source === "local-tree";
@@ -69,11 +69,11 @@ const invalid = (message) => ({
     message,
 });
 /**
- * The first reason a computer-use lab cannot start, checked before any sandbox, key or provider
+ * The first reason a computer-use study cannot start, checked before any sandbox, key or provider
  * is touched. The parser enforces most of these too; the engine repeats them for library callers
  * that hand it a config directly. The groups run in this order, and each returns its first reason.
  */
-function cuaLabRejection(config, hasRunSession, driving, subjectRoute) {
+function cuaStudyRejection(config, hasRunSession, driving, subjectRoute) {
     return (unsupportedDeclarationReason(config, hasRunSession, driving, subjectRoute) ??
         subjectStructureReason(config, subjectRoute) ??
         entryTargetReason(config, subjectRoute) ??
@@ -112,15 +112,15 @@ function subjectStructureReason(config, subjectRoute) {
         return invalid(!serve
             ? "A clone subject on the computer-use route needs `subject.serve` (start and url): humanish starts the app in the sandbox before the participant opens it."
             : `subject.repos[0] must be an owner/repo slug (got "${subjectRepo ?? ""}").`);
-    // A library caller that skips parseLabConfig gets the same fail-closed shape the parser
+    // A library caller that skips parseStudy gets the same fail-closed shape the parser
     // enforces, naming which requirement is missing.
     if (localTreeRoute && (!serve || config.execution?.target !== "e2b-desktop"))
         return invalid(!serve
-            ? "local-tree subjects on the computer-use route require `subject.serve` (start + url): the lab packs and serves the working tree in-sandbox."
+            ? "local-tree subjects on the computer-use route require `subject.serve` (start + url): humanish packs and serves the working tree in the sandbox."
             : "local-tree subjects require `execution.target: e2b-desktop`: the packed working tree is provisioned and served inside a hosted desktop sandbox.");
     if (config.subject.state) {
         const stateReason = !provisionedRoute
-            ? "`subject.state` applies only to clone subjects or local-tree subjects (the lab seeds the state it serves)."
+            ? "`subject.state` applies only to clone subjects or local-tree subjects (humanish seeds the state it serves)."
             : subjectStateInvalidReason(config.subject.state, config.subject.env);
         if (stateReason)
             return invalid(stateReason);
@@ -165,7 +165,7 @@ function driverReason(driving, { localAppSubject, inProcessRoute }) {
     if (localAppSubject && !inProcessRoute)
         return {
             code: "HUMANISH_COMPUTER_USE_LOCAL_APP_NO_EXECUTOR",
-            message: "subject.source: local-app has no built-in driver. Supply one through runLab(config, { inProcess: { executor }, createProvider }); a state-driven executor needs a non-vision provider.",
+            message: "subject.source: local-app has no built-in driver. Supply one through runStudy(config, { inProcess: { executor }, createProvider }); a state-driven executor needs a non-vision provider.",
         };
     return undefined;
 }
@@ -176,7 +176,7 @@ function rosterShapeReason(config) {
     const fanoutReason = computerUseValidationReason(config);
     if (fanoutReason)
         return { code: "HUMANISH_COMPUTER_USE_FANOUT_INVALID", message: fanoutReason };
-    // The sandbox deadline is derived from the session budget, so a lab can ask for a session that
+    // The sandbox deadline is derived from the session budget, so a study can ask for a session that
     // cannot legally be provisioned. Show the arithmetic: the provider's own error names a limit
     // but not which knob produced it.
     const derivedSandboxMs = resolveParticipantSandboxMs(config);
@@ -192,10 +192,10 @@ function rerunPlan({ sourceRunId, participantIds, }) {
     return { sourceRunId, ...(participantIds === undefined ? {} : { participantIds }) };
 }
 /**
- * Plan a computer-use lab. It is called for any config handed to the computer-use runner, not only
+ * Plan a computer-use study. It is called for any config handed to the computer-use runner, not only
  * one routeOf sends here, so a config for another route gets this route's refusal.
  */
-export function planComputerUseLab(config, input) {
+export function planComputerUseStudy(config, input) {
     const hasRunSession = input.hasRunSession === true;
     const driving = input.driving ?? { inProcess: false, createProvider: false };
     const refuse = (stage, code, message, actor) => ({
@@ -220,16 +220,16 @@ export function planComputerUseLab(config, input) {
     if (!descriptor || !isCuaActorDescriptor(descriptor))
         return refuse("in-scope", "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered computer-use actor.`);
     const actor = descriptor.id;
-    const rejection = cuaLabRejection(config, hasRunSession, driving, declaredSubjectRoute(config, driving));
+    const rejection = cuaStudyRejection(config, hasRunSession, driving, declaredSubjectRoute(config, driving));
     if (rejection)
         return refuse("in-scope", rejection.code, rejection.message, actor);
     // A shared world runs every participant against one app; this route would run them as separate
     // participants. It comes after the rules above, so a shared-world config that breaks one of them,
-    // which runLab sends here, still gets that rule's message.
+    // which runStudyWith sends here, still gets that rule's message.
     if (config.subject.topology === "shared-world")
-        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "subject.topology: shared-world labs run every participant against one shared app on the shared-world route; runCuaActorLab runs independent participants. Run the lab with runLab or runConcurrentSharedWorld.", actor);
+        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "subject.topology: shared-world studies run every participant against one shared app on the shared-world route; this route runs independent participants. Run the study with runStudy or runConcurrentSharedWorld.", actor);
     // The in-process route drives subject.appUrl on this machine and creates no desktop, so it would
-    // skip the subject a clone, local-tree or desktop-cli lab declares.
+    // skip the subject a clone, local-tree or desktop-cli study declares.
     const source = config.subject.source;
     if (driving.inProcess &&
         (source === "clone" || source === "local-tree" || source === "desktop-cli"))
@@ -267,7 +267,7 @@ export function planComputerUseLab(config, input) {
             participants: [first],
             subject: source === "local-app" ? { kind: "local-app", appUrl } : appUrlSubject,
         }
-        : isLocalBrowserLab(config)
+        : isLocalBrowserStudy(config)
             ? { desktop: "local-vm", brain, participants: [first, ...rest], subject: appUrlSubject }
             : { desktop: "e2b-desktop", brain, participants: [first, ...rest], subject: hosted };
     const declared = config.execution?.concurrency;

package/dist/routes/computer-use/preflight.d.ts

@@ -1,6 +1,6 @@
-import type { Brain, ComputerUsePlan } from "../../lab/plan-types.js";
-import type { LabCommsExternal } from "../../lab/types.js";
-import type { CuaActorLabErrorCode } from "./types.js";
+import type { Brain, ComputerUsePlan } from "../../study/plan-types.js";
+import type { StudyCommsExternal } from "../../study/types.js";
+import type { CuaActorStudyErrorCode } from "./types.js";
 /**
  * The first reason a live computer-use run cannot start on this machine: missing keys, a missing
  * or signed-out local agent, missing subject env, a spend cap with no price, or an unreachable
@@ -14,8 +14,8 @@ export declare function liveCuaRejection(args: {
     env: Record<string, string | undefined>;
     /** The plan's requirements: which keys and subject env names this run needs. */
     requirements: ComputerUsePlan["requirements"];
-    externalCommsConfig: LabCommsExternal | undefined;
+    externalCommsConfig: StudyCommsExternal | undefined;
 }): Promise<{
-    code: CuaActorLabErrorCode;
+    code: CuaActorStudyErrorCode;
     message: string;
 } | undefined>;

package/dist/routes/computer-use/preflight.js

@@ -1,5 +1,5 @@
-import { pricedModel } from "../../lab/plan-base.js";
-import { missingKeys, missingSubjectEnv } from "../../lab/requirements.js";
+import { pricedModel } from "../../study/plan-base.js";
+import { missingKeys, missingSubjectEnv } from "../../study/requirements.js";
 import { detectLocalAgents } from "../../actors/local-agent/cli.js";
 import { localAgentRefusal } from "../../actors/local-agent/readiness.js";
 import { describeMissingKeys } from "../../keys/key-resolution.js";
@@ -40,10 +40,10 @@ export async function liveCuaRejection(args) {
             : "";
         return {
             code: "HUMANISH_COMPUTER_USE_KEYS_MISSING",
-            message: `Live computer-use labs need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}${suggestion}`,
+            message: `Live computer-use studies need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}${suggestion}`,
         };
     }
-    // A caller's createProvider makes the brain `caller`, so only the lab's own local agent is checked.
+    // A caller's createProvider makes the brain `caller`, so only the study's own local agent is checked.
     if (localAgent) {
         // Refuse here, before a sandbox exists. "codex is not installed" discovered after the
         // machine is paid for is the same information delivered at the worst possible moment.
@@ -74,7 +74,7 @@ export async function liveCuaRejection(args) {
             };
         }
     }
-    // Adopter-hosted comms catch: fail closed before any sandbox is created, because a comms lab
+    // Adopter-hosted comms catch: fail closed before any sandbox is created, because a comms study
     // whose catch is unreachable collects nothing while every participant still spends. The probe asserts
     // humanish's own service marker in /health, so an adopter's proxy answering 200 for everything cannot
     // pass for a catch.

package/dist/routes/computer-use/rerun-selection.d.ts

@@ -2,7 +2,7 @@ import { type RunRerunLineage } from "../../run/bundle.js";
 import type { CuaParticipantPlan, DesktopParticipantRun } from "./types.js";
 export declare function resolveCuaRerunSelection(args: {
     cwd: string;
-    labId: string;
+    studyId: string;
     sandboxMs: number;
     sourceRunId: string;
     participantIds?: string[];

package/dist/routes/computer-use/rerun-selection.js

@@ -3,6 +3,7 @@
 import {} from "../../run/bundle.js";
 import { loadRunBundle } from "../../run/locate.js";
 import {} from "../../run/streams.js";
+import { plural } from "../../run/text.js";
 export async function resolveCuaRerunSelection(args) {
     const source = await loadRunBundle(args.cwd, args.sourceRunId);
     if (!source) {
@@ -43,7 +44,7 @@ export async function resolveCuaRerunSelection(args) {
     if (missingPrior.length > 0) {
         return {
             ok: false,
-            message: `selected participant id(s) were not present in source run ${bundle.runId}: ${missingPrior.join(", ")}`,
+            message: `${plural(missingPrior.length, "selected participant id")} ${missingPrior.length === 1 ? "was" : "were"} not present in source run ${bundle.runId}: ${missingPrior.join(", ")}`,
         };
     }
     const specsById = new Map(args.participantRuns.map((spec) => [spec.planned.id, spec]));
@@ -51,7 +52,7 @@ export async function resolveCuaRerunSelection(args) {
     if (missingCurrent.length > 0) {
         return {
             ok: false,
-            message: `selected participant id(s) are not present in the current lab config ${args.labId}: ${missingCurrent.join(", ")}`,
+            message: `${plural(missingCurrent.length, "selected participant id")} ${missingCurrent.length === 1 ? "is" : "are"} not present in the current study file ${args.studyId}: ${missingCurrent.join(", ")}`,
         };
     }
     const selectedSpecs = selectedIds.map((id) => specsById.get(id));

package/dist/routes/computer-use/result.d.ts

@@ -1,7 +1,7 @@
-import type { runLabParticipants } from "./live-phase.js";
+import type { runStudyParticipants } from "./live-phase.js";
 import type { CuaFinishFacts, CuaRunSetup } from "./setup.js";
-import { type CuaActorLabResult } from "./types.js";
+import { type CuaActorStudyResult } from "./types.js";
 /** Builds and publishes the final bundle, runs the adapter hooks, renders the Observer and returns the result. */
-export declare function finishCuaRun(setup: CuaRunSetup, finish: CuaFinishFacts, ran: Extract<Awaited<ReturnType<typeof runLabParticipants>>, {
+export declare function finishCuaRun(setup: CuaRunSetup, finish: CuaFinishFacts, ran: Extract<Awaited<ReturnType<typeof runStudyParticipants>>, {
     ok: true;
-}>): Promise<CuaActorLabResult>;
+}>): Promise<CuaActorStudyResult>;

package/dist/routes/computer-use/result.js

@@ -1,4 +1,4 @@
-import { adapterScoreFailureMessage, applyBrowserScorer } from "../../lab/adapter-extension.js";
+import { adapterScoreFailureMessage, applyBrowserScorer } from "../../study/adapter-extension.js";
 import { redactText } from "../../evidence/redaction.js";
 import { round6 } from "../../run/pricing.js";
 import { foldScorerFailures, judgeExecution, OUTCOME_POLICIES, participantHarnessFailed, resultOk, } from "../../run/judge.js";
@@ -10,6 +10,7 @@ import { aggregateCuaSubject, projectParticipantSubjects, subjectProvenanceArg,
 import { CUA_FANOUT_STRATEGY, participantSubjectEnv, } from "./types.js";
 import { plannedAppUrl } from "./plan.js";
 import { studyResultIdentity } from "../../run/study-result.js";
+import { plural } from "../../run/text.js";
 /** Aggregate participant counts for the result projection. */
 function buildParticipantSummary(outcomes, participantCount, participantPlan, dryRun) {
     if (dryRun || !outcomes) {
@@ -52,12 +53,12 @@ function buildParticipantSummary(outcomes, participantCount, participantPlan, dr
     };
 }
 /**
- * The computer-use lab result for a finished run. The run passes only when the Observer rendered,
+ * The computer-use study result for a finished run. The run passes only when the Observer rendered,
  * every participant passed (dry-run participants pass as contracts), and no adapter score or declared scorer
  * verdict failed; otherwise the error names the first reason.
  */
-function cuaLabResult(args) {
-    const { labId, cwd, runId, appUrl, dryRun, participantRuns, outcomes, subjects, aggregateSubject, participantPlan, rerunLineage, bundle, observer, receivingWarnings, aggregateWarnings, adapterWarnings, } = args;
+function cuaStudyResult(args) {
+    const { studyId, cwd, runId, appUrl, dryRun, participantRuns, outcomes, subjects, aggregateSubject, participantPlan, rerunLineage, bundle, observer, receivingWarnings, aggregateWarnings, adapterWarnings, } = args;
     const participantCount = participantRuns.length;
     // Participant-level pass: dry-run participants are contract-ok; live ones need a passed,
     // engaged session.
@@ -104,8 +105,8 @@ function cuaLabResult(args) {
                                         ? `Computer-use session ended with a harness error: ${outcome.session.reason}`
                                         : outcome?.session?.status !== "passed"
                                             ? `Computer-use session ended with ${outcome?.session?.status ?? "unknown"}: ${outcome?.session?.reason ?? "no terminal reason"}`
-                                            : "Computer-use lab did not produce a terminal session."
-                                    : (observer.error?.message ?? "Observer failed for the computer-use lab run.")),
+                                            : "The computer-use run did not produce a terminal session."
+                                    : (observer.error?.message ?? "Observer failed for the computer-use run.")),
             };
         }
         const failing = (outcomes ?? []).find((outcome) => !participantOk(outcome));
@@ -114,12 +115,12 @@ function cuaLabResult(args) {
         return {
             code,
             message: observer.ok
-                ? `Fan-out run failed: ${summary.passed}/${participantCount} participant(s) passed (${summary.skipped} skipped, ${summary.harnessErrors} harness error(s), ${summary.hollow} without engagement)${failing?.sessionError !== undefined ? `; first failure: ${failing.sessionError}` : failing === undefined && args.execution.failures[0] !== undefined ? `; ${args.execution.failures[0].message}` : ""}.`
+                ? `Fan-out run failed: ${summary.passed}/${plural(participantCount, "participant")} passed (${summary.skipped} skipped, ${plural(summary.harnessErrors, "harness error")}, ${summary.hollow} without engagement)${failing?.sessionError !== undefined ? `; first failure: ${failing.sessionError}` : failing === undefined && args.execution.failures[0] !== undefined ? `; ${args.execution.failures[0].message}` : ""}.`
                 : (observer.error?.message ?? "Observer failed for the computer-use fan-out run."),
         };
     })();
     return {
-        ...studyResultIdentity("computer-use", labId),
+        ...studyResultIdentity("computer-use", studyId),
         ok,
         cwd,
         actor: args.actorId,
@@ -198,7 +199,7 @@ function computerUseExecutionFailures(outcomes, observer, runId) {
             : [
                 {
                     kind: "evidence",
-                    message: observer.error?.message ?? "Observer failed for the computer-use lab run.",
+                    message: observer.error?.message ?? "Observer failed for the computer-use run.",
                 },
             ]),
     ];
@@ -256,7 +257,7 @@ export async function finishCuaRun(setup, finish, ran) {
         context: {
             bundle,
             runDir: run.paths.physicalRunRoot,
-            labId: plan.labId,
+            studyId: plan.studyId,
             runId,
             actor: descriptor.id,
             route: "computer-use",
@@ -275,8 +276,8 @@ export async function finishCuaRun(setup, finish, ran) {
     const observer = await finished.renderObserver();
     streams.attachFinal(observer);
     const execution = judgeExecution(computerUseExecutionFailures(outcomes, observer, runId), OUTCOME_POLICIES["computer-use"]);
-    const result = cuaLabResult({
-        labId: plan.labId,
+    const result = cuaStudyResult({
+        studyId: plan.studyId,
         cwd,
         runId,
         actorId: descriptor.id,

package/dist/routes/computer-use/route.d.ts

@@ -1,28 +1,28 @@
-import type { ComputerUsePlan } from "../../lab/plan-types.js";
-import type { AdmittedPlan } from "../../run-lab.js";
-import type { LabConfig } from "../../lab/types.js";
+import type { ComputerUsePlan } from "../../study/plan-types.js";
+import type { AdmittedPlan } from "../../run-study.js";
+import type { StudyConfig } from "../../study/types.js";
 import { type ComputerUseRefusal } from "./plan.js";
-import { type ComputerUseRunInput, type CuaActorLabResult, type RunCuaActorLabOptions } from "./types.js";
+import { type ComputerUseRunInput, type CuaActorStudyResult, type RunCuaActorStudyOptions } from "./types.js";
 /**
- * Plans and runs a computer-use lab in one call. It is not exported from src/index.ts; tests call
- * it. It plans the config with planComputerUseLab and runs
+ * Plans and runs a computer-use study in one call. It is not exported from src/index.ts; tests call
+ * it. It plans the config with planComputerUseStudy and runs
  * the plan with runComputerUsePlan, whose run scope and withTransientCommsSecrets wrapper cover the
  * run and its analysis.
  */
-export declare function runCuaActorLab(options: RunCuaActorLabOptions): Promise<CuaActorLabResult>;
+export declare function runCuaActorStudy(options: RunCuaActorStudyOptions): Promise<CuaActorStudyResult>;
 /**
- * A refused computer-use lab's result, at the refusal's stage: a before-scope refusal has its own
+ * A refused computer-use study's result, at the refusal's stage: a before-scope refusal has its own
  * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
  * the personas are read.
  */
-export declare function computerUseLabRefusal(options: RunCuaActorLabOptions, refusal: ComputerUseRefusal): Promise<CuaActorLabResult>;
+export declare function computerUseStudyRefusal(options: RunCuaActorStudyOptions, refusal: ComputerUseRefusal): Promise<CuaActorStudyResult>;
 /**
- * runLab's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
+ * runStudyWith's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
  * participants, the preflight plan, the keys, the local agent, subject env and caps, and the
  * local-tree archive) before any run scope opens, so the CLI can present their refusal before it
  * loads a declared scorer, and returns the run that continues from them with that scorer.
  */
-export declare function admitComputerUsePlan(plan: ComputerUsePlan, input: ComputerUseRunInput, config: LabConfig): Promise<AdmittedPlan<"computer-use">>;
+export declare function admitComputerUsePlan(plan: ComputerUsePlan, input: ComputerUseRunInput, config: StudyConfig): Promise<AdmittedPlan<"computer-use">>;
 /**
  * Run a computer-use plan: its local checks, then the run. The run scope in runAdmittedCuaRun
  * finalizes any status record the run opened, on every exit, so a test or library caller does not
@@ -30,4 +30,4 @@ export declare function admitComputerUsePlan(plan: ComputerUsePlan, input: Compu
  * ENOTEMPTY). Participants, the brain, the subject, the caps and the residual config come from the
  * plan. `config` is what the caller's createProvider and inProcess executor receive.
  */
-export declare function runComputerUsePlan(plan: ComputerUsePlan, input: ComputerUseRunInput, config: LabConfig): Promise<CuaActorLabResult>;
+export declare function runComputerUsePlan(plan: ComputerUsePlan, input: ComputerUseRunInput, config: StudyConfig): Promise<CuaActorStudyResult>;