humanish 0.108.0 → 0.109.0

package/dist/routes/shared-world/participant-specs.d.ts

@@ -1,5 +1,5 @@
-import type { SharedWorldPlan } from "../../lab/plan-types.js";
-import type { Participant, SharedWorldParticipant } from "../../lab/plan-participants.js";
+import type { SharedWorldPlan } from "../../study/plan-types.js";
+import type { Participant, SharedWorldParticipant } from "../../study/plan-participants.js";
 import type { RunBundle } from "../../run/bundle.js";
 import type { CuaParticipantDeps, DesktopParticipantRun, ParticipantRunOutcome } from "../computer-use/types.js";
 import type { LiveParticipants, PlaneContext } from "./types.js";
@@ -10,7 +10,7 @@ export declare function resolveActorEntryUrl(baseUrl: string, entry: string | un
 export declare function participantTaxonomyLabel(labels: Participant["labels"]): string;
 /** Thread the host-yielded lobby code into a follower's mission at runtime (external-public route).
  *  The code flows into the follower's join instruction; it is persisted only as the composed prompt
- *  the model reads (never a raw bundle field), and the lab scrubs the code from all narration. The
+ *  the model reads (never a raw bundle field), and humanish scrubs the code from all narration. The
  *  follower joins through the real UI (a direct /lobby/CODE visit does not auto-join a non-member). */
 export declare function withLobbyCodeMission(spec: DesktopParticipantRun, code: string): DesktopParticipantRun;
 /** A follower blocked by an expired deadline or an ended host. It never opened a browser;

package/dist/routes/shared-world/participant-specs.js

@@ -1,14 +1,14 @@
 // Builds each participant's actor spec and mission, resolves its entry URL, derives the session
 // and sandbox time budgets, and records a follower that never received the host's lobby code.
 import { defaultSubjectPhaseSink } from "../../subject/steps.js";
-import { pricedModel } from "../../lab/plan-base.js";
-import { scrubPersonaBrief } from "../../lab/persona.js";
+import { pricedModel } from "../../study/plan-base.js";
+import { scrubPersonaBrief } from "../../study/persona.js";
 import { resolveParticipant } from "../../run/participant.js";
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
 import { composeParticipantInstructions } from "../computer-use/participant-prompt.js";
 import { startLiveTraceFlush } from "../computer-use/live-flush.js";
-import { resolveCommittedPersonasForCwd } from "../../lab/persona-resolve.js";
-import { participantAssignment } from "../../lab/participant-assignment.js";
+import { resolveCommittedPersonasForCwd } from "../../study/persona-resolve.js";
+import { participantAssignment } from "../../study/participant-assignment.js";
 import { redactText } from "../../evidence/redaction.js";
 import { MAX_SANDBOX_MS, SANDBOX_TIMEOUT_BUFFER_MS, SUBJECT_PROVISION_BUDGET_MS, } from "../../substrates/e2b/lifetime.js";
 import { DEFAULT_STATE_STEP_TIMEOUT_MS } from "../../subject/state.js";
@@ -79,7 +79,7 @@ function buildActorSpec(participant, personas) {
 }
 /** Thread the host-yielded lobby code into a follower's mission at runtime (external-public route).
  *  The code flows into the follower's join instruction; it is persisted only as the composed prompt
- *  the model reads (never a raw bundle field), and the lab scrubs the code from all narration. The
+ *  the model reads (never a raw bundle field), and humanish scrubs the code from all narration. The
  *  follower joins through the real UI (a direct /lobby/CODE visit does not auto-join a non-member). */
 export function withLobbyCodeMission(spec, code) {
     // prose-check: model prompt (the participant model reads this, not a person)
@@ -150,7 +150,7 @@ export function participantRunDeps(ctx, live, scrubKnownValues) {
     return {
         onTrace: (participantId, items, usage, metadata) => live.flush?.flush(participantId, items, usage, metadata),
         residual: ctx.plan.residual,
-        labId: ctx.plan.labId,
+        studyId: ctx.plan.studyId,
         caps: ctx.plan.caps,
         subject: {
             kind: "shared-app",
@@ -164,7 +164,7 @@ export function participantRunDeps(ctx, live, scrubKnownValues) {
         timeoutMs: ctx.timeoutMs,
         participantCount: ctx.plan.plane.participants.length,
         artifactRoot: ctx.runPaths,
-        labCwd: ctx.cwd,
+        studyCwd: ctx.cwd,
         redactScreenshots: ctx.redactScreenshots,
         scrubKnownValues,
         runSession: ctx.runSession,

package/dist/routes/shared-world/plan.d.ts

@@ -1,23 +1,23 @@
 import { type CuaActorDescriptor } from "../../actors/registry.js";
-import type { RoutePlanResult, RouteRefusal, SharedWorldPlan } from "../../lab/plan-types.js";
-import type { LabConfig, LabSubjectState } from "../../lab/types.js";
-import type { ConcurrentSharedWorldLabErrorCode } from "./types.js";
-/** The error a shared-world lab returns before a run starts. */
-export interface SharedWorldRefusal extends RouteRefusal<"shared-world", ConcurrentSharedWorldLabErrorCode> {
+import type { RoutePlanResult, RouteRefusal, SharedWorldPlan } from "../../study/plan-types.js";
+import type { StudyConfig, StudySubjectState } from "../../study/types.js";
+import type { ConcurrentSharedWorldStudyErrorCode } from "./types.js";
+/** The error a shared-world study returns before a run starts. */
+export interface SharedWorldRefusal extends RouteRefusal<"shared-world", ConcurrentSharedWorldStudyErrorCode> {
     /** The registered actor id, once the registry check has passed. */
     readonly actor?: string;
 }
 export type SharedWorldPlanResult = RoutePlanResult<SharedWorldPlan, SharedWorldRefusal>;
-/** The registered descriptor for a planned actor; planSharedWorldLab checked the registry. */
+/** The registered descriptor for a planned actor; planSharedWorldStudy checked the registry. */
 export declare function sharedWorldDescriptorOf(actorType: string): CuaActorDescriptor;
 /**
- * Plan a shared-world lab. It is called for any config handed to the shared-world runner, not only
+ * Plan a shared-world study. It is called for any config handed to the shared-world runner, not only
  * one routeOf sends here, so a config for another route gets this route's refusal.
  */
-export declare function planSharedWorldLab(config: LabConfig, input: {
+export declare function planSharedWorldStudy(config: StudyConfig, input: {
     readonly dryRun: boolean;
     /** Whether deps.runSession is set: a caller's session runner cannot enforce maxOutputTokens. */
     readonly hasRunSession?: boolean;
 }): SharedWorldPlanResult;
 /** The provisioned plane's declared subject state. The external-public plane declares none. */
-export declare function planeStateOf(plan: SharedWorldPlan): LabSubjectState | undefined;
+export declare function planeStateOf(plan: SharedWorldPlan): StudySubjectState | undefined;

package/dist/routes/shared-world/plan.js

@@ -5,13 +5,13 @@
 import { DEFAULT_OPENAI_CU_MODEL } from "../../actors/computer-use/openai-provider.js";
 import { actorRegistry, isCuaActorDescriptor, } from "../../actors/registry.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
-import { brainOf, capsOf, desktopRequirements, isNonEmpty, planBase } from "../../lab/plan-base.js";
-import { sharedWorldParticipants } from "../../lab/plan-participants.js";
-import { PUBLIC_TARGET_OWNER_PATTERN } from "../../lab/parse/subject.js";
-import { REPO_SLUG_PATTERN } from "../../lab/parse/values.js";
-import { concurrentSharedWorldValidationReason, desktopMediaValidationReason, externalPublicSharedWorldValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, scenarioCapsValidationReason, taskProtocolValidationReason, } from "../../lab/validation.js";
+import { brainOf, capsOf, desktopRequirements, isNonEmpty, planBase, } from "../../study/plan-base.js";
+import { sharedWorldParticipants } from "../../study/plan-participants.js";
+import { PUBLIC_TARGET_OWNER_PATTERN } from "../../study/parse/subject.js";
+import { REPO_SLUG_PATTERN } from "../../study/parse/values.js";
+import { concurrentSharedWorldValidationReason, desktopMediaValidationReason, externalPublicSharedWorldValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, scenarioCapsValidationReason, taskProtocolValidationReason, } from "../../study/validation.js";
 import { MODEL_RATES, unpricedCapMessage } from "../../run/pricing.js";
-/** The registered descriptor for a planned actor; planSharedWorldLab checked the registry. */
+/** The registered descriptor for a planned actor; planSharedWorldStudy checked the registry. */
 export function sharedWorldDescriptorOf(actorType) {
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isCuaActorDescriptor(descriptor))
@@ -19,10 +19,10 @@ export function sharedWorldDescriptorOf(actorType) {
     return descriptor;
 }
 /**
- * Plan a shared-world lab. It is called for any config handed to the shared-world runner, not only
+ * Plan a shared-world study. It is called for any config handed to the shared-world runner, not only
  * one routeOf sends here, so a config for another route gets this route's refusal.
  */
-export function planSharedWorldLab(config, input) {
+export function planSharedWorldStudy(config, input) {
     const refuse = (code, message, actor) => ({
         ok: false,
         refusal: { route: "shared-world", code, message, ...(actor === undefined ? {} : { actor }) },
@@ -162,7 +162,7 @@ function planeOf(config) {
             ? { kind: "local-tree", serve, env, state: checkpointed }
             : {
                 kind: "clone",
-                // planSharedWorldLab refused a clone without an owner/repo slug.
+                // planSharedWorldStudy refused a clone without an owner/repo slug.
                 repo: config.subject.repos?.[0] ?? "",
                 serve,
                 env,

package/dist/routes/shared-world/provisioned.d.ts

@@ -1,13 +1,13 @@
-import type { LabCommsEmail, LabConfig, LabSubjectServe, LabSubjectStateCheckpoint } from "../../lab/types.js";
+import type { StudyCommsEmail, StudyConfig, StudySubjectServe, StudySubjectStateCheckpoint } from "../../study/types.js";
 import type { RunSubjectStateStepRecord } from "../../run/bundle.js";
 import type { SharedWorldStateSnapshot } from "../../run/shared-world-evidence.js";
 import type { LocalTreeArchive } from "../../subject/local-tree-archive.js";
 import type { DetachedTimers } from "../../substrates/detached.js";
-import type { LabDeps } from "../../lab/lab-deps.js";
+import type { StudyDeps } from "../../study/study-deps.js";
 import { type ActorRunResult, type SubjectDesktopUsage, type LiveParticipants, type PlaneContext } from "./types.js";
 /** What the provisioned plane needs besides the shared plane context. */
 export interface ProvisionedPlaneSetup {
-    serve: LabSubjectServe;
+    serve: StudySubjectServe;
     localTreeRoute: boolean;
     localTreeArchive: LocalTreeArchive | undefined;
     localTreeArchiveBuffer: ArrayBuffer | undefined;
@@ -15,9 +15,9 @@ export interface ProvisionedPlaneSetup {
     publicRepo: string;
     subjectEnvNames: string[];
     hasGithubToken: boolean;
-    checkpoints: LabSubjectStateCheckpoint[];
-    /** The in-sandbox email catch, when a comms lab declared one. */
-    commsEmail: LabCommsEmail | undefined;
+    checkpoints: StudySubjectStateCheckpoint[];
+    /** The in-sandbox email catch, when a comms study declared one. */
+    commsEmail: StudyCommsEmail | undefined;
     commsPort: number | undefined;
     /** The catch's base URL, injected into the subject's env at create. */
     commsEnv: Record<string, string>;
@@ -47,8 +47,8 @@ export declare function runProvisionedPlane(ctx: PlaneContext, live: LivePartici
  * or the message the run fails with.
  */
 export declare function packSubjectTree(cwd: string, config: {
-    readonly subject: Pick<LabConfig["subject"], "localTree">;
-}, deps: LabDeps, scrubKnownValues: (text: string) => string): Promise<{
+    readonly subject: Pick<StudyConfig["subject"], "localTree">;
+}, deps: StudyDeps, scrubKnownValues: (text: string) => string): Promise<{
     ok: true;
     archive: LocalTreeArchive;
     buffer: ArrayBuffer;

package/dist/routes/shared-world/provisioned.js

@@ -10,7 +10,7 @@ import { mapWithConcurrency } from "../../run/concurrency.js";
 import { provisionCloneSubject } from "../../subject/clone.js";
 import { provisionLocalTreeSubject } from "../../subject/local-tree.js";
 import { defaultSharedWorldPhaseSink } from "../../subject/steps.js";
-import { phaseEvent } from "../../lab/run-lab-events.js";
+import { phaseEvent } from "../../study/run-study-events.js";
 import { loadE2BDesktopModule } from "../../substrates/e2b/sdk.js";
 import { observeDesktopResources, } from "../../substrates/e2b/desktop-resources.js";
 import { acquireE2BDesktopSandbox, readE2BRelease } from "../../substrates/e2b/sandbox.js";
@@ -29,7 +29,7 @@ import { SANDBOX_TIMEOUT_BUFFER_MS, SUBJECT_PROVISION_BUDGET_MS, } from "../../s
 import { DEFAULT_STATE_STEP_TIMEOUT_MS } from "../../subject/state.js";
 import { resolveActorEntryUrl, participantRunDeps, startParticipantFlush, } from "./participant-specs.js";
 import { CONCURRENT_SHARED_WORLD_PROVIDER_METADATA, } from "./types.js";
-import { addressedRecipients } from "../../lab/parse/comms.js";
+import { addressedRecipients } from "../../study/parse/comms.js";
 /**
  * A failure of the caller's `onObserverReady` gate on the provisioned plane. The gate runs inside
  * the try that records participant failures, so it is wrapped to be told apart and rethrown: a gate
@@ -60,7 +60,7 @@ class SubjectPlane {
     subjectDesktop;
     subjectShell;
     // The in-sandbox email catch on the one subject sandbox; drained at teardown. Undefined
-    // unless a comms lab declared it.
+    // unless a comms study declared it.
     deployedComms;
     // Background prober dispose signal, cleared in teardown.
     proberDisposed = false;
@@ -119,7 +119,7 @@ class SubjectPlane {
                     SANDBOX_TIMEOUT_BUFFER_MS,
                 metadata: {
                     ...CONCURRENT_SHARED_WORLD_PROVIDER_METADATA,
-                    labId: plan.labId,
+                    labId: plan.studyId,
                     topology: "shared-world",
                     topologyMode: "concurrent",
                     kind: "subject",

package/dist/routes/shared-world/result.d.ts

@@ -1,18 +1,18 @@
-import { type ConcurrentSharedWorldLabErrorCode, type ConcurrentSharedWorldLabResult, type FinishFacts, type LiveParticipants, type PlaneContext, type PlaneResults } from "./types.js";
+import { type ConcurrentSharedWorldStudyErrorCode, type ConcurrentSharedWorldStudyResult, type FinishFacts, type LiveParticipants, type PlaneContext, type PlaneResults } from "./types.js";
 /** The results of a run whose plane did not run (a dry run) or has not reported yet. */
 export declare function emptyPlaneResults(): PlaneResults;
 /**
  * The refusal envelope for a run that stops before it has results: the requested cwd, no roles,
  * and the run id the caller asked for, if any. `actor` is the label when a refusal names none.
  */
-export declare function concurrentLabFailure(envelope: {
+export declare function concurrentStudyFailure(envelope: {
     cwd: string;
-    labId: string;
+    studyId: string;
     actor: string;
     participantCount: number;
     concurrency: number;
     dryRun: boolean;
     runId: string | undefined;
-}): (code: ConcurrentSharedWorldLabErrorCode, message: string, actorLabel?: string) => ConcurrentSharedWorldLabResult;
-/** Builds and publishes the bundle, renders the Observer and returns the lab result. */
-export declare function finishConcurrentRun(ctx: PlaneContext, live: LiveParticipants, results: PlaneResults, plane: FinishFacts): Promise<ConcurrentSharedWorldLabResult>;
+}): (code: ConcurrentSharedWorldStudyErrorCode, message: string, actorLabel?: string) => ConcurrentSharedWorldStudyResult;
+/** Builds and publishes the bundle, renders the Observer and returns the study result. */
+export declare function finishConcurrentRun(ctx: PlaneContext, live: LiveParticipants, results: PlaneResults, plane: FinishFacts): Promise<ConcurrentSharedWorldStudyResult>;

package/dist/routes/shared-world/result.js

@@ -1,7 +1,7 @@
 // Finishing a concurrent shared-world run: publishing its bundle, rendering the Observer, and the
-// lab result with each role's outcome and the one error a run that did not pass reports.
+// study result with each role's outcome and the one error a run that did not pass reports.
 import { redactText } from "../../evidence/redaction.js";
-import { adapterScoreFailureMessage, applyBrowserScorer } from "../../lab/adapter-extension.js";
+import { adapterScoreFailureMessage, applyBrowserScorer } from "../../study/adapter-extension.js";
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
 import { foldScorerFailures, judgeExecution, sandboxCleanupFailure, OUTCOME_POLICIES, participantHarnessFailed, resultOk, sharedWorldShortfall, } from "../../run/judge.js";
 import { participantFactsOf, unreleasedSandboxFailures, } from "../computer-use/participant-facts.js";
@@ -11,6 +11,7 @@ import { planeStateOf } from "./plan.js";
 import { buildSubjectProvenance, hostOriginDigest } from "./provenance.js";
 import {} from "./types.js";
 import { studyResultIdentity } from "../../run/study-result.js";
+import { plural } from "../../run/text.js";
 /** The results of a run whose plane did not run (a dry run) or has not reported yet. */
 export function emptyPlaneResults() {
     return {
@@ -81,7 +82,7 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
     });
 }
 /** The error a run that did not pass reports, most specific cause first. */
-function concurrentLabError(args) {
+function concurrentStudyError(args) {
     const { ok, handoffTimedOut, hostHandoffFailure, observer, runError, adapterFailure } = args;
     const { participantResults, participantCount } = args;
     if (ok)
@@ -134,16 +135,16 @@ function concurrentLabError(args) {
     }
     return {
         code: "HUMANISH_SHARED_WORLD_FAILED",
-        message: `Concurrent shared-world run did not run coherently: ${passed}/${participantCount} actor(s) reached a terminal, engaged passed session.`,
+        message: `Concurrent shared-world run did not run coherently: ${passed}/${plural(participantCount, "actor")} reached a terminal, engaged passed session.`,
     };
 }
 /**
  * The refusal envelope for a run that stops before it has results: the requested cwd, no roles,
  * and the run id the caller asked for, if any. `actor` is the label when a refusal names none.
  */
-export function concurrentLabFailure(envelope) {
+export function concurrentStudyFailure(envelope) {
     return (code, message, actorLabel) => ({
-        ...studyResultIdentity("shared-world", envelope.labId),
+        ...studyResultIdentity("shared-world", envelope.studyId),
         ok: false,
         cwd: envelope.cwd,
         actor: actorLabel ?? envelope.actor,
@@ -204,7 +205,7 @@ function sharedWorldExecutionFailures(args) {
             ]),
     ];
 }
-/** Builds and publishes the bundle, renders the Observer and returns the lab result. */
+/** Builds and publishes the bundle, renders the Observer and returns the study result. */
 export async function finishConcurrentRun(ctx, live, results, plane) {
     const { plan, input, descriptor, actorSpecs, run, runId } = ctx;
     const participantCount = plan.plane.participants.length;
@@ -268,7 +269,7 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
         context: {
             bundle,
             runDir: physicalArtifactRoot,
-            labId: plan.labId,
+            studyId: plan.studyId,
             runId,
             actor: descriptor.id,
             route: "shared-world",
@@ -298,7 +299,7 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
     const ok = resultOk({ judgment, execution, scorerFailures: scorerResult.failures, policy });
     const overlapProven = !dryRun && judgment.world.overlap;
     const participantResults = concurrentParticipantResults(actorSpecs, actorResults, dryRun);
-    const errorResult = concurrentLabError({
+    const errorResult = concurrentStudyError({
         ok,
         handoffTimedOut,
         hostHandoffFailure,
@@ -311,7 +312,7 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
         executionFailure: execution.failures[0]?.message,
     });
     const result = {
-        ...studyResultIdentity("shared-world", plan.labId),
+        ...studyResultIdentity("shared-world", plan.studyId),
         ok,
         cwd,
         actor: descriptor.id,

package/dist/routes/shared-world/route.d.ts

@@ -1,21 +1,21 @@
 import { type SharedWorldRefusal } from "./plan.js";
-import type { SharedWorldPlan } from "../../lab/plan-types.js";
-import type { AdmittedPlan } from "../../run-lab.js";
-import type { LabConfig } from "../../lab/types.js";
-import { type ConcurrentSharedWorldLabResult, type SharedWorldRunInput, type RunConcurrentSharedWorldLabOptions } from "./types.js";
+import type { SharedWorldPlan } from "../../study/plan-types.js";
+import type { AdmittedPlan } from "../../run-study.js";
+import type { StudyConfig } from "../../study/types.js";
+import { type ConcurrentSharedWorldStudyResult, type SharedWorldRunInput, type RunConcurrentSharedWorldStudyOptions } from "./types.js";
 /**
- * The library entry for a shared-world lab. It plans the config with planSharedWorldLab and runs
+ * The library entry for a shared-world study. It plans the config with planSharedWorldStudy and runs
  * the plan with runSharedWorldPlan, whose run scope and withTransientCommsSecrets wrapper cover the
  * run and its analysis.
  */
-export declare function runConcurrentSharedWorld(options: RunConcurrentSharedWorldLabOptions): Promise<ConcurrentSharedWorldLabResult>;
-/** A refused shared-world lab's result: the route's envelope, and a refusal's analysis record. */
-export declare function sharedWorldLabRefusal(options: RunConcurrentSharedWorldLabOptions, refusal: SharedWorldRefusal): Promise<ConcurrentSharedWorldLabResult>;
+export declare function runConcurrentSharedWorld(options: RunConcurrentSharedWorldStudyOptions): Promise<ConcurrentSharedWorldStudyResult>;
+/** A refused shared-world study's result: the route's envelope, and a refusal's analysis record. */
+export declare function sharedWorldStudyRefusal(options: RunConcurrentSharedWorldStudyOptions, refusal: SharedWorldRefusal): Promise<ConcurrentSharedWorldStudyResult>;
 /**
- * runLab's step for a shared-world plan. It runs a live plan's local checks (the keys, a local
+ * runStudyWith's step for a shared-world plan. It runs a live plan's local checks (the keys, a local
  * agent's sign-in and the subject env) 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 admitSharedWorldPlan(plan: SharedWorldPlan, input: SharedWorldRunInput, config: LabConfig): Promise<AdmittedPlan<"shared-world">>;
+export declare function admitSharedWorldPlan(plan: SharedWorldPlan, input: SharedWorldRunInput, config: StudyConfig): Promise<AdmittedPlan<"shared-world">>;
 /** Run a shared-world plan: its local checks, then the run. */
-export declare function runSharedWorldPlan(plan: SharedWorldPlan, input: SharedWorldRunInput, config: LabConfig): Promise<ConcurrentSharedWorldLabResult>;
+export declare function runSharedWorldPlan(plan: SharedWorldPlan, input: SharedWorldRunInput, config: StudyConfig): Promise<ConcurrentSharedWorldStudyResult>;

package/dist/routes/shared-world/route.js

@@ -1,4 +1,4 @@
-// The concurrent shared-world lab route: N persona participants drive one shared,
+// The concurrent shared-world route: N persona participants drive one shared,
 // mutable service plane at the same time. A recomposition of shipped
 // pieces + the getHost wrapper:
 //
@@ -33,7 +33,7 @@
 // requires the author attestation subject.exposure: synthetic. This is author-trust + a provenance
 // gate; humanish cannot tell synthetic from real data, so it makes no claim about real data.
 import path from "node:path";
-import { missingKeys, missingSubjectEnv } from "../../lab/requirements.js";
+import { missingKeys, missingSubjectEnv } from "../../study/requirements.js";
 import { completeAutomaticAnalysis } from "../../analysis/automatic-completion.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { scrubLiterals } from "../../evidence/redaction.js";
@@ -42,15 +42,15 @@ import { withTransientCommsSecrets } from "../../run/transient-comms-secrets.js"
 import { runScope } from "../../run/run.js";
 import { makeCuaRunBudget } from "../computer-use/participant-model.js";
 import { runExternalPublicPlane } from "./external-public.js";
-import { planSharedWorldLab, sharedWorldDescriptorOf } from "./plan.js";
+import { planSharedWorldStudy, sharedWorldDescriptorOf } from "./plan.js";
 import { localAgentRefusal } from "../../actors/local-agent/readiness.js";
 import { runProvisionedPlane } from "./provisioned.js";
-import { concurrentLabFailure, finishConcurrentRun } from "./result.js";
+import { concurrentStudyFailure, finishConcurrentRun } from "./result.js";
 import { prepareConcurrentRun } from "./setup.js";
-import { browserRouteScorer } from "../../lab/adapter-scorer-loader.js";
-import { withLateScorer } from "../../lab/route-inputs.js";
+import { browserRouteScorer } from "../../study/adapter-scorer-loader.js";
+import { withLateScorer } from "../../study/route-inputs.js";
 import {} from "./types.js";
-import { rosterOf } from "../../lab/parse/actors.js";
+import { rosterOf } from "../../study/parse/actors.js";
 /** The shared-world code for each local-agent refusal, kind for kind with computer-use. */
 const LOCAL_AGENT_REFUSAL_CODES = {
     "agent-missing": "HUMANISH_SHARED_WORLD_AGENT_MISSING",
@@ -59,28 +59,28 @@ const LOCAL_AGENT_REFUSAL_CODES = {
     "unpriced-cap": "HUMANISH_SHARED_WORLD_UNPRICED_CAP",
 };
 /**
- * The library entry for a shared-world lab. It plans the config with planSharedWorldLab and runs
+ * The library entry for a shared-world study. It plans the config with planSharedWorldStudy and runs
  * the plan with runSharedWorldPlan, whose run scope and withTransientCommsSecrets wrapper cover the
  * run and its analysis.
  */
 export async function runConcurrentSharedWorld(options) {
     const { config, dryRun, ...input } = options;
-    // planSharedWorldLab makes every configuration refusal, in the order this route always has.
-    const planned = planSharedWorldLab(config, {
+    // planSharedWorldStudy makes every configuration refusal, in the order this route always has.
+    const planned = planSharedWorldStudy(config, {
         dryRun,
         hasRunSession: input.deps?.runSession !== undefined,
     });
     if (planned.ok)
         return runSharedWorldPlan(planned.plan, input, config);
-    return sharedWorldLabRefusal(options, planned.refusal);
+    return sharedWorldStudyRefusal(options, planned.refusal);
 }
-/** A refused shared-world lab's result: the route's envelope, and a refusal's analysis record. */
-export function sharedWorldLabRefusal(options, refusal) {
+/** A refused shared-world study's result: the route's envelope, and a refusal's analysis record. */
+export function sharedWorldStudyRefusal(options, refusal) {
     const { config, dryRun } = options;
     const declared = rosterOf(config.actors[0]) ?? [];
-    const fail = concurrentLabFailure({
+    const fail = concurrentStudyFailure({
         cwd: path.resolve(options.cwd),
-        labId: config.id,
+        studyId: config.id,
         actor: config.actors[0]?.type ?? "",
         participantCount: declared.length,
         // The parser fills concurrency for multi-participant studies, so this fallback serves only
@@ -94,7 +94,7 @@ export function sharedWorldLabRefusal(options, refusal) {
     return completeAutomaticAnalysis(fail(refusal.code, refusal.message, refusal.actor), undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
 }
 /**
- * runLab's step for a shared-world plan. It runs a live plan's local checks (the keys, a local
+ * runStudyWith's step for a shared-world plan. It runs a live plan's local checks (the keys, a local
  * agent's sign-in and the subject env) 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.
  */
@@ -130,7 +130,7 @@ async function admitSharedWorldRun(plan, input) {
     // agent instead.
     const missing = missingKeys(plan.requirements, env);
     if (missing.length > 0) {
-        return fail("HUMANISH_SHARED_WORLD_KEYS_MISSING", `Live concurrent shared-world labs need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}`);
+        return fail("HUMANISH_SHARED_WORLD_KEYS_MISSING", `Live concurrent shared-world studies need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}`);
     }
     if (plan.brain.kind === "local-agent") {
         // A missing or signed-out agent found after the participants' desktops are paid for is the same
@@ -164,9 +164,9 @@ function completeSharedWorldAnalysis(plan, input, result, finished) {
 }
 /** The route's envelope for a run that stops before its bundle. */
 function sharedWorldFailure(plan, input) {
-    return concurrentLabFailure({
+    return concurrentStudyFailure({
         cwd: path.resolve(input.cwd),
-        labId: plan.labId,
+        studyId: plan.studyId,
         actor: plan.actor,
         participantCount: plan.plane.participants.length,
         concurrency: plan.concurrency,

package/dist/routes/shared-world/setup.d.ts

@@ -1,43 +1,43 @@
 import type { CuaActorDescriptor } from "../../actors/registry.js";
-import type { LabConfig, LabSubjectServe, LabSubjectStateCheckpoint } from "../../lab/types.js";
+import type { StudyConfig, StudySubjectServe, StudySubjectStateCheckpoint } from "../../study/types.js";
 import type { RunScope } from "../../run/run.js";
-import type { ConcurrentSharedWorldLabErrorCode, ConcurrentSharedWorldLabResult, ConcurrentSharedWorldPlaneClass, FinishFacts, LiveParticipants, PlaneContext, PlaneResults, PlaneSelection, SharedWorldRunInput } from "./types.js";
-import type { LabDeps } from "../../lab/lab-deps.js";
-import type { SharedWorldPlan } from "../../lab/plan-types.js";
-/** What validation derived from the lab, which setup reads. */
-interface AdmittedLab {
+import type { ConcurrentSharedWorldStudyErrorCode, ConcurrentSharedWorldStudyResult, ConcurrentSharedWorldPlaneClass, FinishFacts, LiveParticipants, PlaneContext, PlaneResults, PlaneSelection, SharedWorldRunInput } from "./types.js";
+import type { StudyDeps } from "../../study/study-deps.js";
+import type { SharedWorldPlan } from "../../study/plan-types.js";
+/** What validation derived from the study, which setup reads. */
+interface AdmittedStudy {
     plan: SharedWorldPlan;
     input: SharedWorldRunInput;
     /** Read for the subject's serve URL, which each participant's subject names. Participants, their
      *  count and their host and entry come from the plan's participants. */
-    config: LabConfig;
+    config: StudyConfig;
     requestedCwd: string;
-    deps: LabDeps;
+    deps: StudyDeps;
     env: Record<string, string | undefined>;
     descriptor: CuaActorDescriptor;
     planeClass: ConcurrentSharedWorldPlaneClass;
     runBudget: PlaneContext["runBudget"];
     runSession: PlaneContext["runSession"];
-    serve: LabSubjectServe | undefined;
+    serve: StudySubjectServe | undefined;
     localTreeRoute: boolean;
     subjectRepo: string;
     subjectEnvNames: string[];
-    checkpoints: LabSubjectStateCheckpoint[];
+    checkpoints: StudySubjectStateCheckpoint[];
     openaiApiKey: string;
     e2bApiKey: string;
     knownSecretValues: string[];
     scrubKnownValues: (text: string) => string;
     publicRepo: string;
     hasGithubToken: boolean;
-    fail: (code: ConcurrentSharedWorldLabErrorCode, message: string, actorLabel?: string) => ConcurrentSharedWorldLabResult;
+    fail: (code: ConcurrentSharedWorldStudyErrorCode, message: string, actorLabel?: string) => ConcurrentSharedWorldStudyResult;
 }
 /**
  * Starts the run and prepares what the planes read: the physical project, the run, the participant
  * specs, comms, the packed tree and email receiving. Returns the refusal when one of them fails.
  */
-export declare function prepareConcurrentRun(lab: AdmittedLab, scope: RunScope): Promise<{
+export declare function prepareConcurrentRun(study: AdmittedStudy, scope: RunScope): Promise<{
     ok: false;
-    result: ConcurrentSharedWorldLabResult;
+    result: ConcurrentSharedWorldStudyResult;
 } | {
     ok: true;
     ctx: PlaneContext;

package/dist/routes/shared-world/setup.js

@@ -19,19 +19,19 @@ function makeRunId() {
     const stamp = new Date().toISOString().replace(/[:.]/g, "-");
     return `concurrent-shared-world-${stamp}-${randomBytes(4).toString("hex")}`;
 }
-/** The provisioned plane's setup, or undefined when the lab declares no `subject.serve`. */
-function provisionedSetup(lab, prepared) {
-    if (!lab.serve)
+/** The provisioned plane's setup, or undefined when the study declares no `subject.serve`. */
+function provisionedSetup(study, prepared) {
+    if (!study.serve)
         return undefined;
     const { subjectComms, ...rest } = prepared;
     return {
-        serve: lab.serve,
-        localTreeRoute: lab.localTreeRoute,
-        subjectRepo: lab.subjectRepo,
-        publicRepo: lab.publicRepo,
-        subjectEnvNames: lab.subjectEnvNames,
-        hasGithubToken: lab.hasGithubToken,
-        checkpoints: lab.checkpoints,
+        serve: study.serve,
+        localTreeRoute: study.localTreeRoute,
+        subjectRepo: study.subjectRepo,
+        publicRepo: study.publicRepo,
+        subjectEnvNames: study.subjectEnvNames,
+        hasGithubToken: study.hasGithubToken,
+        checkpoints: study.checkpoints,
         commsEmail: subjectComms.email,
         commsPort: subjectComms.port,
         commsEnv: subjectComms.env,
@@ -48,14 +48,14 @@ async function bindPhysicalProject(requestedCwd) {
     return (await prepareSelectedOutputDirectory(path.dirname(physicalCwd), physicalCwd))
         .physicalPath;
 }
-function startConcurrentRun(lab, cwd, scope) {
-    const { plan, input, deps } = lab;
+function startConcurrentRun(study, cwd, scope) {
+    const { plan, input, deps } = study;
     return scope.startRun({
         cwd,
         runId: input.runId,
         mintRunId: makeRunId,
         mode: plan.dryRun ? "dry-run" : "live",
-        lab: plan.lab,
+        study: plan.study,
         renderReview: renderConcurrentReviewMarkdown,
         observer: { open: input.open === true, render: deps.renderObserver },
     });
@@ -64,10 +64,10 @@ function startConcurrentRun(lab, cwd, scope) {
  * Starts the run and prepares what the planes read: the physical project, the run, the participant
  * specs, comms, the packed tree and email receiving. Returns the refusal when one of them fails.
  */
-export async function prepareConcurrentRun(lab, scope) {
-    const { plan, input, config, requestedCwd, deps, env, descriptor, planeClass, fail } = lab;
-    const { runBudget, runSession, localTreeRoute, subjectEnvNames, publicRepo } = lab;
-    const { openaiApiKey, e2bApiKey, knownSecretValues, scrubKnownValues } = lab;
+export async function prepareConcurrentRun(study, scope) {
+    const { plan, input, config, requestedCwd, deps, env, descriptor, planeClass, fail } = study;
+    const { runBudget, runSession, localTreeRoute, subjectEnvNames, publicRepo } = study;
+    const { openaiApiKey, e2bApiKey, knownSecretValues, scrubKnownValues } = study;
     const { dryRun, concurrency } = plan;
     const cwd = await bindPhysicalProject(requestedCwd);
     const warnings = [];
@@ -90,7 +90,7 @@ export async function prepareConcurrentRun(lab, scope) {
     }
     const localTreeArchive = packed.archive;
     const localTreeArchiveBuffer = packed.buffer;
-    const started = await startConcurrentRun(lab, cwd, scope);
+    const started = await startConcurrentRun(study, cwd, scope);
     if (!started.ok)
         return { ok: false, result: fail(started.code, started.message, descriptor.id) };
     const { run } = started;
@@ -169,7 +169,7 @@ export async function prepareConcurrentRun(lab, scope) {
         receiving,
         warnings,
     };
-    const provisioned = provisionedSetup(lab, {
+    const provisioned = provisionedSetup(study, {
         localTreeArchive,
         localTreeArchiveBuffer,
         subjectComms,