humanish 0.107.0 → 0.109.0

package/dist/routes/computer-use/external-comms.d.ts

@@ -1,8 +1,8 @@
-import type { LabCommsEmail, LabCommsExternal } from "../../lab/types.js";
+import type { StudyCommsEmail, StudyCommsExternal } from "../../study/types.js";
 import type { PreparedRunArtifactPaths } from "../../run/paths.js";
 import type { DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
 /**
- * Adopter-hosted drain (#380): once per RUN, after every participant finished — the catch is one
+ * Adopter-hosted drain: once per run, after every participant finished, because the catch is one
  * shared external endpoint, not a per-sandbox file. Same routing and digest-only artifact as
  * the in-sandbox drain; the artifact is registered on every participant that declared a recipient
  * address, since the thread carries each inbox's mail. A drain failure never fails the run.
@@ -10,8 +10,8 @@ import type { DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
  * Returns the warnings the drain produced; participants that received mail get `commsArtifactPath`.
  */
 export declare function drainExternalComms(args: {
-    externalCommsConfig: LabCommsExternal;
-    externalCommsEmail: LabCommsEmail;
+    externalCommsConfig: StudyCommsExternal;
+    externalCommsEmail: StudyCommsEmail;
     env: Record<string, string | undefined>;
     runPaths: PreparedRunArtifactPaths;
     participantRuns: readonly DesktopParticipantRun[];

package/dist/routes/computer-use/external-comms.js

@@ -1,7 +1,7 @@
 import { collectExternalCommsEvidence } from "../../comms/external-evidence.js";
 import { participantHasInboxRecipient } from "./participant-desktop.js";
 /**
- * Adopter-hosted drain (#380): once per RUN, after every participant finished — the catch is one
+ * Adopter-hosted drain: once per run, after every participant finished, because the catch is one
  * shared external endpoint, not a per-sandbox file. Same routing and digest-only artifact as
  * the in-sandbox drain; the artifact is registered on every participant that declared a recipient
  * address, since the thread carries each inbox's mail. A drain failure never fails the run.

package/dist/routes/computer-use/fanout-bundle.js

@@ -10,6 +10,7 @@ import { participantPassed, participantStatus } from "../../run/judge.js";
 import { buildRunCostSummary, desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { formatParticipantPlanEntry } from "./participant-runs.js";
 import { fanoutParticipantRecords } from "./fanout-records.js";
+import { plural } from "../../run/text.js";
 /** The run's first two events: its creation and the fan-out plan. */
 function fanoutPlanEvents(args) {
     const { specs, plan } = args;
@@ -19,14 +20,14 @@ function fanoutPlanEvents(args) {
         at: args.run.createdAt,
         level: "info",
         type: "cua-lab.run.created",
-        message: `Created computer-use fan-out run for ${plan.labId} (actor ${args.descriptor.id}, ${specs.length} participants, one world each).`,
+        message: `Created computer-use fan-out run for ${plan.studyId} (actor ${args.descriptor.id}, ${specs.length} participants, one world each).`,
     });
     events.push({
         id: "event-001-fanout-plan",
         at: args.run.createdAt,
         level: "info",
         type: "cua-lab.fanout.plan",
-        message: `Fan-out plan: ${args.participantPlan.laneCount} participant(s) (${args.participantPlan.strategy}), concurrency ${args.participantPlan.concurrency}, ${args.participantPlan.waves} wave(s); session budget ${Math.round(args.participantPlan.perLaneSessionBudgetMs / 1000)}s per participant; worst-case ~${args.participantPlan.worstCaseSandboxMinutes} sandbox-minutes${args.dryRun ? " (dry-run: $0)" : ""}. Participants: ${args.participantPlan.lanes.map(formatParticipantPlanEntry).join(", ")}.`,
+        message: `Fan-out plan: ${plural(args.participantPlan.laneCount, "participant")} (${args.participantPlan.strategy}), concurrency ${args.participantPlan.concurrency}, ${plural(args.participantPlan.waves, "wave")}; session budget ${Math.round(args.participantPlan.perLaneSessionBudgetMs / 1000)}s per participant; worst-case ~${args.participantPlan.worstCaseSandboxMinutes} sandbox-minutes${args.dryRun ? " (dry-run: $0)" : ""}. Participants: ${args.participantPlan.lanes.map(formatParticipantPlanEntry).join(", ")}.`,
     });
     return events;
 }
@@ -35,26 +36,26 @@ function fanoutReview(args, streams) {
     // The judge's verdict: live fan-out must prove every participant (judgeParticipants).
     const verdict = args.verdict;
     const passedParticipants = (outcomes ?? []).filter((outcome) => participantPassed(participantFactsOf(outcome))).length;
-    // What happened to the PARTICIPANTS, with the denominator attached. The verdict above has to
+    // What happened to the participants, with the denominator attached. The verdict above has to
     // collapse the run to one word; this does not (docs/principles/three-roles.md).
     const terminalOutcomes = (outcomes ?? []).filter((outcome) => outcome?.session?.status !== undefined);
     const participants = terminalOutcomes.length > 0
         ? tallyParticipantOutcomes(
-        // A NO-ENGAGEMENT participant is not one who reached the goal. It said "done" having
+        // A no-engagement participant is not one who reached the goal. It said "done" having
         // taken zero actions and said nothing, and `passedParticipants` above already refuses to
-        // count it — but `reachedGoal` was reading the trace status directly, so one run could be both
-        // "not a passed participant" AND "1/1 reached the goal". The headline number a researcher reads
+        // count it, but `reachedGoal` was reading the trace status directly, so one run could be both
+        // "not a passed participant" and "1/1 reached the goal". The headline number a researcher reads
         // first was the dishonest one. Found by a provider bug that ended a study on turn one.
         terminalOutcomes.map((outcome) => participantStatus(outcome.session.status, {
             noEngagement: outcome.noEngagement === true,
             selfReportedBlocker: outcome.selfReportedBlocker === true,
         })), 
-        // A participant who reached the goal AND told you the road there was broken is the most
+        // A participant who reached the goal and told you the road there was broken is the most
         // useful result a study produces; reporting only the outcome would bury it.
         terminalOutcomes.map((outcome) => outcome.reportedFriction === true))
         : undefined;
     // The study funnel: per-task completion rates across every session that measured one. This is
-    // "where did people get stuck" as data, next to WHO got stuck (participants) above.
+    // "where did people get stuck" as data, next to who got stuck (participants) above.
     const participantFunnels = (outcomes ?? [])
         .map((outcome) => outcome?.session?.trace.taskFunnel)
         .filter((funnel) => funnel !== undefined);
@@ -74,12 +75,12 @@ function fanoutReview(args, streams) {
         summary: args.inProgress === true
             ? `Live computer-use fan-out is running (${specs.length} participants, one world each); terminal participant evidence has not been written yet.`
             : args.dryRun
-                ? `${args.rerun ? `Rerun contract from ${args.rerun.sourceRunId}: ` : ""}Dry-run fan-out contract: ${specs.length} participants composed for ${args.descriptor.id} against ${args.appUrl}, one world each; no desktops launched, $0 spend.`
-                : `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Computer-use fan-out (${specs.length} participants, one world each): ${passedParticipants}/${specs.length} participant(s) reached a terminal, engaged verdict${participants ? `: ${formatParticipantOutcomes(participants, participantEndings)}` : ""}${runTasks ? `; tasks: ${formatRunTaskFunnel(runTasks)}` : ""}.`,
+                ? `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Dry-run fan-out: ${specs.length} participants composed for ${args.descriptor.id} against ${args.appUrl}, one world each; no desktops launched, $0 spend.`
+                : `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Computer-use fan-out (${specs.length} participants, one world each): ${passedParticipants}/${plural(specs.length, "participant")} reached a terminal, engaged verdict${participants ? `: ${formatParticipantOutcomes(participants, participantEndings)}` : ""}${runTasks ? `; tasks: ${formatRunTaskFunnel(runTasks)}` : ""}.`,
         gaps: args.inProgress === true
             ? ["Live fan-out session is still running."]
             : args.dryRun
-                ? ["Live fan-out session not yet run (dry-run contract only)."]
+                ? ["Live fan-out session not yet run (dry run only)."]
                 : specs
                     .map((spec, index) => ({ spec, outcome: outcomes?.[index] }))
                     .filter(({ outcome }) => outcome === undefined ||
@@ -112,7 +113,7 @@ function fanoutDesktopBrowser(args) {
 }
 function fanoutCost(args) {
     const { specs, outcomes } = args;
-    // Run-level cost ESTIMATE: one model-token line per participant that ran a session (from its persisted
+    // Run-level cost estimate: one model-token line per participant that ran a session (from its persisted
     // trace.estimatedCost) + a desktop line per owned allocation, priced at its observed resources.
     // `per-lane-worlds` participants have no shared provisioning to double-count. Omitted on a pure dry-run.
     const costTraces = specs
@@ -136,8 +137,8 @@ function fanoutFeedbackCandidates(args) {
         ? []
         : participantFeedbackCandidates({
             runId: args.run.runId,
-            scenarioId: `cua-${plan.labId}`,
-            adapterId: plan.labId,
+            scenarioId: `cua-${plan.studyId}`,
+            adapterId: plan.studyId,
             goal: redactText(specs[0].evidenceInstructions ?? specs[0].instructions),
             substrate: plan.residual.execution?.target === "local" ? "local-desktop" : "e2b-desktop",
             participants: specs.map((spec, index) => {
@@ -179,7 +180,7 @@ export function buildCuaFanoutBundle(args) {
             at: args.run.createdAt,
             level: "info",
             type: "cua-lab.fanout.rerun",
-            message: `Rerun selected ${args.rerun.selectedLaneIds.length} participant(s) from ${args.rerun.sourceRunId}: ${args.rerun.previous.map((prior) => `${prior.laneId} was ${prior.status}${prior.completionReason ? `/${prior.completionReason}` : ""}`).join(", ")}. This is a new linked run; the source run verdict is unchanged.`,
+            message: `Rerun selected ${plural(args.rerun.selectedLaneIds.length, "participant")} from ${args.rerun.sourceRunId}: ${args.rerun.previous.map((prior) => `${prior.laneId} was ${prior.status}${prior.completionReason ? `/${prior.completionReason}` : ""}`).join(", ")}. This is a new linked run; the source run verdict is unchanged.`,
         });
     }
     specs.forEach((spec, index) => {
@@ -218,22 +219,22 @@ export function buildCuaFanoutBundle(args) {
         persona: {
             id: specs[0].persona.id,
             name: `Computer-use fan-out (${specs.length} participants)`,
-            source: `lab:${plan.labId}`,
+            source: `study:${plan.studyId}`,
             sourceDigest: specs[0].persona.promptDigest,
         },
         scenario: {
-            id: `cua-${plan.labId}`,
-            title: plan.title ?? `Computer-use fan-out: ${plan.labId}`,
-            // Redacted at WRITE time, like every other raw-text surface in the bundle. Participant records are
-            // digest-only by design, but scenario.goal keeps one participant's composed instructions verbatim —
+            id: `cua-${plan.studyId}`,
+            title: plan.title ?? `Computer-use fan-out: ${plan.studyId}`,
+            // Redacted at write time, like every other raw-text surface in the bundle. Participant records are
+            // digest-only by design, but scenario.goal keeps one participant's composed instructions verbatim,
             // and an adopter whose authored participant text must name a runtime world URL (an inbox on a route
             // where the harness does not inject one) put an *.e2b.app address in it. That landed raw here
             // and in observer-data.json, the sensitive-text scanner matched it, and verify failed a bundle
-            // this writer produced. The only adopter-side workaround was scanner evasion (#412).
+            // this writer produced. The only adopter-side workaround was scanner evasion.
             //
             // The instructions the model actually receives are untouched; only the persisted copy changes.
             goal: redactText(specs[0].evidenceInstructions ?? specs[0].instructions),
-            source: `lab:${plan.labId}`,
+            source: `study:${plan.studyId}`,
             sourceDigest: specs[0].persona.promptDigest,
         },
         lifecycle: [
@@ -251,14 +252,14 @@ export function buildCuaFanoutBundle(args) {
             status: "passed",
             notes: ranLive
                 ? anyRaw
-                    ? "Typed text recorded as length only and reasoning/messages pass through text redaction. Some participants captured FULL-FIDELITY (raw) screenshots, retained for local use and NOT redacted for publishing; set policies.redactScreenshots: true to blur a share-as-is bundle."
+                    ? "Typed text is recorded as its length only, and reasoning and messages pass through text redaction. Some participants captured unblurred screenshots, kept for local use and not redacted for publishing. Set policies.redactScreenshots: true to blur screenshots in a bundle you plan to share."
                     : "Typed text recorded as length only and reasoning/messages pass through text redaction. Screenshots are blurred at capture (policies.redactScreenshots: true) for a share-as-is bundle."
-                : "Dry-run fan-out contract bundle: no desktops launched and no screenshots captured. Typed text is recorded as length only and reasoning/messages pass through text redaction whenever a session runs.",
+                : "Dry-run fan-out bundle: no desktops launched and no screenshots captured. Typed text is recorded as length only and reasoning/messages pass through text redaction whenever a session runs.",
         },
         artifacts: bundleArtifacts(),
         review,
-        // What the participants reported, when any reported anything (#392). Dry-run and in-progress
-        // bundles carry none — there is no participant yet to quote.
+        // What the participants reported, when any reported anything. Dry-run and in-progress
+        // bundles carry none: there is no participant yet to quote.
         feedbackCandidates: fanoutFeedbackCandidates(args),
         // Selected hosted image, including the optional speech default; omitted on the stock desktop.
         ...(desktopTemplate === undefined ? {} : { desktopTemplate }),

package/dist/routes/computer-use/fanout-records.js

@@ -1,6 +1,6 @@
 // Each participant's records in a computer-use fan-out bundle: its simulation, its stream, its
 // subject provenance event and the events of its outcome (session, geometry warnings, phase trail).
-import { participantAssignment } from "../../lab/participant-assignment.js";
+import { participantAssignment } from "../../study/participant-assignment.js";
 import { participantEvent, participantRecord, participantStream, } from "../../run/participant-records.js";
 import { declaredScreenForRender } from "../../substrates/e2b/desktop-geometry.js";
 import { describeSubjectState, phaseEventIdSuffix, publicSafeAppUrlLabel } from "./bundle-parts.js";
@@ -41,7 +41,7 @@ function fanoutParticipantView(args, spec, index) {
         : (outcome?.skippedReason ??
             session?.reason ??
             outcome?.sessionError ??
-            "Contract bundle only: dry-run produced the evidence shape without launching a desktop or spending provider tokens.");
+            "Dry run: the evidence shape was written without launching a desktop or spending provider tokens.");
     const traceScreenshotMode = session?.trace.redaction.screenshots;
     const screenshotMode = traceScreenshotMode === "raw" || traceScreenshotMode === "blurred"
         ? traceScreenshotMode
@@ -66,7 +66,7 @@ function fanoutParticipantRecord(args, spec, index, view) {
     const { outcome, publicTargetUrl, session, status, reason } = view;
     return participantRecord(spec, index + 1, {
         personaId: spec.persona.id,
-        scenarioId: `cua-${plan.labId}`,
+        scenarioId: `cua-${plan.studyId}`,
         status,
         streamKind: "browser",
         mode: "browser-sim",
@@ -80,13 +80,12 @@ function fanoutParticipantRecord(args, spec, index, view) {
                     ? `Participant ${spec.planned.id} ${outcome.skippedReason}.`
                     : outcome?.sessionError !== undefined
                         ? `Participant ${spec.planned.id} failed before a terminal session verdict: ${outcome.sessionError}`
-                        : `Contract participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}) for ${args.descriptor.id} against ${publicTargetUrl}.`,
+                        : `Participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}) for ${args.descriptor.id} against ${publicTargetUrl}; no session ran.`,
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
     });
 }
 function fanoutParticipantStream(args, spec, view) {
-    const { plan } = args;
     const { outcome, publicTargetUrl, session, desktopGeometry, screenshots } = view;
     const { lastScreenshot, status, reason, screenshotMode } = view;
     const judged = outcome === undefined ? undefined : judgedStatus(participantFactsOf(outcome));
@@ -104,7 +103,7 @@ function fanoutParticipantStream(args, spec, view) {
             ? {}
             : { caseGroup: spec.planned.labels.caseGroup }),
         kind: "browser",
-        label: `CUA participant ${spec.planned.id}: ${plan.labId}`,
+        label: `${spec.planned.id} · browser`,
         status,
         ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
@@ -113,9 +112,9 @@ function fanoutParticipantStream(args, spec, view) {
             ? {
                 kind: "screenshot",
                 url: lastScreenshot,
-                title: `CUA desktop ${spec.planned.id} (${screenshotMode})`,
+                title: `Desktop (${screenshotMode})`,
             }
-            : { kind: "placeholder", title: `CUA desktop ${spec.planned.id}` },
+            : { kind: "placeholder", title: "Desktop" },
         ...(desktopGeometry.viewport === undefined
             ? {}
             : {
@@ -180,7 +179,7 @@ function fanoutSubjectEvents(ctx, spec, view) {
     const { publicTargetUrl, subject, session } = view;
     const events = [];
     const record = (event) => events.push(participantEvent(spec, event));
-    // Per-participant subject provenance (invariant 5).
+    // Per-participant subject provenance.
     if (args.plan.runner.subject.kind === "clone" && args.publicRepo) {
         record({
             id: nextEventId(`subject-${spec.planned.id}`),
@@ -188,7 +187,7 @@ function fanoutSubjectEvents(ctx, spec, view) {
             level: "info",
             type: "cua-lab.subject.provenance",
             message: `Participant ${spec.planned.id}: ${args.dryRun
-                ? `subject declared: clone of ${args.publicRepo}, served at ${publicTargetUrl} in-sandbox (dry-run contract; nothing cloned)`
+                ? `subject declared: clone of ${args.publicRepo}, served at ${publicTargetUrl} in-sandbox (dry run; nothing cloned)`
                 : subject.commit
                     ? session
                         ? `subject cloned from ${args.publicRepo}@${subject.commit} and served at ${publicTargetUrl} in-sandbox`
@@ -203,7 +202,7 @@ function fanoutSubjectEvents(ctx, spec, view) {
             level: "info",
             type: "cua-lab.subject.provenance",
             message: `Participant ${spec.planned.id}: ${args.dryRun
-                ? `subject declared: local working tree, to be packed and served at ${publicTargetUrl} in-sandbox (dry-run contract; nothing packed)`
+                ? `subject declared: local working tree, to be packed and served at ${publicTargetUrl} in-sandbox (dry run; nothing packed)`
                 : subject.archiveSha256
                     ? session
                         ? `subject packed (archiveSha256 ${subject.archiveSha256}${subject.dirty === true ? ", dirty working tree" : subject.dirty === false ? ", clean working tree" : ""}) and served at ${publicTargetUrl} in-sandbox`
@@ -270,7 +269,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
             at: args.run.createdAt,
             level: "info",
             type: "cua-lab.contract.ready",
-            message: `Participant ${spec.planned.id}: dry-run contract participant ready; switch scenario.mode to live for a real desktop session.`,
+            message: `Participant ${spec.planned.id}: dry-run participant ready; switch scenario.mode to live for a real desktop session.`,
         });
     }
     for (const warning of desktopGeometry.warnings ?? []) {
@@ -282,7 +281,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
             message: warning,
         });
     }
-    // Persisted per-participant phase trail (real boot timing): one RunEvent per COMPLETED phase
+    // Persisted per-participant phase trail (real boot timing): one RunEvent per completed phase
     // boundary this participant recorded (started events never persist here; they carry no durationMs).
     for (const phase of outcome?.phaseRecords ?? []) {
         record({

package/dist/routes/computer-use/live-flush.d.ts

@@ -2,7 +2,7 @@ import type { ActorTokenUsage, ActorTraceItem } from "../../actors/contract.js";
 import type { CuaLiveMetadata } from "../../actors/computer-use/loop.js";
 import { type ObserverResult } from "../../observer/render.js";
 import type { RunBundle } from "../../run/bundle.js";
-import type { RunLabHomes } from "../../lab/run-lab-homes.js";
+import type { RunStudyHomes } from "../../study/run-study-homes.js";
 import type { DesktopParticipantRun } from "./types.js";
 export interface LiveTraceFlush {
     /** Record a participant's recorded-so-far items; the bundle rewrite follows on the flush
@@ -12,7 +12,7 @@ export interface LiveTraceFlush {
     stop: () => Promise<void>;
 }
 /**
- * Incremental live flush (#441): as each participant's loop reports its recorded-so-far items,
+ * Incremental live flush: as each participant's loop reports its recorded-so-far items,
  * rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
  * Observer's 5s poll sees the timeline grow. Throttled (one write per interval, trailing
  * write guaranteed). `write` is the run's `writeSnapshot`, which serializes writes and refuses
@@ -32,9 +32,9 @@ export declare function startLiveTraceFlush(args: {
  * the run. The URLs carry auth, so they live in memory and on the Observer result, never in run
  * artifacts.
  */
-export declare function trackRuntimeStreams(onStream: RunLabHomes["onStream"] | undefined): {
+export declare function trackRuntimeStreams(onStream: RunStudyHomes["onStream"] | undefined): {
     /** Records each stream for the Observer, after the caller's onStream. */
-    onStream: NonNullable<RunLabHomes["onStream"]>;
+    onStream: NonNullable<RunStudyHomes["onStream"]>;
     /** From now on, keep this live Observer's stream list current. */
     showIn: (observer: ObserverResult & {
         ok: true;

package/dist/routes/computer-use/live-flush.js

@@ -1,7 +1,7 @@
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
 import {} from "../../observer/run-routes.js";
 /**
- * Incremental live flush (#441): as each participant's loop reports its recorded-so-far items,
+ * Incremental live flush: as each participant's loop reports its recorded-so-far items,
  * rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
  * Observer's 5s poll sees the timeline grow. Throttled (one write per interval, trailing
  * write guaranteed). `write` is the run's `writeSnapshot`, which serializes writes and refuses
@@ -42,9 +42,9 @@ export function startLiveTraceFlush(args) {
                             liveActor: {
                                 schema: "humanish.live-actor.v1",
                                 updatedAt,
-                                // WHO this participant is, carried while the run is live. Without it a
-                                // surface watching a live run can only name the participant id, and "CUA browser — observer-live-
-                                // check" is the harness talking about itself where the participant should be.
+                                // Who this participant is, carried while the run is live. Without it a
+                                // surface watching a live run can only name the participant id and the stream
+                                // label (`<participant id> · browser`), which describe the harness, not the participant.
                                 ...(personaByStream.get(stream.id) === undefined
                                     ? {}
                                     : { persona: { id: personaByStream.get(stream.id) } }),
@@ -125,8 +125,8 @@ export function trackRuntimeStreams(onStream) {
             await onStream?.(event);
             if (event.type === "ready")
                 urls.push({ streamId: event.streamId, url: event.url });
-            // Mark, never remove: the tile needs to KNOW the live view ended (and say so) rather than
-            // have the stream silently vanish from the overlay (#357).
+            // Mark, never remove: the tile needs to know the live view ended (and say so) rather than
+            // have the stream silently vanish from the overlay.
             else
                 for (const entry of urls)
                     if (entry.streamId === event.streamId)

package/dist/routes/computer-use/live-phase.d.ts

@@ -5,15 +5,16 @@ import type { CuaParticipantsSetup, CuaRunSetup } from "./setup.js";
  * Runs the participants (a dry run runs none). Returns the refusal when real email setup fails, or
  * the participant outcomes and the warnings the finish records.
  */
-export declare function runLabParticipants(setup: CuaRunSetup, participants: CuaParticipantsSetup): Promise<{
+export declare function runStudyParticipants(setup: CuaRunSetup, participants: CuaParticipantsSetup): Promise<{
     ok: false;
     result: {
         automaticAnalysis?: import("../../analysis/job.js").AutomaticAnalysisOutcome;
         automaticAnalysisTrigger?: "default" | "explicit";
-        schema: typeof import("./types.js").CUA_ACTOR_LAB_SCHEMA;
+        schema: typeof import("../../run/study-result.js").STUDY_RESULT_SCHEMA;
+        route: "computer-use";
+        studyId: string;
         ok: boolean;
         cwd: string;
-        labId: string;
         actor: string;
         appUrl: string;
         dryRun: boolean;
@@ -38,7 +39,7 @@ export declare function runLabParticipants(setup: CuaRunSetup, participants: Cua
         diagnostics?: import("./diagnostics.js").CuaDiagnostics;
         warnings: string[];
         error?: {
-            code: import("./types.js").CuaActorLabErrorCode;
+            code: import("./types.js").CuaActorStudyErrorCode;
             message: string;
         };
         runId: string;

package/dist/routes/computer-use/live-phase.js

@@ -2,7 +2,7 @@
 // receiving, the participants themselves, and the drain of an operator-hosted inbox.
 import { prepareReceivingRun } from "../../comms/receiving-runtime.js";
 import { liveObserverResult } from "../../observer/live.js";
-import { pricedModel } from "../../lab/plan-base.js";
+import { pricedModel } from "../../study/plan-base.js";
 import { runAllCuaParticipants } from "./participant-execution.js";
 import { startLiveTraceFlush } from "./live-flush.js";
 import { drainExternalComms } from "./external-comms.js";
@@ -12,7 +12,7 @@ import { participantSubjectEnv } from "./types.js";
  * Runs the participants (a dry run runs none). Returns the refusal when real email setup fails, or
  * the participant outcomes and the warnings the finish records.
  */
-export async function runLabParticipants(setup, participants) {
+export async function runStudyParticipants(setup, participants) {
     const { plan, input, cwd, streams, descriptor, run } = setup;
     const { participantRuns, participantPlan, bundleBase } = setup;
     const { env, knownSecretValues, deps, liveTrace, externalComms, inProgress, fail } = participants;
@@ -20,10 +20,10 @@ export async function runLabParticipants(setup, participants) {
     const inProcess = plan.runner.desktop === "in-process";
     const subjectEnvNames = [...participantSubjectEnv(plan.runner.subject)];
     const { runId, paths: runPaths } = run;
-    // A live run writes what it is doing AS IT DOES IT, whether or not anyone is currently watching.
-    // This used to be gated on `options.onObserverReady` — the interactive Observer callback — so a
-    // run launched by an agent (`lab run --json`), detached, or from the terminal surface recorded
-    // nothing at all until it completed, and anything asking "what is this participant doing right
+    // A live run writes what it is doing as it does it, whether or not anyone is currently watching.
+    // This is not gated on `options.onObserverReady` (the interactive Observer callback): gated, a
+    // run launched by an agent (`run --json`), detached, or from the terminal surface records
+    // nothing at all until it completes, and anything asking "what is this participant doing right
     // now" got silence for the whole run. Who reads the evidence is not the run's business; the
     // callback below stays conditional, the writing does not.
     if (!dryRun) {
@@ -47,7 +47,7 @@ export async function runLabParticipants(setup, participants) {
         streams.showIn(liveObserver);
         if (input.onObserverReady)
             await input.onObserverReady(liveObserver);
-        // Incremental live flush (#441): as each participant's loop reports its recorded-so-far items,
+        // Incremental live flush: as each participant's loop reports its recorded-so-far items,
         // rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
         // Observer's 5s poll sees the timeline grow. The run refuses any snapshot once the final
         // write began; the route stops the flush timer on every exit below.
@@ -91,7 +91,7 @@ export async function runLabParticipants(setup, participants) {
             return {
                 ok: false,
                 result: {
-                    ...fail("HUMANISH_CUA_LAB_SUBJECT_INVALID", "Real email setup failed before desktop allocation. Run humanish comms check --online and humanish comms recover to inspect authentication and pending cleanup.", descriptor.id),
+                    ...fail("HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "Real email setup failed before desktop allocation. Run humanish comms check --online and humanish comms recover to inspect authentication and pending cleanup.", descriptor.id),
                     runId,
                 },
             };

package/dist/routes/computer-use/local-tree-pack.d.ts

@@ -1,12 +1,12 @@
-import type { LabConfig } from "../../lab/types.js";
+import type { StudyConfig } from "../../study/types.js";
 import { type LocalTreeArchive } from "../../subject/local-tree-archive.js";
-import type { LabDeps } from "../../lab/lab-deps.js";
+import type { StudyDeps } from "../../study/study-deps.js";
 /**
  * Pack the working tree for a local-tree run and report what left the host on stderr, by counts
  * and digest only, never paths or file names.
  */
-export declare function packRunLocalTree(deps: LabDeps, config: {
-    readonly subject: Pick<LabConfig["subject"], "localTree">;
+export declare function packRunLocalTree(deps: StudyDeps, config: {
+    readonly subject: Pick<StudyConfig["subject"], "localTree">;
 }, cwd: string): Promise<{
     archive: LocalTreeArchive;
     buffer: ArrayBuffer;
@@ -14,7 +14,7 @@ export declare function packRunLocalTree(deps: LabDeps, config: {
 /**
  * Default local-tree packing implementation: createLocalTreeArchive(root, opts) on the host,
  * then a single read of the produced archive file into an ArrayBuffer for upload. The DI seam
- * (LabDeps.packLocalTree) overrides this in deterministic tests so they never require
+ * (StudyDeps.packLocalTree) overrides this in deterministic tests so they never require
  * tar/git.
  */
 export declare function defaultPackLocalTree(args: {

package/dist/routes/computer-use/local-tree-pack.js

@@ -24,7 +24,7 @@ export async function packRunLocalTree(deps, config, cwd) {
 /**
  * Default local-tree packing implementation: createLocalTreeArchive(root, opts) on the host,
  * then a single read of the produced archive file into an ArrayBuffer for upload. The DI seam
- * (LabDeps.packLocalTree) overrides this in deterministic tests so they never require
+ * (StudyDeps.packLocalTree) overrides this in deterministic tests so they never require
  * tar/git.
  */
 export async function defaultPackLocalTree(args) {

package/dist/routes/computer-use/local-vm.d.ts

@@ -1,23 +1,23 @@
-import type { InternalRunLabOptions } from "../../run-lab.js";
-import type { LabConfig } from "../../lab/types.js";
+import type { InternalRunStudyOptions } from "../../run-study.js";
+import type { StudyConfig } from "../../study/types.js";
 import type { LocalVmInput } from "./types.js";
 import { type LocalFirecrackerAssets } from "../../substrates/local/firecracker-desktop.js";
-type LocalVmRunOptions = InternalRunLabOptions & {
-    config: LabConfig;
+type LocalVmRunOptions = InternalRunStudyOptions & {
+    config: StudyConfig;
     assets?: LocalFirecrackerAssets;
     signal?: AbortSignal;
 };
 /** A local browser study's bindings, and the cleanup of what its participants started. */
 export interface LocalVmRun {
-    /** The caller's runLab options, with the account provider when the study runs one. */
-    readonly options: InternalRunLabOptions;
+    /** The caller's runStudyWith options, with the account provider when the study runs one. */
+    readonly options: InternalRunStudyOptions;
     /** The desktop, the analysis gate and the abort signal the computer-use run takes. */
     readonly localVm: LocalVmInput;
     close(): Promise<void>;
 }
 /**
- * Local desktop/provider composition: the options the lab is planned and run with. It throws before
- * anything starts on a lab the local study cannot run.
+ * Local desktop/provider composition: the options the study is planned and run with. It throws before
+ * anything starts on a study the local VM cannot run.
  */
 export declare function prepareLocalVmRun(options: LocalVmRunOptions): LocalVmRun;
 export {};

package/dist/routes/computer-use/local-vm.js

@@ -26,7 +26,7 @@ function guestAssets(options, account, needsMedia) {
         if (account) {
             const readiness = await checkRestrictedCodexAnalysisReadiness({ timeoutMs: 5000 });
             if (!readiness.ready)
-                throw new Error(`Codex account is not ready (${readiness.errorCode}). Run humanish doctor --lab <lab> before starting a local study.`);
+                throw new Error(`Codex account is not ready (${readiness.errorCode}). Run humanish doctor --study <study> before starting a local study.`);
         }
         return (options.assets ??
             (await prepareLocalRuntime({
@@ -152,8 +152,8 @@ function accountProvider(state) {
     };
 }
 /**
- * Local desktop/provider composition: the options the lab is planned and run with. It throws before
- * anything starts on a lab the local study cannot run.
+ * Local desktop/provider composition: the options the study is planned and run with. It throws before
+ * anything starts on a study the local VM cannot run.
  */
 export function prepareLocalVmRun(options) {
     const config = localBrowserDefaults(options.config);

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

@@ -1,6 +1,6 @@
 import type { CuaExecutor } from "../../actors/computer-use/loop.js";
 import type { DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
-import type { LabCommsEmail, LabCommsRecipient } from "../../lab/types.js";
+import type { StudyCommsEmail, StudyCommsRecipient } from "../../study/types.js";
 import type { PreparedOutputRoot } from "../../run/contained-output.js";
 /** A prepared desktop supplies only participant input/observation and its inbox location. */
 export interface ReadyParticipantDesktop {
@@ -38,11 +38,11 @@ export interface ParticipantDesktop {
 }
 /** Builds one participant's desktop. The factory must not acquire anything; prepare does. */
 export type ParticipantDesktopFactory = (run: DesktopParticipantRun, warnings: string[], artifactRoot: PreparedOutputRoot) => ParticipantDesktop;
-/** The participant's addressed comms recipient, when one exists — the gate AND the address source for the
- *  inbox instruction (#351). A participant told to check an inbox it can never receive into would stall,
+/** The participant's addressed comms recipient, when one exists: the gate and the address source for the
+ *  inbox instruction. A participant told to check an inbox it can never receive into would stall,
  *  so no addressed recipient means no instruction. */
-export declare function inboxRecipientFor(commsEmail: LabCommsEmail, participantId: string): LabCommsRecipient | undefined;
-/** True when a participant has a declared comms recipient WITH an address, so the drain can actually match the
+export declare function inboxRecipientFor(commsEmail: StudyCommsEmail, participantId: string): StudyCommsRecipient | undefined;
+/** True when a participant has a declared comms recipient with an address, so the drain can actually match the
  *  mail the persona will be told to read. Gates the inbox instruction to participants that can receive
- *  mail — a participant told to check an inbox it can never receive into would just stall. */
-export declare function participantHasInboxRecipient(commsEmail: LabCommsEmail, participantId: string): boolean;
+ *  mail; a participant told to check an inbox it can never receive into would just stall. */
+export declare function participantHasInboxRecipient(commsEmail: StudyCommsEmail, participantId: string): boolean;

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

@@ -1,13 +1,13 @@
-import { recipientParticipantId } from "../../lab/parse/comms.js";
-/** The participant's addressed comms recipient, when one exists — the gate AND the address source for the
- *  inbox instruction (#351). A participant told to check an inbox it can never receive into would stall,
+import { recipientParticipantId } from "../../study/parse/comms.js";
+/** The participant's addressed comms recipient, when one exists: the gate and the address source for the
+ *  inbox instruction. A participant told to check an inbox it can never receive into would stall,
  *  so no addressed recipient means no instruction. */
 export function inboxRecipientFor(commsEmail, participantId) {
     return (commsEmail.recipients ?? []).find((recipient) => recipientParticipantId(recipient) === participantId && recipient.address !== undefined);
 }
-/** True when a participant has a declared comms recipient WITH an address, so the drain can actually match the
+/** True when a participant has a declared comms recipient with an address, so the drain can actually match the
  *  mail the persona will be told to read. Gates the inbox instruction to participants that can receive
- *  mail — a participant told to check an inbox it can never receive into would just stall. */
+ *  mail; a participant told to check an inbox it can never receive into would just stall. */
 export function participantHasInboxRecipient(commsEmail, participantId) {
     return inboxRecipientFor(commsEmail, participantId) !== undefined;
 }

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

@@ -11,12 +11,12 @@ export declare function makeParticipantWriteScreenshot(artifactRoot: PreparedOut
 export declare function runCuaParticipant(spec: DesktopParticipantRun, deps: CuaParticipantDeps): Promise<ParticipantRunOutcome>;
 /**
  * Run N>1 E2B participants with bounded concurrency, a pipeline gate (the first provisions
- * before the rest start), and session fail-fast on HARNESS errors only (queued participants
+ * before the rest start), and session fail-fast on harness errors only (queued participants
  * become `blocked` with a pinned reason + a fail-fast event; mission verdicts never trip it).
- * Each participant tears down ITS OWN sandbox by id; nothing here ever enumerates.
+ * Each participant tears down its own sandbox by id; nothing here ever enumerates.
  *
- * Exported for the #342 total-runner tests: the injectable runner lets a test make one participant
- * THROW (the exact class the guard exists for) without a live sandbox. Production always uses
+ * Exported for the total-runner tests: the injectable runner lets a test make one participant
+ * throw (the exact class the guard exists for) without a live sandbox. Production always uses
  * the default.
  */
 export declare function runCuaParticipants(runs: DesktopParticipantRun[], deps: Omit<CuaParticipantDeps, "signalProvisioned">, concurrency: number, runParticipant?: typeof runCuaParticipant): Promise<{