humanish 0.107.0 → 0.109.0

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

@@ -2,7 +2,7 @@ import type { RunSubjectProvenance } from "../../run/bundle.js";
 import type { LocalTreeArchive } from "../../subject/local-tree-archive.js";
 /** Extract the in-sandbox port from the (loopback) serve.url so getHost can expose it. */
 export declare function servePort(serveUrl: string): number;
-/** A getHost URL must be tokenless (no userinfo and no query, so no authKey; invariant 1). */
+/** A getHost URL must be tokenless (no userinfo and no query, so no authKey reaches evidence). */
 export declare function isTokenlessHost(value: string): boolean;
 /** sha256-16 of a URL's origin: the publish-safe host identity persisted in the bundle (the raw
  *  getHost URL embeds the live sandbox id + matches the e2b-URL redaction, so it never lands raw). */
@@ -11,7 +11,7 @@ export declare function hostOriginDigest(url: string): string;
  *  entry path kept). Never contains the raw getHost URL. */
 export declare function publicSafeRouteLabel(entry: string | undefined): string;
 /**
- * Build the one subject sandbox's provenance (invariant 5): clone (repo + optional commit) or
+ * Build the one subject sandbox's provenance: clone (repo + optional commit) or
  * local-tree (archiveSha256 + optional commit/dirty from the once-per-run host-packed archive -
  * archiveSha256 is the pin; there is only one archive, so no per-participant unanimity math applies,
  * unlike the cua fan-out route). Used for both the in-progress and final bundle: the archive

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

@@ -8,7 +8,7 @@ export function servePort(serveUrl) {
         return Number(url.port);
     return url.protocol === "https:" ? 443 : 80;
 }
-/** A getHost URL must be tokenless (no userinfo and no query, so no authKey; invariant 1). */
+/** A getHost URL must be tokenless (no userinfo and no query, so no authKey reaches evidence). */
 export function isTokenlessHost(value) {
     try {
         const url = new URL(value);
@@ -34,7 +34,7 @@ export function publicSafeRouteLabel(entry) {
     return `[provisioned-subject]${entry ?? "/"}`;
 }
 /**
- * Build the one subject sandbox's provenance (invariant 5): clone (repo + optional commit) or
+ * Build the one subject sandbox's provenance: clone (repo + optional commit) or
  * local-tree (archiveSha256 + optional commit/dirty from the once-per-run host-packed archive -
  * archiveSha256 is the pin; there is only one archive, so no per-participant unanimity math applies,
  * unlike the cua fan-out route). Used for both the in-progress and final bundle: the archive

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

@@ -1,7 +1,7 @@
 // The provisioned-getHost plane: the harness provisions one subject sandbox (clone or local-tree,
 // install/build, seed, serve on 0.0.0.0), exposes it through getHost, probes its state on a
-// cadence, and runs every seat against that one shared plane. All sandboxes are torn down by exact
-// id in the plane's finally, never through Sandbox.list.
+// cadence, and runs every participant against that one shared plane. All sandboxes are torn down by
+// exact id in the plane's finally, never through Sandbox.list.
 import { buildOriginMap } from "../../comms/capture-surface.js";
 import { deployCommsCatch, refreshInboxSurface, writeInboxSurface, } from "../../comms/sandbox-catch.js";
 import { redactText, toErrorMessage } from "../../evidence/redaction.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
@@ -59,8 +59,8 @@ class SubjectPlane {
     subjectAllocation;
     subjectDesktop;
     subjectShell;
-    // The in-sandbox email catch on the one subject sandbox (#297); drained at teardown. Undefined
-    // unless a comms lab declared it.
+    // The in-sandbox email catch on the one subject sandbox; drained at teardown. Undefined
+    // unless a comms study declared it.
     deployedComms;
     // Background prober dispose signal, cleared in teardown.
     proberDisposed = false;
@@ -68,7 +68,7 @@ class SubjectPlane {
     disposeSignal;
     proberLoop;
     snapshotIndex = 0;
-    // Persona inbox surface (#297 slice B, shared-world): the serve->getHost origin-rewrite map
+    // Persona inbox surface: the serve->getHost origin-rewrite map
     // (required here so the app's loopback verify links resolve to a reachable host), and the
     // dedicated surface render loop.
     commsOriginMap = [];
@@ -103,8 +103,8 @@ class SubjectPlane {
         const { plan, deps, env, requestTimeoutMs, timeoutMs } = this.ctx;
         const { subjectEnvNames, commsEnv } = this.setup;
         const subjectModule = await (deps.desktopModule ?? loadE2BDesktopModule)();
-        // The one subject sandbox: headless service host (no GUI seat). The subject env is provisioned
-        // here; the actor sandboxes get none of it. A custom desktop template (image) is
+        // The one subject sandbox: headless service host (no GUI participant). The subject env is
+        // provisioned here; the actor sandboxes get none of it. A custom desktop template (image) is
         // honored on both the subject sandbox (here) and every actor sandbox (via runCuaParticipant, which
         // reads the same config); absent keeps the byte-stable Sandbox.create(opts) default. The
         // receipt is on disk before any work, so `humanish reclaim` can kill it by exact id.
@@ -119,11 +119,11 @@ class SubjectPlane {
                     SANDBOX_TIMEOUT_BUFFER_MS,
                 metadata: {
                     ...CONCURRENT_SHARED_WORLD_PROVIDER_METADATA,
-                    labId: plan.labId,
+                    labId: plan.studyId,
                     topology: "shared-world",
                     topologyMode: "concurrent",
-                    role: "subject",
-                    roleCount: String(plan.plane.participants.length),
+                    kind: "subject",
+                    participantCount: String(plan.plane.participants.length),
                 },
                 ...(subjectEnvNames.length > 0 || Object.keys(commsEnv).length > 0
                     ? {
@@ -228,7 +228,7 @@ class SubjectPlane {
         }
         this.getHostUrl = hostUrl;
     }
-    // Persona inbox surface (#297 slice B, shared-world): getHost-expose the read-only inbox listener so
+    // Persona inbox surface: getHost-expose the read-only inbox listener so
     // a persona in another sandbox can open it; build the serve->getHost origin map (required here:
     // the app's loopback verify links must be rewritten to a reachable host); provision the surface
     // channel; write the empty inbox up front (so /inbox never 404s); and start a render loop that drains
@@ -263,7 +263,7 @@ class SubjectPlane {
         const surfaceCadenceMs = 2500;
         this.surfaceLoop = (async () => {
             // Full, idempotent rebuild each tick; surfaceRenderedCount advances only on a successful render,
-            // so a transient failure retries cleanly. Real timer (dispose-interruptible + cleared) — an
+            // so a transient failure retries cleanly. Real timer (dispose-interruptible + cleared): an
             // unbounded loop must not busy-spin on the injected instant clock.
             for (;;) {
                 try {
@@ -327,7 +327,7 @@ class SubjectPlane {
             await this.proberLoop.catch(() => undefined);
         }
         // Stop the inbox-surface render loop too (shares the prober's dispose signal), before the teardown
-        // evidence drain below — so the two in-sandbox reads never overlap and the surface state is final.
+        // evidence drain below, so the two in-sandbox reads never overlap and the surface state is final.
         if (this.surfaceLoop) {
             await this.surfaceLoop.catch(() => undefined);
         }
@@ -370,7 +370,8 @@ class SubjectPlane {
         };
     }
 }
-/** Writes the in-progress bundle, runs the caller's Observer gate and starts the seat flush. */
+/** Writes the in-progress bundle, runs the caller's Observer gate and starts the participants'
+ *  flush. */
 async function publishInProgress(plane, ctx, live, setup) {
     const { plan, input } = ctx;
     const { localTreeRoute, localTreeArchive } = setup;
@@ -435,7 +436,7 @@ function runParticipants(plane, ctx, live, setup) {
         // Tell this persona its (getHost-reachable) inbox URL, but only when comms is live and this participant
         // has a declared recipient it can actually receive mail into (else it would stall on an empty
         // inbox). Only the in-sandbox catch exists on this plane; the adopter-hosted catch is the
-        // external-public plane's (#387).
+        // external-public plane's.
         const actorSpec = commsEmail && plane.commsInboxUrl && participantHasInboxRecipient(commsEmail, spec.planned.id)
             ? withInboxMission(spec, plane.commsInboxUrl, inboxRecipientFor(commsEmail, spec.planned.id)?.address)
             : spec;

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";
@@ -9,7 +9,9 @@ import { resolveSubjectState } from "../computer-use/subject-projection.js";
 import { actorRunPassed, buildConcurrentSharedWorldBundle, judgeSharedWorldRun, maxSimultaneousWindows, } from "./bundle.js";
 import { planeStateOf } from "./plan.js";
 import { buildSubjectProvenance, hostOriginDigest } from "./provenance.js";
-import { CONCURRENT_SHARED_WORLD_LAB_SCHEMA, } from "./types.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 {
@@ -65,7 +67,7 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
                 ? {}
                 : {
                     error: {
-                        code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+                        code: "HUMANISH_SHARED_WORLD_FAILED",
                         message: result.outcome.sessionError ??
                             (result.outcome.noEngagement
                                 ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
@@ -80,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)
@@ -88,16 +90,16 @@ function concurrentLabError(args) {
     if (handoffTimedOut) {
         // Checked before the observer failure: the host never yielded a /lobby/CODE within the
         // deadline (followers failed closed without opening), which is the root cause, and it can
-        // itself make the Observer unable to render a coherent run. Report the distinct, honest
+        // itself make the Observer unable to render a coherent run. Report the distinct
         // handoff-timeout code rather than a generic observer/run failure.
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_HANDOFF_TIMEOUT",
+            code: "HUMANISH_SHARED_WORLD_HANDOFF_TIMEOUT",
             message: runError ??
                 "The host participant never produced a /lobby/CODE URL within the handoff deadline.",
         };
     }
     if (hostHandoffFailure !== undefined) {
-        return { code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED", message: hostHandoffFailure };
+        return { code: "HUMANISH_SHARED_WORLD_FAILED", message: hostHandoffFailure };
     }
     // The run's own failure before the Observer's: a run that stopped early (a desktop module that
     // failed to load, a plane that failed to start) leaves a bundle verify then refuses, and naming
@@ -105,47 +107,46 @@ function concurrentLabError(args) {
     // evidence).
     if (runError) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: observer.ok ? runError : `${runError} The run bundle it left failed verification.`,
         };
     }
     if (!observer.ok) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: observer.error?.message ?? "Observer failed for the concurrent shared-world run.",
         };
     }
     if (adapterFailure !== undefined) {
-        return { code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED", message: adapterFailure };
+        return { code: "HUMANISH_SHARED_WORLD_FAILED", message: adapterFailure };
     }
     const passed = participantResults.filter((result) => result.ok).length;
     if (passed === participantCount && args.shortfall !== undefined) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: `Concurrent shared-world run did not run coherently. ${args.shortfall}`,
         };
     }
     if (passed === participantCount && args.executionFailure !== undefined) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: `Concurrent shared-world run failed as an execution. ${args.executionFailure}`,
         };
     }
     return {
-        code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
-        message: `Concurrent shared-world run did not run coherently: ${passed}/${participantCount} actor(s) reached a terminal, engaged passed session.`,
+        code: "HUMANISH_SHARED_WORLD_FAILED",
+        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) => ({
-        schema: CONCURRENT_SHARED_WORLD_LAB_SCHEMA,
+        ...studyResultIdentity("shared-world", envelope.studyId),
         ok: false,
         cwd: envelope.cwd,
-        labId: envelope.labId,
         actor: actorLabel ?? envelope.actor,
         topology: "shared-world",
         topologyMode: "concurrent",
@@ -159,10 +160,10 @@ export function concurrentLabFailure(envelope) {
     });
 }
 /**
- * The run's execution failures: a run error (the handoff, the plane), each seat whose session
- * failed in the harness, each provider whose cleanup is unconfirmed or that reported a disallowed
- * item after its last request, each sandbox whose release is unconfirmed, and an Observer that
- * failed.
+ * The run's execution failures: a run error (the handoff, the plane), each participant whose
+ * session failed in the harness, each provider whose cleanup is unconfirmed or that reported a
+ * disallowed item after its last request, each sandbox whose release is unconfirmed, and an
+ * Observer that failed.
  */
 function sharedWorldExecutionFailures(args) {
     const { runId, runError, actorResults, subject, observer } = args;
@@ -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",
@@ -288,8 +289,8 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
     if (observer.ok && live.observer) {
         attachObserverRuntimeStreamUrls(observer, live.streamUrls);
     }
-    // Concurrent "ok": every actor must produce a terminal, engaged, passed session, and the seats
-    // must show the concurrency verify requires of a pass (judgeSharedWorld). This is a
+    // Concurrent "ok": every actor must produce a terminal, engaged, passed session, and the
+    // participants must show the concurrency verify requires of a pass (judgeSharedWorld). This is a
     // harness/session-credibility gate, not mission-completion proof; a failed actor trace cannot
     // make the route green just because the harness got a terminal.
     const adapterFailure = adapterScoreFailureMessage(bundle);
@@ -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,10 +312,9 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
         executionFailure: execution.failures[0]?.message,
     });
     const result = {
-        schema: CONCURRENT_SHARED_WORLD_LAB_SCHEMA,
+        ...studyResultIdentity("shared-world", plan.studyId),
         ok,
         cwd,
-        labId: plan.labId,
         actor: descriptor.id,
         topology: "shared-world",
         topologyMode: "concurrent",

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,14 +1,14 @@
-// The concurrent shared-world lab backend (#164 phase 2): 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:
 //
 //   - One subject sandbox: provisionCloneSubject once (clone+install+build+seed) + serve on
 //     0.0.0.0, exposed via getHost(port) → a tokenless reachable URL (the headless service host;
-//     no GUI seat).
+//     no GUI participant).
 //   - N actor desktop sandboxes: fan-out's runCuaParticipant machinery (per-participant device/persona, by-id
-//     teardown) bounded by execution.concurrency, each browser pointed at the getHost URL —
+//     teardown) bounded by execution.concurrency, each browser pointed at the getHost URL and
 //     driving the shared service at the same time. Independent: no pipeline gate, no
-//     fail-fast — one actor's failure must not block the swarm or corrupt the "M of N" outcomes.
+//     fail-fast: one actor's failure must not block the swarm or corrupt the "M of N" outcomes.
 //   - A background prober snapshots the subject DB checkpoint digests on a cadence → a stateSeries
 //     of the shared world evolving under load.
 //   - All N+1 sandboxes torn down by exact id in a finally, never through Sandbox.list.
@@ -20,10 +20,10 @@
 // `best-effort-causal-attribution`, `non-deterministic-shared-state`,
 // `window-and-snapshot-granularity`, `contention-observed-not-proven-safe`,
 // `state-change-not-isolated-to-actors`. laneWindows + stateSeries are independent series with no
-// per-delta→actor field — causation under concurrency is structurally inexpressible.
+// per-delta→actor field, so causation under concurrency is structurally inexpressible.
 //
-// Capability and proof: the deterministic $0 gate proves the plumbing + the honesty
-// contract — the real mapWithConcurrency produces genuinely overlapping laneWindows (a rendezvous
+// Capability and proof: the deterministic $0 gate proves the plumbing + the claims-match-mechanism
+// contract: the real mapWithConcurrency produces genuinely overlapping laneWindows (a rendezvous
 // latch in the fake session forces two participant fns in-flight while the real orchestrator clock
 // measures the windows). Every generated bundle describes only its own observations; no one run
 // establishes scale, repeatability, or adopter-harness replacement.
@@ -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,49 +42,49 @@ 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_CONCURRENT_SHARED_WORLD_LAB_AGENT_MISSING",
-    "signin-required": "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_AGENT_SIGNIN_REQUIRED",
-    unsupported: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_ACTOR_UNSUPPORTED",
-    "unpriced-cap": "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_UNPRICED_CAP",
+    "agent-missing": "HUMANISH_SHARED_WORLD_AGENT_MISSING",
+    "signin-required": "HUMANISH_SHARED_WORLD_AGENT_SIGNIN_REQUIRED",
+    unsupported: "HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED",
+    "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-seat labs, so this fallback serves only library
-        // callers: every declared seat runs at once unless the author declared a cap (#350).
+        // The parser fills concurrency for multi-participant studies, so this fallback serves only
+        // library callers: every declared participant runs at once unless the author declared a cap.
         concurrency: config.execution?.concurrency ?? Math.max(1, declared.length),
         dryRun,
         runId: options.runId,
@@ -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.
  */
@@ -125,14 +125,15 @@ async function admitSharedWorldRun(plan, input) {
         return undefined;
     const env = input.env ?? process.env;
     const fail = (code, message) => completeSharedWorldAnalysis(plan, input, sharedWorldFailure(plan, input)(code, message, sharedWorldDescriptorOf(plan.actor).id), undefined);
-    // The plan lists OPENAI_API_KEY for an openai brain's seats and the external-public plane's
-    // lobby-code reader; a local-agent brain's seats run on the operator's signed-in agent instead.
+    // The plan lists OPENAI_API_KEY for an openai brain's participants and the external-public
+    // plane's lobby-code reader; a local-agent brain's participants run on the operator's signed-in
+    // agent instead.
     const missing = missingKeys(plan.requirements, env);
     if (missing.length > 0) {
-        return fail("HUMANISH_CONCURRENT_SHARED_WORLD_LAB_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 seats' desktops are paid for is the same
+        // A missing or signed-out agent found after the participants' desktops are paid for is the same
         // news at the worst moment.
         const refusal = await localAgentRefusal({ agent: plan.brain.agent, env, caps: plan.caps });
         if (refusal)
@@ -140,7 +141,7 @@ async function admitSharedWorldRun(plan, input) {
     }
     const unsetSubjectEnv = missingSubjectEnv(plan.requirements, env);
     if (unsetSubjectEnv.length > 0) {
-        return fail("HUMANISH_CONCURRENT_SHARED_WORLD_LAB_SUBJECT_ENV_MISSING", `subject.env declares ${unsetSubjectEnv.join(", ")} but the environment does not provide ${unsetSubjectEnv.length === 1 ? "it" : "them"} (pass via --env-file; values are never persisted).`);
+        return fail("HUMANISH_SHARED_WORLD_SUBJECT_ENV_MISSING", `subject.env declares ${unsetSubjectEnv.join(", ")} but the environment does not provide ${unsetSubjectEnv.length === 1 ? "it" : "them"} (pass via --env-file; values are never persisted).`);
     }
     return undefined;
 }
@@ -163,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,
@@ -232,13 +233,13 @@ async function runPlanInScope(plan, input, config, scope) {
     const { ctx, live, results } = prepared;
     const planeRan = await runPlane(ctx, live, results, prepared.plane);
     if (!planeRan) {
-        return fail("HUMANISH_CONCURRENT_SHARED_WORLD_LAB_INVALID", "the provisioned-getHost concurrent shared-world route requires `subject.serve`.", descriptor.id);
+        return fail("HUMANISH_SHARED_WORLD_INVALID", "the provisioned-getHost concurrent shared-world route requires `subject.serve`.", descriptor.id);
     }
     return finishConcurrentRun(ctx, live, results, prepared.finish);
 }
 /**
- * Runs the plane the lab declares, then finalizes email receiving and stops the seats' flush on
- * every exit. Returns false when a provisioned lab reaches it without `subject.serve`.
+ * Runs the plane the study declares, then finalizes email receiving and stops the participants'
+ * flush on every exit. Returns false when a provisioned study reaches it without `subject.serve`.
  */
 async function runPlane(ctx, live, results, plane) {
     const { dryRun } = ctx.plan;
@@ -266,7 +267,7 @@ async function runPlane(ctx, live, results, plane) {
         catch {
             ctx.warnings.push("Email finalization could not complete. Inspect humanish comms recover; provider cleanup remains unresolved.");
         }
-        // Stop the seats' flush timer on every exit, before the final write.
+        // Stop the participants' flush timer on every exit, before the final write.
         await live.flush?.stop();
     }
     return true;