humanish 0.108.0 → 0.109.1

package/dist/actors/computer-use/loop/types.d.ts

@@ -2,7 +2,7 @@ import type { HeardSpeech } from "../speech.js";
 import type { ActorCapabilities, ActorConversation, ActorExecutionProfile, ActorPersonaRef, ActorSessionResult, ActorTokenUsage, ActorTrace, ActorTraceItem, ParticipantClosingReport, ParticipantDeclaredOutcome, ProviderRequestReceipt } from "../../contract.js";
 import type { RedactionHooks } from "../../../evidence/redaction.js";
 import type { DwellWindow, StopWhen } from "../../stop-conditions.js";
-import type { LabTask } from "../../../lab/tasks.js";
+import type { StudyTask } from "../../../study/tasks.js";
 import type { ReasoningEffort } from "../../reasoning-effort.js";
 /**
  * One desktop action. `heldKeys` on a pointer action are held down for the whole action and
@@ -80,7 +80,7 @@ export interface CuaObservation {
      * in-memory progress key is derived from it. A structured blob has no detectable secret shape
      * (the published-evidence scan catches only secret-shaped patterns), so it is handled like
      * stateSignature, which is never written as text either. Persisting it would need a stringified
-     * projection through redaction.redactText and the lab's scrubText, with its fields capped or
+     * projection through redaction.redactText and the run's scrubText, with its fields capped or
      * allowlisted, since pattern and literal redaction cannot sanitize an arbitrary blob.
      */
     appState?: Record<string, unknown>;
