humanish 0.107.0 → 0.109.0

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

@@ -5,16 +5,16 @@ import { type CuaSubjectProvenanceArg, type ParticipantRunOutcome } from "./type
 /** The human-readable state story appended to the provenance event (and review.md via it). */
 export declare function describeSubjectState(state: RunSubjectProvenance["state"], dryRun: boolean): string;
 /**
- * Feedback candidates derived from what LIVE participants actually reported (#392).
+ * Feedback candidates derived from what live participants actually reported.
  *
- * A live run's feedback draft used to fall through to a dry-run template, because no browser route
- * ever built a candidate. The candidate worth filing is the one the study produced: a participant
+ * A live run's feedback draft comes from these candidates, never from a dry-run template. The
+ * candidate worth filing is the one the study produced: a participant
  * who reported friction on the way (the most valuable thing a run captures), or one who stopped
- * trying. A clean pass files nothing here — feedback exists to carry findings, and a run without
- * any falls back to an honest live summary in the draft layer instead of a template.
+ * trying. A clean pass files nothing here: feedback exists to carry findings, and a run without
+ * any falls back to a live summary in the draft layer instead of a template.
  *
- * Everything quoted is already scrub+redacted — participant messages and `session.reason` pass
- * through redactNarration in the loop — and passes redactText again here as defense-in-depth.
+ * Everything quoted is already scrub+redacted (participant messages and `session.reason` pass
+ * through redactNarration in the loop) and passes redactText again here as defense-in-depth.
  */
 export declare function participantFeedbackCandidates(args: {
     runId: string;
@@ -34,8 +34,8 @@ export declare function participantFeedbackCandidates(args: {
         commsArtifactPath?: string;
     }>;
 }): RunFeedbackCandidate[];
-/** Human-readable provenance line for the single-participant subject.provenance event (invariant 5):
- *  claims "cloned/packed and served" ONLY when it actually happened. */
+/** Human-readable provenance line for the single-participant subject.provenance event:
+ *  claims "cloned/packed and served" only when it actually happened. */
 export declare function subjectProvenanceMessage(provenance: CuaSubjectProvenanceArg, publicAppUrl: string, dryRun: boolean, hasSession: boolean): string;
 export declare function providerResourcesForOutcome(args: {
     outcome: ParticipantRunOutcome | undefined;

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

@@ -8,15 +8,16 @@ import {} from "../../run/bundle.js";
 import { participantResourceIds } from "../../run/participant-records.js";
 import { resolveSelfReportedFriction } from "./self-report.js";
 import {} from "./types.js";
+import { plural } from "../../run/text.js";
 /** The human-readable state story appended to the provenance event (and review.md via it). */
 export function describeSubjectState(state, dryRun) {
     switch (state.provenance) {
         case "seeded":
-            return `seeded (${state.seed?.length ?? 0} step(s): ${(state.seed ?? []).map((record) => record.name).join(", ")})`;
+            return `seeded (${plural(state.seed?.length ?? 0, "step")}: ${(state.seed ?? []).map((record) => record.name).join(", ")})`;
         case "unpinned":
-            return `UNPINNED (external: ${(state.externalEnvNames ?? []).join(", ")})`;
+            return `unpinned (external: ${(state.externalEnvNames ?? []).join(", ")})`;
         case "declared-not-run":
-            return `declared, not run (${dryRun ? "dry-run contract" : "provisioning did not complete"})`;
+            return `declared, not run (${dryRun ? "dry run" : "provisioning did not complete"})`;
         case "undeclared":
             return "undeclared";
         case "external-public":
@@ -24,16 +25,16 @@ export function describeSubjectState(state, dryRun) {
     }
 }
 /**
- * Feedback candidates derived from what LIVE participants actually reported (#392).
+ * Feedback candidates derived from what live participants actually reported.
  *
- * A live run's feedback draft used to fall through to a dry-run template, because no browser route
- * ever built a candidate. The candidate worth filing is the one the study produced: a participant
+ * A live run's feedback draft comes from these candidates, never from a dry-run template. The
+ * candidate worth filing is the one the study produced: a participant
  * who reported friction on the way (the most valuable thing a run captures), or one who stopped
- * trying. A clean pass files nothing here — feedback exists to carry findings, and a run without
- * any falls back to an honest live summary in the draft layer instead of a template.
+ * trying. A clean pass files nothing here: feedback exists to carry findings, and a run without
+ * any falls back to a live summary in the draft layer instead of a template.
  *
- * Everything quoted is already scrub+redacted — participant messages and `session.reason` pass
- * through redactNarration in the loop — and passes redactText again here as defense-in-depth.
+ * Everything quoted is already scrub+redacted (participant messages and `session.reason` pass
+ * through redactNarration in the loop) and passes redactText again here as defense-in-depth.
  */
 export function participantFeedbackCandidates(args) {
     const candidates = [];
@@ -59,8 +60,8 @@ export function participantFeedbackCandidates(args) {
             persona_id: participant.personaId,
             actor: "computer-use",
             substrate: args.substrate,
-            // The participant is reporting on the PRODUCT: friction and abandonment are target-app
-            // findings by the three-roles rule. A harness failure never reaches this builder — it is
+            // The participant is reporting on the product: friction and abandonment are target-app
+            // findings by the three-roles rule. A harness failure never reaches this builder; it is
             // not a participant report.
             failure_owner: "target-app",
             summary,
@@ -103,18 +104,18 @@ export function participantFeedbackCandidates(args) {
             proposed_next_state: "study-quality-review",
             acceptance_proof: [
                 feedbackProofCommands(args.runId).verify,
-                feedbackProofCommands(args.runId).watch,
+                feedbackProofCommands(args.runId).observe,
             ],
         });
     }
     return candidates;
 }
-/** Human-readable provenance line for the single-participant subject.provenance event (invariant 5):
- *  claims "cloned/packed and served" ONLY when it actually happened. */
+/** Human-readable provenance line for the single-participant subject.provenance event:
+ *  claims "cloned/packed and served" only when it actually happened. */
 export function subjectProvenanceMessage(provenance, publicAppUrl, dryRun, hasSession) {
     if (provenance.source === "clone") {
         if (dryRun) {
-            return `Subject declared: clone of ${provenance.repo}, to be served at ${publicAppUrl} in-sandbox (dry-run contract; nothing cloned)`;
+            return `Subject declared: clone of ${provenance.repo}, to be served at ${publicAppUrl} in-sandbox (dry run; nothing cloned)`;
         }
         if (provenance.commit) {
             return hasSession
@@ -124,7 +125,7 @@ export function subjectProvenanceMessage(provenance, publicAppUrl, dryRun, hasSe
         return `Subject clone attempted from ${provenance.repo}; commit unresolved (provisioning failed before resolution)`;
     }
     if (dryRun) {
-        return `Subject declared: local working tree, to be packed and served at ${publicAppUrl} in-sandbox (dry-run contract; nothing packed)`;
+        return `Subject declared: local working tree, to be packed and served at ${publicAppUrl} in-sandbox (dry run; nothing packed)`;
     }
     if (provenance.archiveSha256) {
         const dirtyLabel = provenance.dirty === true

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

@@ -1,5 +1,5 @@
 import type { CuaActorDescriptor } from "../../actors/registry.js";
-import type { ComputerUsePlan } from "../../lab/plan-types.js";
+import type { ComputerUsePlan } from "../../study/plan-types.js";
 import type { BundleRun, RunBundle, RunRerunLineage } from "../../run/bundle.js";
 import { type Judgment } from "../../run/judge.js";
 import type { CuaParticipantPlan, DesktopParticipantRun, CuaSubjectProjection, CuaSubjectProvenanceArg, ParticipantRunOutcome } from "./types.js";
@@ -20,7 +20,7 @@ export interface CuaRunBundleBase {
 /**
  * The judgment for the current state of a computer-use run, by the rule for its shape: one
  * participant (its tallied status is the verdict) or several (every participant must pass). The bundle's
- * verdict and the lab result's ok both come from it.
+ * verdict and the study result's ok both come from it.
  */
 export declare function judgeComputerUseRun(base: Pick<CuaRunBundleBase, "participantRuns" | "rerun">, state: {
     dryRun: boolean;

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

@@ -2,13 +2,14 @@
 // and buildCuaRunBundle sends it to the single-participant or the fan-out builder with that
 // shape's arguments. renderCuaReviewMarkdown writes review.md. shared-world/bundle.ts holds the
 // same for that route.
-import { judgeOneParticipant, judgeParticipants } from "../../run/judge.js";
+import { judgeOneParticipant, judgeParticipants, verdictText, } from "../../run/judge.js";
 import { desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { e2bDesktopTemplate } from "../../substrates/e2b/sandbox.js";
 import { providerResourcesForOutcome } from "./bundle-parts.js";
 import { participantFactsOf } from "./participant-facts.js";
 import { buildCuaFanoutBundle } from "./fanout-bundle.js";
 import { buildSingleParticipantBundle } from "./single-bundle.js";
+import { plural } from "../../run/text.js";
 /** One participant without a rerun keeps the single-participant bundle shape and its rule. */
 function isOneParticipantRun(base) {
     return base.participantRuns.length === 1 && base.rerun === undefined;
@@ -16,7 +17,7 @@ function isOneParticipantRun(base) {
 /**
  * The judgment for the current state of a computer-use run, by the rule for its shape: one
  * participant (its tallied status is the verdict) or several (every participant must pass). The bundle's
- * verdict and the lab result's ok both come from it.
+ * verdict and the study result's ok both come from it.
  */
 export function judgeComputerUseRun(base, state) {
     const inProgress = state.inProgress === true;
@@ -84,8 +85,8 @@ function singleParticipantArgs(base, state) {
             ? {}
             : { caseGroup: spec.planned.labels.caseGroup }),
         dryRun: state.dryRun,
-        labId: plan.labId,
-        ...(plan.title ? { labTitle: plan.title } : {}),
+        studyId: plan.studyId,
+        ...(plan.title ? { studyTitle: plan.title } : {}),
         mission: spec.evidenceInstructions ?? spec.instructions,
         ...(spec.evidenceAssignment === undefined ? {} : { assignment: spec.evidenceAssignment }),
         persona: spec.persona,
@@ -157,17 +158,17 @@ export function renderCuaReviewMarkdown(bundle) {
         "",
         `- run: ${bundle.runId}`,
         `- mode: ${bundle.mode}`,
-        `- run gate: ${bundle.review.verdict}`,
+        `- run gate: ${verdictText(bundle.review.verdict, bundle.mode)}`,
         `- summary: ${bundle.review.summary}`,
         ...(provenance ? [`- subject: ${provenance.message}`] : []),
         ...(trace
             ? [
                 `- actor: ${trace.provider} (${trace.lane}/${trace.protocol})`,
-                // Honest count: name the trace's actual screenshot mode ("raw" | "blurred"); say
+                // Name the trace's actual screenshot mode ("raw" | "blurred"); say
                 // nothing when no frames exist ("n/a") rather than claim a redaction that never ran.
-                `- evidence: ${trace.items.length} trace item(s), ${trace.counts.screenshots ?? 0} ${trace.redaction.screenshots === "raw" || trace.redaction.screenshots === "blurred"
-                    ? `${trace.redaction.screenshots} screenshot(s)`
-                    : "screenshot(s)"}`,
+                `- evidence: ${plural(trace.items.length, "trace item")}, ${plural(trace.counts.screenshots ?? 0, trace.redaction.screenshots === "raw" || trace.redaction.screenshots === "blurred"
+                    ? `${trace.redaction.screenshots} screenshot`
+                    : "screenshot")}`,
             ]
             : []),
         ...(bundle.review.gaps.length > 0

package/dist/routes/computer-use/e2b-desktop/comms.d.ts

@@ -1,12 +1,12 @@
 import { type OriginMap } from "../../../comms/capture-surface.js";
 import { type DeployedCommsCatch } from "../../../comms/sandbox-catch.js";
-import type { LabCommsEmail, LabConfig } from "../../../lab/types.js";
+import type { StudyCommsEmail, StudyConfig } from "../../../study/types.js";
 import type { Shell } from "../../../substrates/shell.js";
 import type { ReadyParticipantDesktop } from "../participant-desktop.js";
 import { type E2BDesktopDeps, type DesktopParticipantRun } from "../types.js";
 /** A participant's captured-email wiring, decided from config before the sandbox exists. */
 export interface ParticipantComms {
-    readonly email: LabCommsEmail;
+    readonly email: StudyCommsEmail;
     readonly port: number;
     readonly smtpPort: number | undefined;
     /** The loopback URL the persona opens to read captured mail. */
@@ -19,10 +19,10 @@ export interface ParticipantComms {
 }
 /**
  * On an in-sandbox subject route, redirect the app's email-API sends into an in-sandbox catch
- * (loopback) so its verification mail is CAPTURED, not sent to the internet. Undefined when the
- * lab declares no fake email, which leaves the participant unchanged.
+ * (loopback) so its verification mail is captured instead of sent to the internet. Undefined when the
+ * study declares no fake email, which leaves the participant unchanged.
  */
-export declare function planParticipantComms(comms: LabConfig["comms"], serveUrl: string | undefined, targetUrl: string, inSandboxSubject: boolean): ParticipantComms | undefined;
+export declare function planParticipantComms(comms: StudyConfig["comms"], serveUrl: string | undefined, targetUrl: string, inSandboxSubject: boolean): ParticipantComms | undefined;
 /** The env the subject app reads to reach the catch, injected at sandbox create so it boots with it. */
 export declare function participantCommsEnv(comms: ParticipantComms | undefined): Record<string, string>;
 /** A started catch and the stop for its inbox-surface loop. */
@@ -33,7 +33,7 @@ export interface RunningCommsCatch {
 }
 /**
  * Start the in-sandbox email catch before the subject serve, so the app's send-API base URL
- * resolves the moment it boots. A comms-declared lab that cannot stand the catch up fails closed
+ * resolves the moment it boots. A comms-declared study that cannot stand the catch up fails closed
  * rather than silently sending real mail.
  */
 export declare function startCommsCatch(shell: Shell, comms: ParticipantComms, requestTimeoutMs: number): Promise<RunningCommsCatch>;

package/dist/routes/computer-use/e2b-desktop/comms.js

@@ -1,4 +1,4 @@
-// Off-app email for one E2B desktop participant (#297): the in-sandbox catch the subject app sends to, the
+// Off-app email for one E2B desktop participant: the in-sandbox catch the subject app sends to, the
 // persona's inbox surface, the real-email receiving surface, and the evidence drained at teardown.
 import { setTimeout as delay } from "node:timers/promises";
 import { buildOriginMap } from "../../../comms/capture-surface.js";
@@ -9,14 +9,15 @@ import { redactText, toErrorMessage } from "../../../evidence/redaction.js";
 import { writeContainedOutputFile } from "../../../run/contained-output.js";
 import { inboxRecipientFor, participantHasInboxRecipient } from "../participant-desktop.js";
 import { participantServeUrl } from "../types.js";
-import { addressedRecipients } from "../../../lab/parse/comms.js";
+import { addressedRecipients } from "../../../study/parse/comms.js";
+import { plural } from "../../../run/text.js";
 /** Mid-run inbox-surface render cadence (ms). Coarse enough that the per-tick `cat` + file writes stay
  *  cheap; fine enough that a verification email is visible seconds after the app sends it. */
 const INBOX_SURFACE_CADENCE_MS = 2500;
 /**
  * On an in-sandbox subject route, redirect the app's email-API sends into an in-sandbox catch
- * (loopback) so its verification mail is CAPTURED, not sent to the internet. Undefined when the
- * lab declares no fake email, which leaves the participant unchanged.
+ * (loopback) so its verification mail is captured instead of sent to the internet. Undefined when the
+ * study declares no fake email, which leaves the participant unchanged.
  */
 export function planParticipantComms(comms, serveUrl, targetUrl, inSandboxSubject) {
     const email = inSandboxSubject && comms?.email?.kind === "fake" ? comms.email : undefined;
@@ -42,7 +43,7 @@ export function planParticipantComms(comms, serveUrl, targetUrl, inSandboxSubjec
 export function participantCommsEnv(comms) {
     if (comms === undefined)
         return {};
-    // injectEnv is absent on an adopter-hosted plane (#328): there is no subject env to inject
+    // injectEnv is absent on an adopter-hosted plane: there is no subject env to inject
     // because the operator points their own app at their own catch.
     const env = comms.email.injectEnv === undefined
         ? {}
@@ -63,7 +64,7 @@ export function participantCommsEnv(comms) {
 }
 /**
  * Start the in-sandbox email catch before the subject serve, so the app's send-API base URL
- * resolves the moment it boots. A comms-declared lab that cannot stand the catch up fails closed
+ * resolves the moment it boots. A comms-declared study that cannot stand the catch up fails closed
  * rather than silently sending real mail.
  */
 export async function startCommsCatch(shell, comms, requestTimeoutMs) {
@@ -75,23 +76,23 @@ export async function startCommsCatch(shell, comms, requestTimeoutMs) {
     if (!deployed.ready) {
         throw new Error(`comms email catch did not become ready on 127.0.0.1:${comms.port} in the subject sandbox`);
     }
-    // Write the EMPTY inbox once up front so the persona's /inbox always resolves to the "No messages
-    // yet." page — never a bare 404 — the instant it navigates there, even before any mail arrives OR if
+    // Write the empty inbox once up front so the persona's /inbox always resolves to the "No messages
+    // yet." page (never a bare 404) the instant it navigates there, even before any mail arrives or if
     // the app sends to an address no declared recipient matches (the loop only re-renders on new mail).
     await writeInboxSurface(shell, deployed.surfaceDir, [], {
         originMap: comms.originMap,
         requestTimeoutMs,
     });
-    // The surface uses its OWN FakeInbox + cursor, independent of the teardown evidence drain (two
-    // readers of the append-only NDJSON — no double-count).
+    // The surface uses its own FakeInbox + cursor, independent of the teardown evidence drain (two
+    // readers of the append-only NDJSON, so no double-count).
     const stop = new AbortController();
     let renderedCount = 0;
     const loop = (async () => {
         // Render-first (so even a short session gets a populated inbox), then refresh on a cadence. The
-        // cadence uses a REAL timer, NOT the injected instant clock: this loop is unbounded, so an instant
+        // cadence uses a real timer instead of the injected instant clock: this loop is unbounded, so an instant
         // sleep would busy-spin and starve the session's own timers. `stop` interrupts the wait
         // (and clears the timer) so teardown never blocks for a full cadence. Each refresh
-        // is a full, idempotent rebuild; `renderedCount` only advances on a SUCCESSFUL render so a
+        // is a full, idempotent rebuild; `renderedCount` only advances on a successful render so a
         // transient failure retries cleanly (no duplicate emails).
         for (;;) {
             try {
@@ -200,19 +201,19 @@ export async function drainCommsEvidence(args) {
             return path;
         }
         if (collected.captured > 0) {
-            // Captured mail that matched no declared recipient must not vanish silently (invariant 6:
-            // honest signals): tell the operator to declare comms.email.recipients[].address to match
+            // Captured mail that matched no declared recipient must not vanish silently: tell the
+            // operator to declare comms.email.recipients[].address to match
             // the address the app actually sends to (e.g. the one the persona surface will sign up with).
-            warnings.push(`Comms catch captured ${collected.captured} email send(s) but none matched a declared recipient inbox — no comms evidence written. Declare comms.email.recipients[].address to match the address the app sends to.`);
+            warnings.push(`The email catch captured ${plural(collected.captured, "email send")}, but none matched a declared recipient inbox, so no email evidence was written. Set comms.email.recipients[].address to the address the app sends to.`);
         }
         else {
-            // Zero captures is the silent-broken shape (#351): the app never posted to the catch at
+            // Zero captures is the silent-broken shape: the app never posted to the catch at
             // all, so the personas stared at an empty inbox. Most common cause: the app does not
             // actually read the declared injectEnv var for its email API base URL.
             const transportHint = comms.email.smtp
                 ? `Verify the app reads ${comms.email.smtp.hostEnv}/${comms.email.smtp.portEnv} for its SMTP host and port`
                 : `Verify the app reads ${comms.email.injectEnv} for its email API base URL (an SDK that ignores it sends real mail or throws)`;
-            warnings.push(`Comms catch captured ZERO email sends — the app never delivered mail through the catch. ${transportHint} and that the flow reached an email step.`);
+            warnings.push(`The email catch captured no email sends: the app never delivered mail through it. ${transportHint} and that the flow reached an email step.`);
         }
     }
     catch (error) {

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

@@ -15,7 +15,7 @@ export function createE2BParticipantDesktop(spec, deps, warnings) {
         warnings,
         targetUrl,
         desktopCliRoute: deps.subject.kind === "desktop-cli",
-        // Off-app comms (#297): gated entirely on config.comms; no comms declared, no change.
+        // Off-app comms: gated entirely on config.comms; no comms declared, no change.
         comms: planParticipantComms(deps.residual.comms, participantServeUrl(deps.subject), targetUrl, deps.subject.kind === "clone" || deps.subject.kind === "local-tree"),
         // The default or injected sink sees every event, started and completed alike, so an operator
         // watching stderr sees both halves of each phase; the state keeps only completed ones.
@@ -23,9 +23,9 @@ export function createE2BParticipantDesktop(spec, deps, warnings) {
             if (event.ok !== undefined)
                 state.phaseRecords.push(event);
             deps.reportSubjectPhase(event, {
-                laneId: spec.planned.id,
-                laneIndex: spec.planned.index,
-                laneCount: deps.participantCount,
+                id: spec.planned.id,
+                index: spec.planned.index,
+                count: deps.participantCount,
             });
         },
     };

package/dist/routes/computer-use/e2b-desktop/fidelity.d.ts

@@ -1,4 +1,4 @@
-import type { ResidualConfig } from "../../../lab/plan-types.js";
+import type { ResidualConfig } from "../../../study/plan-types.js";
 import type { RunDesktopGeometry } from "../../../run/streams.js";
 import type { DesktopBrowserFamily, DesktopBrowserLaunchIdentity } from "../../../substrates/e2b/desktop-browser.js";
 import { makeChromeBrowserStateObserver } from "../../../substrates/e2b/desktop-cdp.js";
@@ -19,7 +19,8 @@ export declare function mobileLaunchFlags(residual: Readonly<ResidualConfig>, sp
  * observation. A request that cannot be applied fails the participant closed with the reason. Only
  * participants on a mobile preset are emulated: a run-wide flag must not hand a desktop or tablet
  * participant an iPhone user agent (the first live proof did exactly that to the desktop newcomer
- * beside the phone participant). Those participants carry no fidelity block, which is honest.
+ * beside the phone participant). Those participants carry no fidelity block, since nothing was
+ * emulated.
  */
 export declare function applyParticipantMobileFidelity(args: {
     desktop: E2BDesktopSandbox;
@@ -44,8 +45,8 @@ export declare function participantBrowserStateObserver(args: {
 }): ReturnType<typeof makeChromeBrowserStateObserver>;
 /**
  * The participant's final browser geometry, measured while the sandbox is alive. A final capture that
- * measured EITHER field wins whole, so a partial final capture omits fields the launch-time capture
- * had (honest omission); only a final capture that measured NOTHING falls back to the launch-time
+ * measured either field wins whole, so a partial final capture omits fields the launch-time capture
+ * had; only a final capture that measured nothing falls back to the launch-time
  * capture. Also reads the emulation holder's log into the fidelity block.
  */
 export declare function finalParticipantGeometry(args: {

package/dist/routes/computer-use/e2b-desktop/fidelity.js

@@ -1,5 +1,5 @@
-// Device fidelity for one E2B desktop participant: mobile emulation beyond viewport size (#221), the
-// browser-state observer that watches it for drift (#623), and the final browser geometry.
+// Device fidelity for one E2B desktop participant: mobile emulation beyond viewport size, the
+// browser-state observer that watches it for drift, and the final browser geometry.
 import { redactText, toErrorMessage } from "../../../evidence/redaction.js";
 import { readDetachedLog } from "../../../substrates/detached.js";
 import { applyMobileEmulation, DEFAULT_MOBILE_USER_AGENT, makeChromeBrowserStateObserver, } from "../../../substrates/e2b/desktop-cdp.js";
@@ -28,7 +28,8 @@ function cdpEndpoint(identity, targetUrl) {
  * observation. A request that cannot be applied fails the participant closed with the reason. Only
  * participants on a mobile preset are emulated: a run-wide flag must not hand a desktop or tablet
  * participant an iPhone user agent (the first live proof did exactly that to the desktop newcomer
- * beside the phone participant). Those participants carry no fidelity block, which is honest.
+ * beside the phone participant). Those participants carry no fidelity block, since nothing was
+ * emulated.
  */
 export async function applyParticipantMobileFidelity(args) {
     const { spec, deps } = args;
@@ -63,10 +64,10 @@ export function participantBrowserStateObserver(args) {
     return makeChromeBrowserStateObserver(args.desktop, deps.requestTimeoutMs, cdpEndpoint(args.launchIdentity, args.targetUrl), {
         targetId: args.targetId,
         // Once per participant: a dark observation channel is a gap in the instrument, and the
-        // funnel's NEVER MEASURED count needs this line to explain itself (#514).
+        // funnel's "never measured" count needs this line to explain itself.
         onUnavailable: (reason) => {
             warnings.push(`Browser-state observer unavailable for participant ${spec.planned.id} (${redactText(deps.scrubKnownValues(reason))}); ` +
-                "urlIncludes/urlPathEquals/textIncludes stop conditions and task criteria are NOT being measured this session.");
+                "urlIncludes, urlPathEquals and textIncludes stop conditions and task criteria are not measured in this session.");
         },
         drift: fidelity.emulatedTargetId === undefined
             ? undefined
@@ -75,11 +76,11 @@ export function participantBrowserStateObserver(args) {
                 expectedWidth: spec.planned.device.preset.width,
                 expectTouch: fidelity.applied?.requested.touch === true,
                 onDrift: (reason) => {
-                    warnings.push(`Mobile emulation drift for participant ${spec.planned.id}: ${reason} (#623).`);
+                    warnings.push(`Mobile emulation drift for participant ${spec.planned.id}: ${reason}.`);
                 },
                 onCovered: (coveredTargetId, read) => {
                     // A later tab the page itself reported at the phone width: evidence that
-                    // the emulation followed the participant (#623), kept on the bundle.
+                    // the emulation followed the participant, kept on the bundle.
                     if (fidelity.applied === undefined)
                         return;
                     fidelity.applied = {
@@ -95,8 +96,8 @@ export function participantBrowserStateObserver(args) {
 }
 /**
  * The participant's final browser geometry, measured while the sandbox is alive. A final capture that
- * measured EITHER field wins whole, so a partial final capture omits fields the launch-time capture
- * had (honest omission); only a final capture that measured NOTHING falls back to the launch-time
+ * measured either field wins whole, so a partial final capture omits fields the launch-time capture
+ * had; only a final capture that measured nothing falls back to the launch-time
  * capture. Also reads the emulation holder's log into the fidelity block.
  */
 export async function finalParticipantGeometry(args) {
@@ -126,7 +127,7 @@ export async function finalParticipantGeometry(args) {
     ];
     warnings.push(...geometryWarnings);
     // The emulation holder's own log, after its announce line: which later targets it
-    // attached to, what it sent, and any reply that came back as an error (#623). Read while
+    // attached to, what it sent, and any reply that came back as an error. Read while
     // the sandbox is alive; the first live proof had no way to say what the holder did.
     if (fidelity.applied !== undefined && fidelity.holderName !== undefined) {
         const holderLog = await readDetachedLog(e2bShell(desktop), fidelity.holderName, deps.requestTimeoutMs).catch(() => "");

package/dist/routes/computer-use/e2b-desktop/prepare.d.ts

@@ -1,6 +1,6 @@
 import { type E2BDesktopSandbox } from "../../../substrates/e2b/sdk.js";
 import type { E2BParticipantContext, E2BParticipantState } from "./state.js";
-export declare const CUA_ACTOR_LAB_PROVIDER_METADATA: {
+export declare const CUA_ACTOR_STUDY_PROVIDER_METADATA: {
     readonly mode: "cua-actor-lab";
     readonly tool: "humanish";
 };

package/dist/routes/computer-use/e2b-desktop/prepare.js

@@ -11,7 +11,7 @@ import { loadE2BDesktopModule } from "../../../substrates/e2b/sdk.js";
 import { e2bShell } from "../../../substrates/e2b/shell.js";
 import { attachReceivingInbox, participantCommsEnv, startCommsCatch } from "./comms.js";
 import { participantSubjectEnv } from "../types.js";
-export const CUA_ACTOR_LAB_PROVIDER_METADATA = {
+export const CUA_ACTOR_STUDY_PROVIDER_METADATA = {
     mode: "cua-actor-lab",
     tool: "humanish",
 };
@@ -24,7 +24,7 @@ export async function acquireParticipantDesktop(ctx, state) {
     const { residual, env } = deps;
     const subjectEnvNames = participantSubjectEnv(deps.subject);
     const subjectEnvValues = residual.subject.envValues ?? {};
-    // Off-app comms (#297): the base-URL env is injected at sandbox create, so the app reads it at
+    // Off-app comms: the base-URL env is injected at sandbox create, so the app reads it at
     // boot; the catch starts right after create.
     const commsEnv = participantCommsEnv(ctx.comms);
     const desktopModule = await (deps.desktopModule ?? loadE2BDesktopModule)();
@@ -37,12 +37,12 @@ export async function acquireParticipantDesktop(ctx, state) {
             requestTimeoutMs: deps.requestTimeoutMs,
             timeoutMs: deps.sandboxMs,
             metadata: {
-                ...CUA_ACTOR_LAB_PROVIDER_METADATA,
-                labId: deps.labId,
-                simId: spec.recordId,
-                laneId: spec.planned.id,
-                laneIndex: String(spec.planned.index),
-                laneCount: String(deps.participantCount),
+                ...CUA_ACTOR_STUDY_PROVIDER_METADATA,
+                labId: deps.studyId,
+                recordId: spec.recordId,
+                participantId: spec.planned.id,
+                participantIndex: String(spec.planned.index),
+                participantCount: String(deps.participantCount),
             },
             // The participant's model key never enters the sandbox (the model drives from outside).
             // The subject's declared env names are provisioned here on the clone route.
@@ -129,7 +129,7 @@ export async function verifyParticipantScreen(ctx, state, desktop) {
         state.desktopGeometry = { ...state.desktopGeometry, warnings: [screenGeometry.warning] };
     }
     if (screenGeometry.error && deps.screenMismatchPolicy !== "record-evidence") {
-        state.failureCode = "HUMANISH_CUA_LAB_DEVICE_GEOMETRY";
+        state.failureCode = "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY";
         throw new Error(screenGeometry.error);
     }
     if (screenGeometry.error && screenGeometry.verified) {
@@ -149,7 +149,7 @@ export async function provisionParticipantSubject(ctx, state, desktop) {
     const { residual, subject } = deps;
     const shell = e2bShell(desktop);
     if (subject.kind === "desktop-cli") {
-        // Prepare the runtime and any declared product install, UNKEYED. With install omitted,
+        // Prepare the runtime and any declared product install, with no keys. With install omitted,
         // the participant discovers and installs the product from its public surfaces.
         await provisionDesktopCli(shell, {
             product: subject.product.name,

package/dist/routes/computer-use/e2b-desktop/start.js

@@ -47,17 +47,17 @@ export async function openParticipantSurface(ctx, state, desktop) {
     if (subject.kind === "desktop-cli") {
         // A terminal window, opened the way the browser is opened on every other route: the
         // participant arrives at a desktop with the thing they were asked to use already in front
-        // of them. They can still open another from the dock — that is the point of a desktop.
+        // of them. They can still open another from the dock; that is the point of a desktop.
         await openDesktopTerminal(desktop, deps.requestTimeoutMs, subject.product.workdir);
         await desktop.wait(DESKTOP_SETTLE_MS).catch(() => undefined);
         return;
     }
     const requestedMedia = residual.execution?.desktop?.media;
-    // A declared camera (#509) is in place before the browser starts: the feed is generated or
+    // A declared camera is in place before the browser starts: the feed is generated or
     // uploaded first, and a feed that cannot be produced fails the participant closed here.
     const mediaEvidence = requestedMedia === undefined
         ? undefined
-        : await prepareDesktopMedia(desktop, requestedMedia, residual.policies?.mediaPermission ?? "prompt", deps.labCwd, deps.requestTimeoutMs);
+        : await prepareDesktopMedia(desktop, requestedMedia, residual.policies?.mediaPermission ?? "prompt", deps.studyCwd, deps.requestTimeoutMs);
     const emulationFlags = mobileLaunchFlags(residual, spec);
     const browserLaunch = await openDesktopBrowserTarget(desktop, targetUrl, deps.requestTimeoutMs, residual.execution?.desktop?.browser, [...emulationFlags, ...(mediaEvidence?.flags ?? [])], state.speech?.env ?? state.recording?.env);
     state.desktopBrowser =
@@ -76,7 +76,7 @@ export async function openParticipantSurface(ctx, state, desktop) {
     state.browserLaunched = true;
     noteDevToolsReadiness(ctx, browserLaunch.devTools, emulationFlags.length > 0);
     await desktop.wait(DESKTOP_SETTLE_MS).catch(() => undefined);
-    // Mobile fidelity (#221) is applied outside startParticipantStream's best-effort catch, so a request
+    // Mobile fidelity is applied outside startParticipantStream's best-effort catch, so a request
     // that cannot be applied fails the participant closed.
     state.fidelity = await applyParticipantMobileFidelity({
         desktop,
@@ -91,7 +91,7 @@ export async function openParticipantSurface(ctx, state, desktop) {
 }
 /**
  * DevTools answering later than this after launch is recorded as a warning on the participant. Six live
- * launches answered in 4.8-7.7 s; the reads this wait now guards used to give up at about 11 s.
+ * launches answered in 4.8-7.7 s; without this wait the reads it guards give up at about 11 s.
  */
 const SLOW_DEVTOOLS_MS = 10_000;
 /**
@@ -172,7 +172,7 @@ export async function startParticipantStream(ctx, state, desktop) {
                 type: "ready",
                 participantId: spec.planned.id,
                 sandboxId: desktop.sandboxId,
-                simId: spec.recordId,
+                recordId: spec.recordId,
                 streamId: spec.streamId,
                 url: candidateStreamUrl,
             });
@@ -188,7 +188,7 @@ export async function startParticipantStream(ctx, state, desktop) {
     // never a participant finding about missing controls. Both computer-use and shared-world participants
     // use this route.
     if (state.initialBrowserGeometry?.unusable !== undefined) {
-        state.failureCode = "HUMANISH_CUA_LAB_DEVICE_GEOMETRY";
+        state.failureCode = "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY";
         throw new Error(`${state.failureCode}: ${state.initialBrowserGeometry.unusable} Participant actions were not started.`);
     }
 }

package/dist/routes/computer-use/e2b-desktop/state.d.ts

@@ -12,7 +12,7 @@ import type { E2BDesktopSandbox } from "../../../substrates/e2b/sdk.js";
 import type { ParticipantDesktopEvidence } from "../participant-desktop.js";
 import type { ParticipantComms, RunningCommsCatch } from "./comms.js";
 import type { ParticipantFidelity } from "./fidelity.js";
-import type { CuaActorLabErrorCode, E2BDesktopDeps, DesktopParticipantRun, SandboxReleaseFact } from "../types.js";
+import type { CuaActorStudyErrorCode, E2BDesktopDeps, DesktopParticipantRun, SandboxReleaseFact } from "../types.js";
 /** What every step of one participant reads: its spec, the run's dependencies and where it points. */
 export interface E2BParticipantContext {
     readonly spec: DesktopParticipantRun;
@@ -38,7 +38,7 @@ export interface E2BParticipantState {
     desktopResources: DesktopResourceObservation | undefined;
     released: boolean;
     sandboxRelease: SandboxReleaseFact | undefined;
-    failureCode: CuaActorLabErrorCode | undefined;
+    failureCode: CuaActorStudyErrorCode | undefined;
     commsCatch: RunningCommsCatch | undefined;
     commsArtifactPath: string | undefined;
     receivingInboxUrl: string | undefined;

package/dist/routes/computer-use/e2b-desktop/teardown.js

@@ -145,14 +145,14 @@ export async function finishE2BDesktop(ctx, state, failed) {
         state.sandboxTornDownAtMs = deps.now();
         // The participant's live stream is now a dead page whichever teardown path ran (released, kept, or
         // release-failed-awaiting-TTL); tell the watch overlay so the tile falls back to recorded
-        // evidence instead of "sandbox not found" (#357). Guarded: a viewer callback must never
+        // evidence instead of "sandbox not found". Guarded: a viewer callback must never
         // break teardown.
         if (state.streamUrl !== undefined) {
             try {
                 await deps.onStream({
                     type: "ended",
                     participantId: spec.planned.id,
-                    simId: spec.recordId,
+                    recordId: spec.recordId,
                     streamId: spec.streamId,
                 });
             }