humanish 0.108.0 → 0.109.0

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

@@ -1,7 +1,7 @@
-// The computer-use lab backend: a subject (an app-url the caller provisioned, or a repo the
-// lab clones and serves in-sandbox) driven by a registry-resolved computer-use actor inside a
+// The computer-use route: a subject (an app-url the caller provisioned, or a repo the
+// humanish clones and serves in the sandbox) driven by a registry-resolved computer-use actor inside a
 // hosted E2B desktop. On this path `actors[].type` selects the actor: the
-// descriptor returned by the registry runs the session; the lab provisions the desktop and
+// descriptor returned by the registry runs the session; the route provisions the desktop and
 // subject, composes the prompt from config, persists the evidence bundle, and tears down.
 //
 // Substrate notes:
@@ -26,24 +26,24 @@ import path from "node:path";
 import { completeAutomaticAnalysis } from "../../analysis/automatic-completion.js";
 import { runScope } from "../../run/run.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
-import { browserRouteScorer } from "../../lab/adapter-scorer-loader.js";
-import { withLateScorer } from "../../lab/route-inputs.js";
-import { callerDrivingOf, planComputerUseLab } from "./plan.js";
+import { browserRouteScorer } from "../../study/adapter-scorer-loader.js";
+import { withLateScorer } from "../../study/route-inputs.js";
+import { callerDrivingOf, planComputerUseStudy } from "./plan.js";
 import { finishCuaRun } from "./result.js";
-import { runLabParticipants } from "./live-phase.js";
-import { admitCuaRun, refuseCuaLab, startCuaRun } from "./setup.js";
+import { runStudyParticipants } from "./live-phase.js";
+import { admitCuaRun, refuseCuaStudy, startCuaRun } from "./setup.js";
 import {} from "./types.js";
 import { studyResultIdentity } from "../../run/study-result.js";
 /**
- * Plans and runs a computer-use lab in one call. It is not exported from src/index.ts; tests call
- * it. It plans the config with planComputerUseLab and runs
+ * Plans and runs a computer-use study in one call. It is not exported from src/index.ts; tests call
+ * it. It plans the config with planComputerUseStudy and runs
  * the plan with runComputerUsePlan, whose run scope and withTransientCommsSecrets wrapper cover the
  * run and its analysis.
  */