@@ -301,7 +301,7 @@ export interface CuaLoopOptions {
     /**
      * Extra literal scrub for known provisioned values (which have no detectable "shape", so
      * pattern redaction cannot catch them), composed before redactText on every model-authored
-     * text item (reasoning, message, completion summary) and the loop error. The lab passes the
+     * text item (reasoning, message, completion summary) and the loop error. The route passes the
      * env-value scrubber here so a value the model narrates can never land raw in the trace.
      * Default: identity (the loop is shape-only on its own).
      */
@@ -324,19 +324,19 @@ export interface CuaLoopOptions {
     /** Injected pause for the dwell window's cadence; tests advance their clock through it. */
     sleep?: (ms: number) => Promise<void>;
     /**
-     * The lab's declared protocol: discrete tasks whose completion is corroborated by the
+     * The study's declared protocol: discrete tasks whose completion is corroborated by the
      * same observations stopWhen reads, on the same cadence. The tracker never influences the loop's
      * control flow: a completed task list does not stop a session (that is stopWhen's job); it only
      * records the funnel that lands on the trace. The participant-facing halves of these tasks are
      * already in `instructions` (composed upstream); the loop reads only the `success` criteria,
      * which never reach the prompt.
      */
-    tasks?: readonly LabTask[];
+    tasks?: readonly StudyTask[];
     /**
      * Spend cap in USD. When set, the loop stops with budget_reached as soon as the running
      * estimated spend crosses it, before the next provider turn. Absent means uncapped. maxUsd: 0
      * can still permit one model request before its reported spend trips the check. Enforcement
-     * needs an estimate, so the lab refuses a cap on an unpriced model at preflight.
+     * needs an estimate, so humanish refuses a cap on an unpriced model at preflight.
      */
     maxUsd?: number;
     /**
@@ -363,6 +363,22 @@ export interface CuaLoopOptions {
      * built-in route sets it.
      */
     requireReportedUsageForSpendCap?: boolean;
+    /**
+     * Trace snapshot for a watcher: the redacted items recorded so far, with the running
+     * usage so a run can be priced in flight. Called after each checkpoint's screenshot (the initial
+     * observation and every acted turn, so a flush never shows an action without the frame before
+     * it), after each dwell frame, and after a closing request. The array is a fresh copy; its items
+     * are the objects the final trace persists. Not awaited, so a slow flush cannot stall a turn.
+     * Default: no-op.
+     */
+    onTrace?: (items: readonly ActorTraceItem[], usage: ActorTokenUsage, metadata?: CuaLiveMetadata) => void;
+}
+/**
+ * The runtime-only taps the external-public shared-world handoff (src/routes/shared-world/handoff.ts)
+ * reads the lobby code through. Internal: 0.109.0 removed them from CuaLoopOptions, and a library
+ * caller wraps the executor's `observe` or the provider's `nextTurn` instead.
+ */
+export interface LoopTaps {
     /**
      * Runtime-only URL tap: called with `observation.url` for each observation a turn may receive
      * (the initial one, each post-action one and the one after a dwell window). The loop never
@@ -370,9 +386,6 @@ export interface CuaLoopOptions {
      *
      * Built-in caller: the external-public shared-world handoff (src/routes/shared-world/handoff.ts)
      * latches the host participant's lobby URL and checks that each follower reached the same lobby.
-     *
-     * @deprecated Wrap the executor's `observe` and read `url` from each observation it returns. The
-     * next minor removes this option.
      */
     onObservedUrl?: (url: string | undefined) => void;
     /**
@@ -383,9 +396,6 @@ export interface CuaLoopOptions {
      *
      * Built-in caller: the external-public handoff scans the host's narration for the lobby code,
      * because the E2B desktop's CDP URL read behind onObservedUrl is unreliable.
-     *
-     * @deprecated Wrap the provider's `nextTurn` and read `reasoning` and `message` from each turn it
-     * returns. The next minor removes this option.
      */
     onMessage?: (text: string) => void;
     /**
@@ -395,21 +405,11 @@ export interface CuaLoopOptions {
      *
      * Built-in caller: the external-public handoff reads the lobby code off each participant's own
      * frame until that participant has one: the host's latch, or a follower's convergence observation.
-     *
-     * @deprecated Wrap the executor's `observe` and read `screenshot` from each observation it
-     * returns. The next minor removes this option.
      */
     onScreenshot?: (frame: Buffer) => void;
-    /**
-     * Trace snapshot for a watcher: the redacted items recorded so far, with the running
-     * usage so a run can be priced in flight. Called after each checkpoint's screenshot (the initial
-     * observation and every acted turn, so a flush never shows an action without the frame before
-     * it), after each dwell frame, and after a closing request. The array is a fresh copy; its items
-     * are the objects the final trace persists. Not awaited, so a slow flush cannot stall a turn.
-     * Default: no-op.
-     */
-    onTrace?: (items: readonly ActorTraceItem[], usage: ActorTokenUsage, metadata?: CuaLiveMetadata) => void;
 }
+/** The loop's options inside humanish: the public ones plus the handoff's taps. */
+export type LoopRunOptions = CuaLoopOptions & LoopTaps;
 export type CuaLiveMetadata = Pick<ActorTrace, "executionProfile" | "providerRequests" | "historyTurnsOmitted">;
 /** What runComputerUseLoop returns; the public name for an actor session result. */
 export type CuaLoopResult = ActorSessionResult;

package/dist/actors/computer-use/loop/usage.d.ts

@@ -1,5 +1,5 @@
 import type { ActorProviderRequest, ActorTokenUsage, ProviderRequestReceipt } from "../../contract.js";
-import type { CuaProviderError } from "../provider-error.js";
+import type { ComputerUseProviderError } from "../provider-error.js";
 import type { CuaLiveMetadata, CuaProvider, CuaTurn } from "./types.js";
 type TurnUsage = NonNullable<CuaTurn["usage"]>;
 /** Turn usage with valid input and output counts, cache counts within input, and turns that add up. */
@@ -67,7 +67,7 @@ export declare class UsageLedger {
      * Book one settled single-dispatch request. A request that settles while a continuing request
      * is open belongs to that interaction, whatever kind the caller asked for.
      */
-    settle(kind: "interaction" | "debrief", receipt: ProviderRequestReceipt, usage: ActorTokenUsage | undefined, error: CuaProviderError | undefined): "interaction" | "debrief";
+    settle(kind: "interaction" | "debrief", receipt: ProviderRequestReceipt, usage: ActorTokenUsage | undefined, error: ComputerUseProviderError | undefined): "interaction" | "debrief";
     /**
      * The running usage both spend guards price: totals plus the per-inference ledger, shaped like
      * the trace's final tokenUsage so one estimator prices both. Unlike the persisted trace, where an

package/dist/actors/computer-use/loop.d.ts

@@ -1,4 +1,4 @@
-import type { CuaLoopOptions, CuaLoopResult } from "./loop/types.js";
+import type { CuaLoopOptions, CuaLoopResult, LoopRunOptions } from "./loop/types.js";
 export type { CuaAction, CuaExecutor, CuaLiveMetadata, CuaLoopOptions, CuaLoopResult, CuaObservation, CuaProvider, CuaSafetyCheck, CuaSpendGate, CuaTurn, CuaTurnRequest, } from "./loop/types.js";
 export { describeCuaAction } from "./loop/actions.js";
 export { stableProgressKey } from "./loop/backstop.js";
@@ -9,3 +9,8 @@ export { validClosingReport } from "./loop/debrief.js";
  * it is recorded; screenshots are persisted raw unless redactScreenshots is set.
  */
 export declare function runComputerUseLoop(options: CuaLoopOptions): Promise<CuaLoopResult>;
+/**
+ * runComputerUseLoop with the external-public handoff's taps (LoopTaps), which the public
+ * options no longer carry. The actor's entry.
+ */
+export declare function runComputerUseLoopWithTaps(options: LoopRunOptions): Promise<CuaLoopResult>;

package/dist/actors/computer-use/loop.js

@@ -1,4 +1,4 @@
-import { CuaProviderError } from "./provider-error.js";
+import { ComputerUseProviderError } from "./provider-error.js";
 import { runActionBatch } from "./loop/actions.js";
 import { advanceBackstop, startBackstop } from "./loop/backstop.js";
 import { requestDebrief } from "./loop/debrief.js";
@@ -20,6 +20,28 @@ export { validClosingReport } from "./loop/debrief.js";
  * it is recorded; screenshots are persisted raw unless redactScreenshots is set.
  */
 export async function runComputerUseLoop(options) {
+    refuseRemovedOptions(options);
+    return runComputerUseLoopWithTaps(options);
+}
+/** What 0.109.0 removed from CuaLoopOptions, and what a caller does instead. */
+const REMOVED_OPTIONS = {
+    onObservedUrl: "Wrap the executor's `observe` and read `url` from each observation it returns.",
+    onMessage: "Wrap the provider's `nextTurn` and read `reasoning` and `message` from each turn it returns.",
+    onScreenshot: "Wrap the executor's `observe` and read `screenshot` from each observation it returns.",
+};
+/** A JavaScript caller still passing a removed option gets an error, not a hook that never fires. */
+function refuseRemovedOptions(options) {
+    for (const [name, replacement] of Object.entries(REMOVED_OPTIONS)) {
+        if (options[name] !== undefined) {
+            throw new TypeError(`runComputerUseLoop: ${name} was removed in 0.109.0. ${replacement}`);
+        }
+    }
+}
+/**
+ * runComputerUseLoop with the external-public handoff's taps (LoopTaps), which the public
+ * options no longer carry. The actor's entry.
+ */
+export async function runComputerUseLoopWithTaps(options) {
     refuseAccountBilledCaps(options);
     const session = new LoopSession(options);
     const conversation = {
@@ -132,7 +154,7 @@ function applyBackstop(session, conversation, step, turnHints) {
 }
 function refuseAccountBilledCaps(options) {
     if (accountBillingConflicts(options.provider, options)) {
-        throw new CuaProviderError("request_rejected", {
+        throw new ComputerUseProviderError("request_rejected", {
             dispatched: false,
             usageComplete: false,
             cleanup: "confirmed",
@@ -201,7 +223,7 @@ function stopBeforeActing(session, turn, turnNumber) {
     }
     return undefined;
 }
-/** Hand the turn's narration to the onMessage hook; see CuaLoopOptions.onMessage. */
+/** Hand the turn's narration to the onMessage tap; see LoopTaps.onMessage. */
 function forwardNarration(session, turn) {
     const { onMessage } = session.settings;
     const narration = [turn.reasoning, turn.message]
@@ -241,7 +263,7 @@ function reviewSafetyChecks(session, conversation, turn) {
     const { acknowledgeSafetyChecks } = session;
     const acks = acknowledgeSafetyChecks(turn.pendingSafetyChecks);
     if (acks === null || acks.length === 0) {
-        return stops.blockedOnSafetyChecks(session.settings.redaction.redactText(turn.pendingSafetyChecks.map((check) => check.code).join(", ")));
+        return stops.blockedOnSafetyChecks(session.settings.redaction.redactText(turn.pendingSafetyChecks.map((check) => check.code).join(", ")), turn.pendingSafetyChecks.length);
     }
     conversation.acknowledgedSafetyChecks = acks;
     return undefined;

package/dist/actors/computer-use/openai-provider.d.ts

@@ -5,8 +5,8 @@ import type { ReasoningEffort } from "../reasoning-effort.js";
 export declare const OPENAI_RESPONSES_CU_CAPABILITIES: ActorCapabilities;
 export declare const DEFAULT_OPENAI_CU_MODEL = "gpt-5.6-sol";
 /**
- * The effort a request carries when a lab declares none. Exported because a default that only
- * exists as a literal inside the provider is exactly how it stayed invisible: the lab surface has
+ * The effort a request carries when a study declares none. Exported because a default that only
+ * exists as a literal inside the provider is exactly how it stayed invisible: the study surface has
  * to be able to say what will actually run.
  */
 export declare const DEFAULT_OPENAI_CU_REASONING_EFFORT: ReasoningEffort;

package/dist/actors/computer-use/openai-provider.js

@@ -1,6 +1,6 @@
 import { validClosingReport } from "./loop.js";
-import { CuaAdmissionLimitError, isCuaAdmissionLimitError } from "./admission-limit.js";
-import { CuaPromptRefusedError } from "./provider-error.js";
+import { ComputerUseAdmissionLimitError, isComputerUseAdmissionLimitError, } from "./admission-limit.js";
+import { ComputerUsePromptRefusedError } from "./provider-error.js";
 import { CarriedConversation } from "./openai-context.js";
 import { acceptReply, ConversationRecord, debriefRequestBody, turnInputItems, turnRequestBody, } from "./openai-requests.js";
 import { asRecord, optionalString, parseOpenAiResponse, } from "./openai-wire.js";
@@ -56,8 +56,8 @@ export const OPENAI_RESPONSES_CU_CAPABILITIES = {
 // rate-table key stay stable if OpenAI repoints the alias.
 export const DEFAULT_OPENAI_CU_MODEL = "gpt-5.6-sol";
 /**
- * The effort a request carries when a lab declares none. Exported because a default that only
- * exists as a literal inside the provider is exactly how it stayed invisible: the lab surface has
+ * The effort a request carries when a study declares none. Exported because a default that only
+ * exists as a literal inside the provider is exactly how it stayed invisible: the study surface has
  * to be able to say what will actually run.
  */
 export const DEFAULT_OPENAI_CU_REASONING_EFFORT = "medium";
@@ -280,8 +280,8 @@ async function postResponse(transport, body, signal, retries, interaction, spend
         catch (error) {
             // An explicit local pre-dispatch limit is terminal. Recreate the fixed safe payload
             // rather than propagating caller-added message/context through the transport seam.
-            if (isCuaAdmissionLimitError(error))
-                throw new CuaAdmissionLimitError();
+            if (isComputerUseAdmissionLimitError(error))
+                throw new ComputerUseAdmissionLimitError();
             // Dispatch may have reached the provider. Preserve this uncertainty even when a later
             // retry succeeds or is refused locally; only that later refusal is known not to dispatch.
             // Under a spend gate the loop accounts for the attempt instead: it books a resend below
@@ -317,7 +317,7 @@ async function postResponse(transport, body, signal, retries, interaction, spend
             }
             // A usage-policy flag is terminal for this prompt: typed so the loop names it, never retried.
             if (namedProviderErrorCode(bodyText) === "invalid_prompt") {
-                throw new CuaPromptRefusedError("OpenAI", "400 invalid_prompt");
+                throw new ComputerUsePromptRefusedError("OpenAI", "400 invalid_prompt");
             }
             const detail = requestRejectionDetail(bodyText);
             throw new Error(`OpenAI Responses 400${detail === undefined ? "" : ` ${detail}`}`);
@@ -452,7 +452,7 @@ export function createOpenAiResponsesProvider(options) {
     return {
         id: "openai-responses-cu",
         version: model,
-        // The effort the wire actually carries, not the one the lab asked for: the provider defaults
+        // The effort the wire actually carries, not the one the study asked for: the provider defaults
         // an absent request to "medium", and the trace has to say what produced it.
         modelSettings: {
             reasoningEffort,

package/dist/actors/computer-use/provider-error.d.ts

@@ -5,23 +5,23 @@ export declare const isCuaProviderFailurePhase: (value: unknown) => value is Cua
 declare const codes: readonly ["request_rejected", "unavailable", "busy", "refused", "invalid_response", "protocol_error", "timeout", "cancelled", "process_failed", "cleanup_unconfirmed"];
 export type CuaProviderErrorCode = (typeof codes)[number];
 /** Safe local classification. Never attach provider prose, stderr, paths or a raw cause. */
-export declare class CuaProviderError extends Error {
+export declare class ComputerUseProviderError extends Error {
     readonly code: CuaProviderErrorCode;
     readonly receipt: ProviderRequestReceipt;
     readonly usage?: ActorTokenUsage;
     readonly failurePhase?: CuaProviderFailurePhase;
     constructor(code: CuaProviderErrorCode, receipt: ProviderRequestReceipt, usage?: ActorTokenUsage, failurePhase?: CuaProviderFailurePhase);
 }
-export declare const isCuaProviderError: (value: unknown) => value is CuaProviderError;
+export declare const isComputerUseProviderError: (value: unknown) => value is ComputerUseProviderError;
 /**
  * The model provider refused the request under its usage policy (OpenAI `invalid_prompt`). A
  * refusal is the provider's decision about this prompt, so it is not a harness fault, and sending
  * the same prompt again is not a recovery path. `providerCode` is the provider's identifier only;
  * the provider's message can echo the prompt and is never attached.
  */
-export declare class CuaPromptRefusedError extends Error {
+export declare class ComputerUsePromptRefusedError extends Error {
     readonly providerCode: string;
     constructor(provider: string, providerCode: string);
 }
-export declare const isCuaPromptRefusedError: (value: unknown) => value is CuaPromptRefusedError;
+export declare const isComputerUsePromptRefusedError: (value: unknown) => value is ComputerUsePromptRefusedError;
 export {};

package/dist/actors/computer-use/provider-error.js

@@ -24,7 +24,7 @@ const codes = Object.freeze([
 ]);
 const errors = new WeakSet();
 /** Safe local classification. Never attach provider prose, stderr, paths or a raw cause. */
-export class CuaProviderError extends Error {
+export class ComputerUseProviderError extends Error {
     code;
     receipt;
     usage;
@@ -50,7 +50,7 @@ export class CuaProviderError extends Error {
             throw new TypeError("Invalid participant provider error declaration.");
         }
         super(`Participant provider: ${code}`);
-        this.name = "CuaProviderError";
+        this.name = "ComputerUseProviderError";
         this.code = code;
         this.receipt = Object.freeze({
             dispatched: receipt.dispatched,
@@ -66,7 +66,7 @@ export class CuaProviderError extends Error {
         errors.add(this);
     }
 }
-export const isCuaProviderError = (value) => typeof value === "object" && value !== null && errors.has(value);
+export const isComputerUseProviderError = (value) => typeof value === "object" && value !== null && errors.has(value);
 const refusals = new WeakSet();
 /**
  * The model provider refused the request under its usage policy (OpenAI `invalid_prompt`). A
@@ -74,13 +74,13 @@ const refusals = new WeakSet();
  * the same prompt again is not a recovery path. `providerCode` is the provider's identifier only;
  * the provider's message can echo the prompt and is never attached.
  */
-export class CuaPromptRefusedError extends Error {
+export class ComputerUsePromptRefusedError extends Error {
     providerCode;
     constructor(provider, providerCode) {
         super(`${provider} refused the prompt under its usage policy (${providerCode})`);
-        this.name = "CuaPromptRefusedError";
+        this.name = "ComputerUsePromptRefusedError";
         this.providerCode = providerCode;
         refusals.add(this);
     }
 }
-export const isCuaPromptRefusedError = (value) => typeof value === "object" && value !== null && refusals.has(value);
+export const isComputerUsePromptRefusedError = (value) => typeof value === "object" && value !== null && refusals.has(value);

package/dist/actors/contract.d.ts

@@ -1,6 +1,6 @@
 import type { AffordanceUse } from "./affordance.js";
 import type { ActorEstimatedCost } from "../run/pricing.js";
-import type { TaskFunnel } from "../lab/tasks.js";
+import type { TaskFunnel } from "../study/tasks.js";
 import { type CuaProviderFailurePhase } from "./computer-use/provider-error.js";
 export declare const ACTOR_TRACE_SCHEMA = "humanish.actor-trace.v1";
 /**
@@ -271,7 +271,7 @@ export interface ActorTrace {
      * carried. Present on traces whose provider declares settings; absent everywhere else and on
      * every pre-existing bundle, and its absence is tolerated by verify.
      *
-     * It exists because effort was a silent constant: unreachable from a lab, so every run took the
+     * It exists because effort was a silent constant: unreachable from a study, so every run took the
      * provider default. Effort is part of who the participant was, not of how the instrument was
      * tuned (docs/principles/actor-fidelity.md), so a trace that does not carry it is a result with
      * half its sample description missing, and two such traces cannot be compared.
@@ -294,8 +294,8 @@ export interface ActorTrace {
     affordanceUse?: AffordanceUse;
     /**
      * Additive + optional task funnel (humanish.task-funnel.v1): how far this participant got
-     * through the lab's declared protocol, corroborated per task by observations rather than by the
-     * actor's own narration. Present only when the lab declared `tasks` and the session ran; absent
+     * through the study's declared protocol, corroborated per task by observations rather than by the
+     * actor's own narration. Present only when the study declared `tasks` and the session ran; absent
      * on every pre-existing bundle and on dry-run contract bundles (a funnel that
      * was never measured is not an empty funnel). Its absence is tolerated by verify.
      */

package/dist/actors/contract.js

@@ -6,7 +6,7 @@ import { isCuaProviderFailurePhase, } from "./computer-use/provider-error.js";
 // The schema maps the providers and routes implemented by the closed first-party
 // registry. The broader Actor.run(input) and ApprovalPolicy contract remains
 // design-only and is intentionally absent from these runtime types. RedactionHooks
-// (src/evidence/redaction.ts) and ResolvedPersona (src/lab/persona.ts) ship in
+// (src/evidence/redaction.ts) and ResolvedPersona (src/study/persona.ts) ship in
 // their own modules.
 export const ACTOR_TRACE_SCHEMA = "humanish.actor-trace.v1";
 /**

package/dist/actors/local-agent/claude-session.js

@@ -2,7 +2,7 @@
 //
 // Why: `actors[].localAgent: codex` already runs through a persistent app-server thread,
 // so the participant remembers what it tried. `claude` spawned `claude -p` per turn, so every
-// turn started cold. Measured on the same lab with the same credentials (n=1 each): one-shot,
+// turn started cold. Measured on the same study with the same credentials (n=1 each): one-shot,
 // 188 actions over 90 turns and never finished; a thread that remembers, 21 actions over 8 turns
 // and goal_satisfied in 103 s. A participant that cannot remember trying the menu tries the menu
 // again. Until this existed, comparing the two agents measured the transport, not the model.
@@ -22,7 +22,7 @@ import { mkdtemp, rm, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import readline from "node:readline";
-import { CuaProviderError } from "../computer-use/provider-error.js";
+import { ComputerUseProviderError } from "../computer-use/provider-error.js";
 import { declaredOutcomeOf, parseAgentJson, promptFor, toCuaActions, LOCAL_AGENT_CAPABILITIES, } from "./cli.js";
 /** How long Claude Code may take to acknowledge an interrupt before the session is ended. */
 const INTERRUPT_RECEIPT_TIMEOUT_MS = 5_000;
@@ -289,7 +289,7 @@ export async function startClaudeSession(options = {}) {
                 usageIncomplete = true;
                 if (error instanceof ClaudeSessionDesyncError) {
                     // The stream no longer pairs results with turns, so no later turn can trust it.
-                    throw new CuaProviderError("protocol_error", {
+                    throw new ComputerUseProviderError("protocol_error", {
                         dispatched: "unknown",
                         usageComplete: false,
                         cleanup: "unconfirmed",

package/dist/actors/local-agent/cli.d.ts

@@ -49,7 +49,7 @@ export interface LocalAgentProviderOptions {
     timeoutMs?: number;
     /**
      * Recorded in the trace's model settings. Low by default: a computer-use run is sixty turns, and
-     * a high-effort answer per turn costs minutes. The lab can raise it.
+     * a high-effort answer per turn costs minutes. The study can raise it.
      */
     reasoningEffort?: ReasoningEffort;
     /** Model override passed to the CLI (`--model`). Absent = the CLI's own default. */

package/dist/actors/local-agent/cli.js

@@ -401,7 +401,7 @@ export const NO_LOCAL_AGENT_MESSAGE = "no local coding agent found. openai-compu
 /** Doctor's row for one installed agent, in the register the other rows use. */
 export function localAgentDoctorMessage(agent) {
     if (agent.authStatus === "authenticated")
-        return `${agent.label} reports signed in; a lab with actors[0].type: local-agent can use it instead of a provider API key. Account access and limits are untested.`;
+        return `${agent.label} reports signed in; a study with actors[0].type: local-agent can use it instead of a provider API key. Account access and limits are untested.`;
     const status = agent.id === "codex" ? "codex login status" : "claude auth status";
     return agent.authStatus === "unauthenticated"
         ? `${agent.label} is installed and reports not signed in; run \`${agent.id === "codex" ? "codex login" : "claude auth login"}\``

package/dist/actors/reasoning-effort.js

@@ -1,7 +1,7 @@
-// The provider-declared reasoning-effort vocabulary, kept in its own module so the lab schema and
+// The provider-declared reasoning-effort vocabulary, kept in its own module so the study schema and
 // the OpenAI provider can share it without the schema depending on a provider.
 //
-// Why this exists: effort was reachable in the provider and unreachable from a lab. Every
+// Why this exists: effort was reachable in the provider and unreachable from a study. Every
 // computer-use run humanish had ever done was therefore the provider default, not by decision but
 // by omission. Effort changes who the participant is, the same way a persona prompt does
 // (docs/principles/actor-fidelity.md: capability settings are recruiting decisions), so pinning it
@@ -10,7 +10,7 @@
 //
 // Support is model-dependent. OpenAI documents the vocabulary below as the union across models and
 // states plainly that "supported values are model-dependent"; there is no offline way to know which
-// subset a given model id accepts. So this module refuses to pretend: it validates that a lab asked
+// subset a given model id accepts. So this module refuses to pretend: it validates that a study asked
 // for a real effort level, and a model that does not support the one it was asked for fails on the
 // first turn with the provider's own message rather than being silently downgraded. Silent
 // downgrade is the worse failure: it would record an effort the run did not actually use.

package/dist/actors/registry.d.ts

@@ -31,7 +31,7 @@ export type ActorDescriptor = CodexActorDescriptor | CuaActorDescriptor | Script
  * CuaActorDescriptor: its runSession takes CuaActorSessionOptions and returns a CuaLoopResult.
  * Any future computer-use provider (e.g. stagehand-cua) must keep that session signature and add
  * its id to CuaActorDescriptor["id"], so code narrowed by this guard can still tell the ids apart.
- * This guard is what lets the lab dispatch on capabilities rather than on hardcoded actor ids.
+ * This guard is what lets humanish dispatch on capabilities rather than on hardcoded actor ids.
  */
 export declare function isCuaActorDescriptor(descriptor: ActorDescriptor): descriptor is CuaActorDescriptor;
 /**
@@ -39,7 +39,7 @@ export declare function isCuaActorDescriptor(descriptor: ActorDescriptor): descr
  * "scripted-browser" run kind is a ScriptedBrowserActorDescriptor; runSession takes
  * ScriptedBrowserSessionOptions and returns ScriptedBrowserSessionResult (trace fully formed,
  * like the CUA shape; no separate toActorTrace). Any future scripted driver (e.g. a HAR
- * replayer) must keep this signature; it is what lets the lab dispatch on capabilities, not ids.
+ * replayer) must keep this signature; it is what lets humanish dispatch on capabilities.
  */
 export declare function isScriptedBrowserActorDescriptor(descriptor: ActorDescriptor): descriptor is ScriptedBrowserActorDescriptor;
 /**

package/dist/actors/registry.js

@@ -10,7 +10,7 @@ import { runScriptedBrowserSession, } from "./scripted-browser/actor.js";
  * CuaActorDescriptor: its runSession takes CuaActorSessionOptions and returns a CuaLoopResult.
  * Any future computer-use provider (e.g. stagehand-cua) must keep that session signature and add
  * its id to CuaActorDescriptor["id"], so code narrowed by this guard can still tell the ids apart.
- * This guard is what lets the lab dispatch on capabilities rather than on hardcoded actor ids.
+ * This guard is what lets humanish dispatch on capabilities rather than on hardcoded actor ids.
  */
 export function isCuaActorDescriptor(descriptor) {
     return descriptor.capabilities.lanes.includes("computer-use");
@@ -20,7 +20,7 @@ export function isCuaActorDescriptor(descriptor) {
  * "scripted-browser" run kind is a ScriptedBrowserActorDescriptor; runSession takes
  * ScriptedBrowserSessionOptions and returns ScriptedBrowserSessionResult (trace fully formed,
  * like the CUA shape; no separate toActorTrace). Any future scripted driver (e.g. a HAR
- * replayer) must keep this signature; it is what lets the lab dispatch on capabilities, not ids.
+ * replayer) must keep this signature; it is what lets humanish dispatch on capabilities.
  */
 export function isScriptedBrowserActorDescriptor(descriptor) {
     return descriptor.capabilities.lanes.includes("scripted-browser");
@@ -74,7 +74,7 @@ export const actorRegistry = {
     },
     // The ActorId names the terminal-product dispatch slot; the live route records the concrete
     // provider as "codex". keyPlacement "in-sandbox-command-scoped" is registry-declared and
-    // enforced by runTerminalProductLab before it creates a sandbox, which is where this actor runs.
+    // enforced by runTerminalProductStudy before it creates a sandbox, which is where this actor runs.
     "codex-exec": {
         id: "codex-exec",
         label: "Codex Exec (autonomous terminal agent, in-sandbox)",

package/dist/actors/scripted-browser/actor.d.ts

@@ -15,7 +15,7 @@ export interface ScriptedBrowserSessionOptions {
     /** id = actors[0].persona ?? "scripted-journey"; promptDigest = journey.sourceDigest prefix
      *  (the step manifest is the "prompt"; no model prompt exists on this route). */
     persona: ActorPersonaRef;
-    /** Journey wall-clock budget in ms; the lab route passes execution.timeoutMs or 300_000. */
+    /** Journey wall-clock budget in ms; the route passes execution.timeoutMs or 300_000. */
     timeoutMs: number;
     /** Absolute; the session writes screenshots/ and traces/<surface>.json beneath it. */
     artifactRoot: string;
@@ -45,5 +45,5 @@ export interface ScriptedBrowserSessionResult extends ActorSessionResult {
  *   approvals exist on a deterministic replay), asserted in tests.
  */
 export declare function runScriptedBrowserSession(options: ScriptedBrowserSessionOptions): Promise<ScriptedBrowserSessionResult>;
-/** Internal lab seam: the run root is already prepared and must stay bound to that identity. */
+/** Internal route seam: the run root is already prepared and must stay bound to that identity. */
 export declare function runScriptedBrowserSessionInPreparedRoot(options: ScriptedBrowserSessionOptions, preparedArtifactRoot: PreparedOutputRoot): Promise<ScriptedBrowserSessionResult>;

package/dist/actors/scripted-browser/actor.js

@@ -69,7 +69,7 @@ export async function runScriptedBrowserSession(options) {
     const preparedArtifactRoot = await prepareSelectedOutputDirectory(process.cwd(), options.artifactRoot);
     return runScriptedBrowserSessionInPreparedRoot(options, preparedArtifactRoot);
 }
-/** Internal lab seam: the run root is already prepared and must stay bound to that identity. */
+/** Internal route seam: the run root is already prepared and must stay bound to that identity. */
 export async function runScriptedBrowserSessionInPreparedRoot(options, preparedArtifactRoot) {
     assertScriptedSessionPathIds(options);
     await prepareContainedOutputDirectory(preparedArtifactRoot, "screenshots");

package/dist/analysis/automatic-completion.d.ts

@@ -1,16 +1,16 @@
 import { FinishedRun } from "../run/run.js";
 import type { AnalysisConfig } from "./types.js";
-import type { LabDeps } from "../lab/lab-deps.js";
-import type { LabEvent } from "../lab/run-lab-events.js";
+import type { StudyDeps } from "../study/study-deps.js";
+import type { StudyEvent } from "../study/run-study-events.js";
 import { type AutomaticAnalysisDeps } from "./automatic.js";
 import type { AutomaticAnalysisOutcome } from "./job.js";
 /** What a route's input gives its analysis: the test's runner and deps, the signal and onEvent. */
 export interface AnalysisInput {
-    readonly deps?: Pick<LabDeps, "analysis">;
+    readonly deps?: Pick<StudyDeps, "analysis">;
     /** Cancels the analysis only. */
     readonly analysisSignal?: AbortSignal;
     /** Receives analysis-started and analysis-finished. */
-    readonly emit?: (event: LabEvent) => void;
+    readonly emit?: (event: StudyEvent) => void;
 }
 export interface AutomaticAnalysisResult {
     automaticAnalysis?: AutomaticAnalysisOutcome;
@@ -27,15 +27,15 @@ export declare function completeAutomaticAnalysis<T extends {
     runId: string;
     dryRun: boolean;
 }>(result: T, finished: FinishedRun | undefined, config: AnalysisConfig | undefined, input: AnalysisInput | undefined, { trigger, preferLargerOutput, refusal, }?: {
-    /** "default" when the lab declared no analysis; its missing-key skip is not a failure. */
+    /** "default" when the study declared no analysis; its missing-key skip is not a failure. */
     trigger?: "default" | "explicit";
-    /** The lab omitted an output limit, so a larger one may be used within the admission budget. */
+    /** The study omitted an output limit, so a larger one may be used within the admission budget. */
     preferLargerOutput?: boolean;
     /** The route's reason not to analyze this run; see AutomaticAnalysisDeps.refusal. */
     refusal?: AutomaticAnalysisDeps["refusal"];
 }): Promise<T & AutomaticAnalysisResult>;
 /**
- * True when an analysis the lab never declared was refused because its conservative estimate is
+ * True when an analysis the study never declared was refused because its conservative estimate is
  * over the default cap. The author did not ask for it, so the refusal does not fail the run;
  * `humanish analyze --max-cost` can still run it.
  */

package/dist/analysis/automatic-completion.js

@@ -72,7 +72,7 @@ export async function completeAutomaticAnalysis(result, finished, config, input,
     }
 }
 /**
- * True when an analysis the lab never declared was refused because its conservative estimate is
+ * True when an analysis the study never declared was refused because its conservative estimate is
  * over the default cap. The author did not ask for it, so the refusal does not fail the run;
  * `humanish analyze --max-cost` can still run it.
  */

package/dist/analysis/automatic-config.d.ts

@@ -1,14 +1,14 @@
-import type { LabRoute } from "../lab/plan.js";
+import type { StudyRoute } from "../study/plan.js";
 import type { AnalysisConfig } from "./types.js";
 export declare const DEFAULT_ANALYSIS_TIMEOUT_MS = 600000;
 export declare const DEFAULT_ANALYSIS_MODEL = "gpt-6-astra";
-interface LabAnalysisSettings {
+interface StudyAnalysisSettings {
     model?: string;
     question?: string;
     timeoutMs?: number;
 }
-/** The lab's review.analysis: a provider selection for a separate review after a live study. */
-export type LabAnalysis = LabAnalysisSettings & ({
+/** The study's review.analysis: a provider selection for a separate review after a live run. */
+export type StudyAnalysis = StudyAnalysisSettings & ({
     provider?: "openai";
     maxCostUsd: number;
     maxOutputTokens?: number;
@@ -17,7 +17,7 @@ export type LabAnalysis = LabAnalysisSettings & ({
     maxCostUsd?: null;
     maxOutputTokens?: null;
 });
-/** The spend cap on an analysis the lab did not declare. */
+/** The spend cap on an analysis the study did not declare. */
 export declare const DEFAULT_ANALYSIS_MAX_COST_USD = 3;
 /** Called for parsed manifests and direct library configs, before participant execution. */
 export declare function resolveAutomaticAnalysis(raw: unknown): {
@@ -36,6 +36,6 @@ export interface AutomaticAnalysisBudget {
     trigger: "default" | "explicit";
 }
 /** Metadata only: resolving the future live-run budget never reads keys or dispatches. */
-export declare function automaticAnalysisBudget(raw: unknown, route: LabRoute): AutomaticAnalysisBudget | undefined;
+export declare function automaticAnalysisBudget(raw: unknown, route: StudyRoute): AutomaticAnalysisBudget | undefined;
 export declare function formatAutomaticAnalysisBudget(budget: AutomaticAnalysisBudget): string;
 export {};

package/dist/analysis/automatic-config.js

@@ -22,7 +22,7 @@ const SENSITIVE_QUESTION = {
     ok: false,
     message: "review.analysis.question contains sensitive text and cannot be sent for analysis.",
 };
-/** The spend cap on an analysis the lab did not declare. */
+/** The spend cap on an analysis the study did not declare. */
 export const DEFAULT_ANALYSIS_MAX_COST_USD = 3;
 /** Called for parsed manifests and direct library configs, before participant execution. */
 export function resolveAutomaticAnalysis(raw) {