-export async function runCuaActorLab(options) {
+export async function runCuaActorStudy(options) {
     const { config, dryRun, ...input } = options;
-    // planComputerUseLab makes every configuration refusal, in the order this route always has.
-    const planned = planComputerUseLab(config, {
+    // planComputerUseStudy makes every configuration refusal, in the order this route always has.
+    const planned = planComputerUseStudy(config, {
         dryRun,
         hasRunSession: input.deps?.runSession !== undefined,
         driving: callerDrivingOf(input),
@@ -52,14 +52,14 @@ export async function runCuaActorLab(options) {
     });
     if (planned.ok)
         return runComputerUsePlan(planned.plan, input, config);
-    return computerUseLabRefusal(options, planned.refusal);
+    return computerUseStudyRefusal(options, planned.refusal);
 }
 /**
- * A refused computer-use lab's result, at the refusal's stage: a before-scope refusal has its own
+ * A refused computer-use study's result, at the refusal's stage: a before-scope refusal has its own
  * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
  * the personas are read.
  */
-export async function computerUseLabRefusal(options, refusal) {
+export async function computerUseStudyRefusal(options, refusal) {
     const { config, dryRun } = options;
     if (refusal.stage === "before-scope")
         return {
@@ -76,10 +76,10 @@ export async function computerUseLabRefusal(options, refusal) {
         };
     // The other refusals come after the cwd checks, and the participant cap after the personas are read.
     const analysis = resolveAutomaticAnalysis(config.review?.analysis);
-    return completeAutomaticAnalysis(await refuseCuaLab(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
+    return completeAutomaticAnalysis(await refuseCuaStudy(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
 }
 /**
- * runLab's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
+ * runStudyWith's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
  * participants, the preflight plan, the keys, the local agent, subject env and caps, and the
  * local-tree archive) before any run scope opens, so the CLI can present their refusal before it
  * loads a declared scorer, and returns the run that continues from them with that scorer.
@@ -141,7 +141,7 @@ async function runPlanInScope(plan, input, admitted, scope) {
     const prepared = await startCuaRun(plan, input, admitted, scope);
     if (!prepared.ok)
         return prepared.result;
-    const ran = await runLabParticipants(prepared.setup, prepared.participants);
+    const ran = await runStudyParticipants(prepared.setup, prepared.participants);
     if (!ran.ok)
         return ran.result;
     return finishCuaRun(prepared.setup, prepared.finish, ran);

package/dist/routes/computer-use/self-report.js

@@ -125,7 +125,7 @@ function stripNegatedNonBlockerPhrases(text) {
         .replace(/\bno\s+(?:real\s+|remaining\s+|actual\s+)?(?:blocker|blockers|blocking issue|blocking issues|error|errors|failure|failures)\s+(?:was\s+|were\s+)?(?:encountered|observed|found|hit|seen|reported|detected)\b/g, "")
         .replace(/\bwithout\s+(?:a\s+|any\s+)?(?:real\s+|remaining\s+|actual\s+)?(?:blocker|blockers|blocking issue|blocking issues|error|errors|failure|failures)\b/g, "")
         .replace(/\bnot\s+(?:blocked|a blocker|an error|failed)\b/g, "")
-        // "No functional failures blocked me" downgraded a clean passing run to a lab failure on
+        // "No functional failures blocked me" downgraded a clean passing run to a run failure on
         // 2026-09-01. The adjective list above is closed (real|remaining|actual), so an ordinary
         // qualifier like "functional" slipped through and the trailing verb "blocked" tripped the
         // scan. Allow up to two intervening words, and cover the verb form directly.

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

@@ -1,26 +1,26 @@
 import { type RunScope } from "../../run/run.js";
 import type { CuaActorDescriptor } from "../../actors/registry.js";
-import type { LabCommsEmail, LabCommsExternal, LabConfig } from "../../lab/types.js";
+import type { StudyCommsEmail, StudyCommsExternal, StudyConfig } from "../../study/types.js";
 import { type RunRerunLineage } from "../../run/bundle.js";
 import { type LocalTreeArchive } from "../../subject/local-tree-archive.js";
 import { type ComputerUseRefusal } from "./plan.js";
-import type { ComputerUsePlan } from "../../lab/plan-types.js";
+import type { ComputerUsePlan } from "../../study/plan-types.js";
 import { trackRuntimeStreams, type LiveTraceFlush } from "./live-flush.js";
 import { type CuaRunBundleBase } from "./bundle.js";
 import { projectParticipantSubjects } from "./subject-projection.js";
-import { type CuaActorLabErrorCode, type CuaActorLabResult, type CuaParticipantDeps, type CuaParticipantPlan, type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ComputerUseRunInput, type RunCuaActorLabOptions } from "./types.js";
+import { type CuaActorStudyErrorCode, type CuaActorStudyResult, type CuaParticipantDeps, type CuaParticipantPlan, type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ComputerUseRunInput, type RunCuaActorStudyOptions } from "./types.js";
 /**
  * The envelope of a refusal the plan left for after the cwd checks. The participant cap and
  * in-process fan-out refusals come after the committed personas are read, so a persona-file error still wins.
  */
-export declare function refuseCuaLab(options: RunCuaActorLabOptions, refusal: ComputerUseRefusal): Promise<CuaActorLabResult>;
+export declare function refuseCuaStudy(options: RunCuaActorStudyOptions, refusal: ComputerUseRefusal): Promise<CuaActorStudyResult>;
 export type AdmittedCuaRun = Extract<Awaited<ReturnType<typeof admitCuaRun>>, {
     ok: true;
 }>["admitted"];
 type StartedRun = Extract<Awaited<ReturnType<RunScope["startRun"]>>, {
     ok: true;
 }>["run"];
-/** What runLabParticipants and finishCuaRun both read. */
+/** What runStudyParticipants and finishCuaRun both read. */
 export interface CuaRunSetup {
     plan: ComputerUsePlan;
     input: ComputerUseRunInput;
@@ -34,22 +34,22 @@ export interface CuaRunSetup {
     scrubKnownValues: (text: string) => string;
     bundleBase: CuaRunBundleBase;
 }
-/** What only runLabParticipants reads. */
+/** What only runStudyParticipants reads. */
 export interface CuaParticipantsSetup {
     env: Record<string, string | undefined>;
     /** The array scrubKnownValues reads at each call. Email receiving appends the values it
      *  provisions before the participants run. */
     knownSecretValues: string[];
     deps: Omit<CuaParticipantDeps, "signalProvisioned">;
-    /** Filled by runLabParticipants on a live run; deps.onTrace reads it. */
+    /** Filled by runStudyParticipants on a live run; deps.onTrace reads it. */
     liveTrace: {
         flush?: LiveTraceFlush["flush"];
         stop?: LiveTraceFlush["stop"];
     };
     /** The operator-hosted inbox on the app-url route, when declared. */
     externalComms: {
-        config: LabCommsExternal;
-        email: LabCommsEmail;
+        config: StudyCommsExternal;
+        email: StudyCommsEmail;
     } | undefined;
     /** The subjects of the in-progress bundle, written before any participant starts. */
     inProgress: {
@@ -58,7 +58,7 @@ export interface CuaParticipantsSetup {
         provenance: CuaSubjectProvenanceArg | undefined;
     };
     /** The refusal envelope, for a run that stops before its bundle. */
-    fail: (code: CuaActorLabErrorCode, message: string, actorLabel?: string) => CuaActorLabResult;
+    fail: (code: CuaActorStudyErrorCode, message: string, actorLabel?: string) => CuaActorStudyResult;
 }
 /** What only finishCuaRun reads besides the participants' outcomes. */
 export interface CuaFinishFacts {
@@ -68,7 +68,7 @@ export interface CuaFinishFacts {
 }
 type PreparedCuaRun = {
     ok: false;
-    result: CuaActorLabResult;
+    result: CuaActorStudyResult;
 } | {
     ok: true;
     setup: CuaRunSetup;
@@ -78,21 +78,21 @@ type PreparedCuaRun = {
 /**
  * Everything before the run starts: the physical project, the route, the participant plan and
  * preflight, the key and subject-env scrubber, the live checks that need no sandbox, and the
- * local-tree archive. These read files, env and the network, which planLab does not. Returns the
+ * local-tree archive. These read files, env and the network, which planStudy does not. Returns the
  * refusal, or what startCuaRun reads.
  */
-export declare function admitCuaRun(plan: ComputerUsePlan, input: ComputerUseRunInput, config: LabConfig): Promise<{
+export declare function admitCuaRun(plan: ComputerUsePlan, input: ComputerUseRunInput, config: StudyConfig): Promise<{
     ok: false;
-    result: CuaActorLabResult;
+    result: CuaActorStudyResult;
 } | {
     ok: true;
     admitted: {
-        config: LabConfig;
+        config: StudyConfig;
         dryRun: boolean;
         cwd: string;
-        seams: import("../../lab/lab-deps.js").LabDeps;
+        seams: import("../../study/study-deps.js").StudyDeps;
         streams: {
-            onStream: NonNullable<import("../../lab/run-lab-homes.js").RunLabHomes["onStream"]>;
+            onStream: NonNullable<import("../../study/run-study-homes.js").RunStudyHomes["onStream"]>;
             showIn: (observer: import("../../index.js").ObserverResult & {
                 ok: true;
             }) => void;
@@ -100,15 +100,15 @@ export declare function admitCuaRun(plan: ComputerUsePlan, input: ComputerUseRun
         };
         env: Record<string, string | undefined>;
         appUrl: string;
-        fail: (code: CuaActorLabErrorCode, message: string, actorLabel?: string) => CuaActorLabResult;
-        refuse: (code: CuaActorLabErrorCode, message: string, actorLabel?: string | undefined) => {
+        fail: (code: CuaActorStudyErrorCode, message: string, actorLabel?: string) => CuaActorStudyResult;
+        refuse: (code: CuaActorStudyErrorCode, message: string, actorLabel?: string | undefined) => {
             ok: false;
-            result: CuaActorLabResult;
+            result: CuaActorStudyResult;
         };
         descriptor: CuaActorDescriptor;
         runSession: (options: import("../../actors/computer-use/actor.js").CuaActorSessionOptions) => Promise<import("../../index.js").ComputerUseLoopResult>;
-        externalCommsConfig: LabCommsExternal | undefined;
-        externalCommsEmail: LabCommsEmail | undefined;
+        externalCommsConfig: StudyCommsExternal | undefined;
+        externalCommsEmail: StudyCommsEmail | undefined;
         participantRuns: DesktopParticipantRun[];
         participantPlan: CuaParticipantPlan;
         rerunLineage: RunRerunLineage | undefined;

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

@@ -17,13 +17,13 @@ import { e2bRequestTimeoutMs } from "../../substrates/e2b/lifetime.js";
 import { liveCuaRejection } from "./preflight.js";
 import { cuaDescriptorOf, declaredAppUrl, plannedAppUrl } from "./plan.js";
 import { trackRuntimeStreams } from "./live-flush.js";
-import { phaseEvent, planEvent } from "../../lab/run-lab-events.js";
+import { phaseEvent, planEvent } from "../../study/run-study-events.js";
 import { defaultSubjectPhaseSink } from "../../subject/steps.js";
 import {} from "./bundle.js";
 import { packRunLocalTree } from "./local-tree-pack.js";
 import { projectParticipantSubjects, subjectProvenanceArg } from "./subject-projection.js";
 import { participantSubjectEnv, } from "./types.js";
-import { labPersonaIds } from "../../lab/persona-resolve.js";
+import { studyPersonaIds } from "../../study/persona-resolve.js";
 import { studyResultIdentity } from "../../run/study-result.js";
 /** The physical project, bound before any caller hook runs. */
 async function bindProject(cwd) {
@@ -37,12 +37,12 @@ async function bindProject(cwd) {
  * The envelope of a refusal the plan left for after the cwd checks. The participant cap and
  * in-process fan-out refusals come after the committed personas are read, so a persona-file error still wins.
  */
-export async function refuseCuaLab(options, refusal) {
+export async function refuseCuaStudy(options, refusal) {
     const { config, dryRun } = options;
     const projectRoot = await bindProject(options.cwd);
     // The committed personas are read before the refusal returns, so a persona-file error wins.
     if (refusal.stage === "after-personas")
-        await compileParticipantPersonas(projectRoot, labPersonaIds(config));
+        await compileParticipantPersonas(projectRoot, studyPersonaIds(config));
     return {
         ...studyResultIdentity("computer-use", config.id),
         ok: false,
@@ -59,7 +59,7 @@ export async function refuseCuaLab(options, refusal) {
 /**
  * Everything before the run starts: the physical project, the route, the participant plan and
  * preflight, the key and subject-env scrubber, the live checks that need no sandbox, and the
- * local-tree archive. These read files, env and the network, which planLab does not. Returns the
+ * local-tree archive. These read files, env and the network, which planStudy does not. Returns the
  * refusal, or what startCuaRun reads.
  */
 export async function admitCuaRun(plan, input, config) {
@@ -74,7 +74,7 @@ export async function admitCuaRun(plan, input, config) {
     const appUrl = plannedAppUrl(subject);
     const subjectEnvNames = [...participantSubjectEnv(subject)];
     const fail = (code, message, actorLabel) => ({
-        ...studyResultIdentity("computer-use", plan.labId),
+        ...studyResultIdentity("computer-use", plan.studyId),
         ok: false,
         cwd,
         actor: actorLabel ?? plan.actor,
@@ -89,13 +89,13 @@ export async function admitCuaRun(plan, input, config) {
         ok: false,
         result: fail(...args),
     });
-    // runLab's local VM study supplies a local-target app-url lab's desktop; a direct route call or
-    // an in-process executor on the same lab has none. It reads the declared source, as the planner
+    // runStudyWith's local VM study supplies a local-target app-url study's desktop; a direct route call or
+    // an in-process executor on the same study has none. It reads the declared source, as the planner
     // did: a library config the parser never saw can plan to an app-url subject from another source.
     if (config.subject.source === "app-url" &&
         config.execution?.target === "local" &&
         input.localVm === undefined)
-        return refuse("HUMANISH_COMPUTER_USE_LOCAL_DESKTOP_MISSING", "An app-url lab with execution.target: local needs a local desktop. runLab starts one; a direct route call or an in-process executor does not.");
+        return refuse("HUMANISH_COMPUTER_USE_LOCAL_DESKTOP_MISSING", "An app-url study with execution.target: local needs a local desktop. runStudy starts one; a direct route call or an in-process executor does not.");
     const descriptor = cuaDescriptorOf(plan.actor);
     const baseRunSession = seams.runSession ?? descriptor.runSession;
     // A local VM study's sessions abort on its signal.
@@ -123,7 +123,7 @@ export async function admitCuaRun(plan, input, config) {
     // every N; the stderr table prints for fan-out (N>1) so single-participant runs stay as quiet as they
     // always were.
     if (participantCount > 1) {
-        emitPreflightPlan(participantPlan, plan.labId);
+        emitPreflightPlan(participantPlan, plan.studyId);
     }
     input.emit?.(planEvent(participantPlan));
     await assertPreparedSelectedOutputDirectory(projectRoot);
@@ -205,14 +205,14 @@ export async function startCuaRun(plan, input, admitted, scope) {
     const { dryRun, cwd, seams, descriptor, participantRuns, participantPlan, publicRepo } = admitted;
     const { appUrl } = admitted;
     // The run's status record exists from here on, so anything watching the runs directory can
-    // tell which lab this is and that it is alive. The fail-closed returns below leave it finished
+    // tell which study this is and that it is alive. The fail-closed returns below leave it finished
     // with no outcome when the scope closes; a crash leaves it stale, which reads as interrupted.
     const started = await scope.startRun({
         cwd,
         runId: input.runId,
         mintRunId: makeCuaRunId,
         mode: dryRun ? "dry-run" : "live",
-        lab: plan.lab,
+        study: plan.study,
         renderReview: renderCuaReviewMarkdown,
         observer: { open: input.open === true, render: seams.renderObserver },
     });
@@ -228,7 +228,7 @@ export async function startCuaRun(plan, input, admitted, scope) {
         humanishSource: "present",
         packageName: "humanish",
     });
-    // Live-trace flush seam: runLabParticipants fills it when a live run has an in-progress bundle
+    // Live-trace flush seam: runStudyParticipants fills it when a live run has an in-progress bundle
     // to grow; participants call it through deps.onTrace. It exists before deps so deps can reference it as
     // a stable indirection.
     const liveTrace = {};
@@ -315,7 +315,7 @@ function cuaParticipantDeps(plan, input, admitted, run) {
         onTrace: (participantId, items, usage, metadata) => liveTrace.flush?.(participantId, items, usage, metadata),
         ...callerDriving(input, config),
         residual: plan.residual,
-        labId: plan.labId,
+        studyId: plan.studyId,
         caps: plan.caps,
         appUrl,
         brain: plan.runner.brain,
@@ -329,7 +329,7 @@ function cuaParticipantDeps(plan, input, admitted, run) {
         timeoutMs,
         participantCount,
         artifactRoot: runPaths,
-        labCwd: input.cwd,
+        studyCwd: input.cwd,
         redactScreenshots,
         scrubKnownValues,
         runSession,

package/dist/routes/computer-use/single-bundle.d.ts

@@ -16,7 +16,7 @@ export declare function buildSingleParticipantBundle(args: {
     /** The run's verdict, from the judge. */
     verdict: Verdict;
     realEmail?: boolean;
-    /** The run this bundle belongs to; the bundle head reads its id, mode, start and lab. */
+    /** The run this bundle belongs to; the bundle head reads its id, mode, start and study. */
     run: BundleRun;
     actorId: string;
     appUrl: string;
@@ -26,8 +26,8 @@ export declare function buildSingleParticipantBundle(args: {
     surface?: string;
     caseGroup?: string;
     dryRun: boolean;
-    labId: string;
-    labTitle?: string;
+    studyId: string;
+    studyTitle?: string;
     mission: string;
     assignment?: RunStream["assignment"];
     persona: ActorPersonaRef;
@@ -44,7 +44,7 @@ export declare function buildSingleParticipantBundle(args: {
     isMobile?: boolean;
     screenshots: string[];
     /** Relative run-dir path of the digest-only comms-thread evidence artifact (humanish.comms-thread.v1),
-     *  when a comms lab captured mail; registered as a "log" stream artifact. */
+     *  when a comms study captured mail; registered as a "log" stream artifact. */
     commsArtifactPath?: string;
     /**
      * Capture-time screenshot policy ("blurred" when policies.redactScreenshots, else "raw").

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

@@ -1,4 +1,4 @@
-import { participantAssignment } from "../../lab/participant-assignment.js";
+import { participantAssignment } from "../../study/participant-assignment.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import {} from "../../run/streams.js";
@@ -7,6 +7,7 @@ import { describeSubjectState, participantFeedbackCandidates, phaseEventIdSuffix
 import { participantStatus as participantStatusFor } from "../../run/judge.js";
 import { buildRunCostSummary } from "../../run/cost-summary.js";
 import { participantEvent, participantIds, participantRecord, participantStream, } from "../../run/participant-records.js";
+import { plural } from "../../run/text.js";
 /** The one participant's record and stream ids: sim-001 and stream-001. */
 const SINGLE = participantIds(0);
 /** The participant's runner: a hosted E2B desktop, a local VM desktop, or the in-process route. */
@@ -80,7 +81,7 @@ function singleSimulation(args, view) {
     const { publicAppUrl, status, reason } = view;
     return participantRecord(SINGLE, 1, {
         personaId: args.persona.id,
-        scenarioId: `cua-${args.labId}`,
+        scenarioId: `cua-${args.studyId}`,
         status,
         streamKind: "browser",
         mode: "browser-sim",
@@ -91,7 +92,7 @@ function singleSimulation(args, view) {
             : args.inProgress === true
                 ? `Computer-use actor (${args.actorId}) is driving the subject app ${browserPlace(args)}.`
                 : args.sessionError !== undefined
-                    ? `Computer-use lab failed before a terminal session verdict: ${args.sessionError}`
+                    ? `The computer-use run failed before a terminal session verdict: ${args.sessionError}`
                     : `Computer-use actor (${args.actorId}) against ${publicAppUrl}; no session ran.`,
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
@@ -133,7 +134,7 @@ function singleStream(args, view) {
             ...(args.session ? { actorStatus: args.session.status } : {}),
             ...(lastScreenshot ? { screenshotUrl: lastScreenshot } : {}),
         },
-        // The seam this lab exists to fill: the provider-neutral actor evidence projection.
+        // The seam this route exists to fill: the provider-neutral actor evidence projection.
         ...(args.session ? { actor: args.session.trace } : {}),
         artifacts: [
             { label: "run bundle", path: "run.json", kind: "bundle" },
@@ -164,7 +165,7 @@ function singleEvents(args, view) {
             at: args.run.createdAt,
             level: "info",
             type: "cua-lab.run.created",
-            message: `Created computer-use lab run for ${args.labId} (actor ${args.actorId}).`,
+            message: `Created a computer-use run for ${args.studyId} (actor ${args.actorId}).`,
         },
         args.subjectProvenance
             ? participantEvent(SINGLE, {
@@ -312,21 +313,21 @@ export function buildSingleParticipantBundle(args) {
         persona: {
             id: args.persona.id,
             name: `Computer-use operator (${args.persona.id})`,
-            source: `study:${args.labId}`,
+            source: `study:${args.studyId}`,
             sourceDigest: args.persona.promptDigest,
         },
         scenario: {
-            id: `cua-${args.labId}`,
-            title: args.labTitle ?? `Computer-use lab: ${args.labId}`,
+            id: `cua-${args.studyId}`,
+            title: args.studyTitle ?? `Computer-use run: ${args.studyId}`,
             goal: redactText(args.mission),
-            source: `study:${args.labId}`,
+            source: `study:${args.studyId}`,
             sourceDigest: args.persona.promptDigest,
         },
         lifecycle: [
             {
                 at: args.run.createdAt,
                 event: "cua-lab.run.created",
-                message: `Created computer-use lab run with one participant in a desktop browser (actor ${args.actorId}).`,
+                message: `Created a computer-use run with one participant in a desktop browser (actor ${args.actorId}).`,
             },
         ],
         simulations: [simulation],
@@ -339,7 +340,7 @@ export function buildSingleParticipantBundle(args) {
                 : traceScreenshotMode === "blurred"
                     ? "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."
                     : args.screenshots.length > 0
-                        ? `Session ended before a trace was recorded; ${args.screenshots.length} already-written frame(s) follow the capture policy (${screenshotMode}). Typed text is recorded as length only and reasoning/messages pass through text redaction.`
+                        ? `Session ended before a trace was recorded; ${plural(args.screenshots.length, "already-written frame")} ${args.screenshots.length === 1 ? "follows" : "follow"} the capture policy (${screenshotMode}). Typed text is recorded as length only and reasoning/messages pass through text redaction.`
                         : "No screenshots captured. Typed text is recorded as length only and reasoning/messages pass through text redaction whenever a session runs.",
         },
         artifacts: bundleArtifacts(),
@@ -350,8 +351,8 @@ export function buildSingleParticipantBundle(args) {
             ? []
             : participantFeedbackCandidates({
                 runId: args.run.runId,
-                scenarioId: `cua-${args.labId}`,
-                adapterId: args.labId,
+                scenarioId: `cua-${args.studyId}`,
+                adapterId: args.studyId,
                 goal: redactText(args.mission),
                 substrate: runnerSubstrate(args),
                 participants: [

package/dist/routes/computer-use/subject-projection.d.ts

@@ -1,5 +1,5 @@
-import type { ComputerUsePlan } from "../../lab/plan-types.js";
-import type { LabSubjectState } from "../../lab/types.js";
+import type { ComputerUsePlan } from "../../study/plan-types.js";
+import type { StudySubjectState } from "../../study/types.js";
 import { type RunSubjectProvenance, type RunSubjectStateStepRecord } from "../../run/bundle.js";
 import { type LocalTreeArchive } from "../../subject/local-tree-archive.js";
 import { type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ParticipantRunOutcome } from "./types.js";
@@ -24,7 +24,7 @@ export declare function projectParticipantSubjects(args: {
  * contract bundles and failed live provisioning); no declaration → "undeclared".
  */
 export declare function resolveSubjectState(args: {
-    declared: LabSubjectState | undefined;
+    declared: StudySubjectState | undefined;
     dryRun: boolean;
     executed: RunSubjectStateStepRecord[];
 }): RunSubjectProvenance["state"];