humanish 0.108.0 → 0.109.0

package/dist/cli/commands/{lab-format.js → study-format.js}

@@ -1,5 +1,5 @@
 import { formatCuaDiagnostics, formatCuaStopCause } from "../../routes/computer-use/diagnostics.js";
-/** A lab run's first lines: the command that ran, whether it was a dry run, how it ended, and its route. */
+/** A run's first lines: the command that ran, whether it was a dry run, how it ended, and its route. */
 function runHeader(result, route) {
     const kind = result.dryRun === true ? "dry run" : result.dryRun === false ? "live run" : "run";
     return [
@@ -19,7 +19,7 @@ function withError(error, lines) {
 function participantStatus(status) {
     return status === "contract_proof_only" ? "dry run, nothing ran live" : status;
 }
-export function formatConcurrentSharedWorldLabHuman(result) {
+export function formatConcurrentSharedWorldStudyHuman(result) {
     return withError(result.error, [
         ...runHeader(result, "shared-world"),
         `run: ${result.runId}`,
@@ -47,7 +47,7 @@ export function formatConcurrentSharedWorldLabHuman(result) {
         ...result.warnings.map((warning) => `warning: ${warning}`),
     ]);
 }
-export function formatTerminalLabHuman(result) {
+export function formatTerminalStudyHuman(result) {
     return withError(result.error, [
         ...runHeader(result, "terminal"),
         `run: ${result.runId}`,
@@ -60,7 +60,7 @@ export function formatTerminalLabHuman(result) {
         ...result.warnings.map((warning) => `warning: ${warning}`),
     ]);
 }
-export function formatScriptedLabHuman(result) {
+export function formatScriptedStudyHuman(result) {
     return withError(result.error, [
         ...runHeader(result, "scripted"),
         `run: ${result.runId}`,
@@ -79,7 +79,7 @@ export function formatScriptedLabHuman(result) {
         ...result.warnings.map((warning) => `warning: ${warning}`),
     ]);
 }
-export function formatCuaLabHuman(result) {
+export function formatCuaStudyHuman(result) {
     return withError(result.error, [
         ...runHeader(result, "computer-use"),
         `run: ${result.runId}`,

package/dist/cli/commands/{lab-route-computer-use.d.ts → study-route-computer-use.d.ts}

@@ -1,16 +1,16 @@
 import { Command } from "commander";
-import type { LabConfig } from "../../lab/types.js";
-import { type CliIo, type LabCommandOptions } from "../io.js";
-import type { RouteRun } from "./lab-route-run.js";
+import type { StudyConfig } from "../../study/types.js";
+import { type CliIo, type StudyCommandOptions } from "../io.js";
+import type { RouteRun } from "./study-route-run.js";
 interface ComputerUseRouteArgs {
     command: Command;
     io: CliIo;
-    config: LabConfig;
+    config: StudyConfig;
     mode: "run" | "watch";
-    options: LabCommandOptions;
+    options: StudyCommandOptions;
 }
 /**
- * The computer-use route's CLI setup: its settings, the watch and exposure plan, the runLab options
+ * The computer-use route's CLI setup: its settings, the watch and exposure plan, the runStudyWith options
  * with the live Observer hook, and how it presents the outcome or a run error. Undefined when
  * setup has already written its own result.
  */

package/dist/cli/commands/{lab-route-computer-use.js → study-route-computer-use.js}

@@ -1,19 +1,19 @@
 import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
 import { Command } from "commander";
-import {} from "../../run-lab.js";
-import { resolveLabDryRun } from "../../lab/plan.js";
+import {} from "../../run-study.js";
+import { resolveStudyDryRun } from "../../study/plan.js";
 import { serveObserver } from "../../observer/render.js";
 import { startExposedObserver, validateExposure } from "../../observer/exposure.js";
 import { ServeTunnelError } from "../../observer/tunnel.js";
 import { cliAnalysisOptions } from "./analysis-signals.js";
 import { onRunShutdown } from "./run-signals.js";
-import { parseLabCount, parseParticipantIds, parseObserverPort, wantsJson, writeResult, } from "../io.js";
+import { parseStudyCount, parseParticipantIds, parseObserverPort, wantsJson, writeResult, } from "../io.js";
 import { exposureRequestFromOptions, followObserver, planObserver, showObserver, staticObserverOpen, withObserverServer, } from "../observer-follow.js";
-import { formatCuaLabHuman } from "./lab-format.js";
-import { resolveRouteShouldOpen } from "./lab-route-open.js";
+import { formatCuaStudyHuman } from "./study-format.js";
+import { resolveRouteShouldOpen } from "./study-route-open.js";
 import { studyResultIdentity } from "../../run/study-result.js";
 /**
- * The computer-use route's CLI setup: its settings, the watch and exposure plan, the runLab options
+ * The computer-use route's CLI setup: its settings, the watch and exposure plan, the runStudyWith options
  * with the live Observer hook, and how it presents the outcome or a run error. Undefined when
  * setup has already written its own result.
  */
@@ -60,7 +60,7 @@ function refuseCua(args, dryRun, code, message) {
         warnings: [],
         error: { code, message },
     };
-    writeResult(args.command, args.io, result, formatCuaLabHuman);
+    writeResult(args.command, args.io, result, formatCuaStudyHuman);
     args.io.setExitCode(2);
 }
 /** Parses the options, or writes the refusal and returns undefined. */
@@ -78,13 +78,13 @@ function resolveCuaSettings(args) {
         args.io.setExitCode(2);
         return undefined;
     }
-    const count = parseLabCount(args.options.count, args.config.actors[0]?.count ?? 1);
+    const count = parseStudyCount(args.options.count, args.config.actors[0]?.count ?? 1);
     if (count === null) {
         args.io.writeErr("error: --count must be a positive integer.\n");
         args.io.setExitCode(2);
         return undefined;
     }
-    const dryRun = resolveLabDryRun(args.config, args.options.dryRun, true) ?? true;
+    const dryRun = resolveStudyDryRun(args.config, args.options.dryRun, true) ?? true;
     const port = parseObserverPort(args.options.port ?? "0");
     const wantsFollow = args.mode === "watch" && !wantsMachine && args.options.detach !== true && dryRun !== true;
     if (port === null) {
@@ -122,7 +122,7 @@ function prepareCuaWatch(args, settings) {
         return undefined;
     return { exposure: exposeValidation.plan, finishedPlan };
 }
-/** The runLab options for this invocation, with the live Observer hook for a followed watch. */
+/** The runStudyWith options for this invocation, with the live Observer hook for a followed watch. */
 function cuaRunOptions(args, settings, prepared, live) {
     const { finishedPlan } = prepared;
     return {
@@ -140,7 +140,7 @@ function cuaRunOptions(args, settings, prepared, live) {
         dryRun: settings.dryRun,
         ...(settings.wantsFollow
             ? {
-                // Fires inside runLab, before the actor loop and before sandbox creation, so a
+                // Fires inside runStudyWith, before the actor loop and before sandbox creation, so a
                 // tunnel-auth failure aborts before any spend and leaves no orphaned sandbox.
                 onObserverReady: (observer) => attachLiveObserver(args.io, settings, prepared.exposure, live, observer),
             }
@@ -235,7 +235,7 @@ async function reportCuaRun(args, prepared, result, live) {
             ],
         };
     }
-    writeResult(args.command, args.io, output, formatCuaLabHuman);
+    writeResult(args.command, args.io, output, formatCuaStudyHuman);
     args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
     if (server && (result.observer?.ok || attachedObserver)) {
         const followResult = output.observer?.ok

package/dist/cli/commands/{lab-route-open.d.ts → study-route-open.d.ts}

@@ -1,10 +1,10 @@
 import { Command } from "commander";
-import type { CliIo, LabCommandOptions } from "../io.js";
+import type { CliIo, StudyCommandOptions } from "../io.js";
 import { type ObserverPlan } from "../observer-follow.js";
 /**
- * Default browser-open policy for a lab route's run. Mirrors the observe/watch gate:
+ * Default browser-open policy for a study route's run. Mirrors the observe/watch gate:
  * an explicit --open/--no-open wins; --json (machine mode) never auto-opens; otherwise a
- * lab-config `defaults.open` wins, and the final fallback opens only for an interactive
+ * study-file `defaults.open` wins, and the final fallback opens only for an interactive
  * `watch` on a real TTY. Extracted so every route's CLI setup shares one gate (and one test).
  */
 export declare function resolveRouteShouldOpen(args: {
@@ -21,7 +21,7 @@ export declare function watchFinishedPlan(args: {
     command: Command;
     io: CliIo;
     mode: "run" | "watch";
-    options: LabCommandOptions;
+    options: StudyCommandOptions;
 }, wantsMachine: boolean, shouldOpen: boolean): ObserverPlan | null | undefined;
 /** The route's static render opens only when nothing else will open the Observer. */
 export declare function observerOpen(mode: "run" | "watch", finishedPlan: ObserverPlan | undefined, shouldOpen: boolean): boolean;

package/dist/cli/commands/{lab-route-open.js → study-route-open.js}

@@ -1,9 +1,9 @@
 import { Command } from "commander";
 import { planObserver, staticObserverOpen } from "../observer-follow.js";
 /**
- * Default browser-open policy for a lab route's run. Mirrors the observe/watch gate:
+ * Default browser-open policy for a study route's run. Mirrors the observe/watch gate:
  * an explicit --open/--no-open wins; --json (machine mode) never auto-opens; otherwise a
- * lab-config `defaults.open` wins, and the final fallback opens only for an interactive
+ * study-file `defaults.open` wins, and the final fallback opens only for an interactive
  * `watch` on a real TTY. Extracted so every route's CLI setup shares one gate (and one test).
  */
 export function resolveRouteShouldOpen(args) {

package/dist/cli/commands/{lab-route-preview.d.ts → study-route-preview.d.ts}

@@ -1,17 +1,17 @@
 import { Command } from "commander";
-import type { LabConfig } from "../../lab/types.js";
-import { type CliIo, type LabCommandOptions } from "../io.js";
-import type { RouteRun } from "./lab-route-run.js";
+import type { StudyConfig } from "../../study/types.js";
+import { type CliIo, type StudyCommandOptions } from "../io.js";
+import type { RouteRun } from "./study-route-run.js";
 interface PreviewRouteArgs {
     command: Command;
     io: CliIo;
-    lab: string;
-    config: LabConfig;
+    study: string;
+    config: StudyConfig;
     mode: "run" | "watch";
-    options: LabCommandOptions;
+    options: StudyCommandOptions;
 }
 /**
- * The preview route's CLI setup: the participant count and Observer plan, its runLab options, and how it
+ * The preview route's CLI setup: the participant count and Observer plan, its runStudyWith options, and how it
  * presents the outcome. Undefined when setup has already written its own result.
  */
 export declare function previewRouteRun(args: PreviewRouteArgs): RouteRun | undefined;

package/dist/cli/commands/{lab-route-preview.js → study-route-preview.js}

@@ -1,13 +1,13 @@
 import { Command } from "commander";
 import { studyResultIdentity } from "../../run/study-result.js";
-import { formatRunHuman, parseLabCount, writeResult, } from "../io.js";
+import { formatRunHuman, parseStudyCount, writeResult, } from "../io.js";
 import { planObserver, showObserver, staticObserverOpen } from "../observer-follow.js";
 /**
- * The preview route's CLI setup: the participant count and Observer plan, its runLab options, and how it
+ * The preview route's CLI setup: the participant count and Observer plan, its runStudyWith options, and how it
  * presents the outcome. Undefined when setup has already written its own result.
  */
 export function previewRouteRun(args) {
-    const participantCount = parseLabCount(args.options.count, args.config.actors[0]?.count ?? 4);
+    const participantCount = parseStudyCount(args.options.count, args.config.actors[0]?.count ?? 4);
     if (participantCount === null) {
         const result = {
             ...studyResultIdentity("preview", args.config.id),

package/dist/cli/commands/study-route-run.d.ts

@@ -0,0 +1,19 @@
+import { type InternalRunStudyOptions, type StudyOutcome } from "../../run-study.js";
+import type { StudyConfig } from "../../study/types.js";
+import type { LoadedAdapterScorer } from "./study-scorer.js";
+export interface RouteRun {
+    readonly options: InternalRunStudyOptions;
+    present(outcome: StudyOutcome): Promise<void>;
+    /** Handles an error runStudyWith threw, and rethrows any it does not handle. */
+    onRunError?(error: unknown): Promise<void>;
+}
+/**
+ * Plans the study with a route's options, then presents the refusal or the run. `beforeRun` runs
+ * only for a plan that will run: it loads the scorer, or writes its own refusal and returns
+ * undefined, so a refused study never imports the scorer's host code. `afterRun` runs once runStudyWith
+ * has returned or thrown, before presentation, which may hold its own signal handlers (watch's
+ * Observer and tunnel).
+ */
+export declare function runRoute(config: StudyConfig, run: RouteRun, beforeRun?: () => Promise<{
+    scorer?: LoadedAdapterScorer;
+} | undefined>, afterRun?: () => void): Promise<void>;

package/dist/cli/commands/{lab-route-run.js → study-route-run.js}

@@ -1,17 +1,17 @@
-// What a route's CLI setup hands the lab command: the runLab options it chose and how it presents
-// the outcome. runRoute plans the lab once and runs it between the two.
-import { prepareLab } from "../../run-lab.js";
+// What a route's CLI setup hands the run command: the runStudyWith options it chose and how it presents
+// the outcome. runRoute plans the study once and runs it between the two.
+import { prepareStudy } from "../../run-study.js";
 /**
- * Plans the lab with a route's options, then presents the refusal or the run. `beforeRun` runs
+ * Plans the study with a route's options, then presents the refusal or the run. `beforeRun` runs
  * only for a plan that will run: it loads the scorer, or writes its own refusal and returns
- * undefined, so a refused lab never imports the scorer's host code. `afterRun` runs once runLab
+ * undefined, so a refused study never imports the scorer's host code. `afterRun` runs once runStudyWith
  * has returned or thrown, before presentation, which may hold its own signal handlers (watch's
  * Observer and tunnel).
  */
 export async function runRoute(config, run, beforeRun = () => Promise.resolve({}), afterRun = () => undefined) {
     let outcome;
     try {
-        const prepared = await prepareLab(config, run.options);
+        const prepared = await prepareStudy(config, run.options);
         if (prepared.ok) {
             const ready = await beforeRun();
             if (ready === undefined)

package/dist/cli/commands/study-route-scripted.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import type { StudyConfig } from "../../study/types.js";
+import { type CliIo, type StudyCommandOptions } from "../io.js";
+import type { RouteRun } from "./study-route-run.js";
+interface ScriptedRouteArgs {
+    command: Command;
+    io: CliIo;
+    config: StudyConfig;
+    mode: "run" | "watch";
+    options: StudyCommandOptions;
+}
+/**
+ * The scripted route's CLI setup: its open semantics and runStudyWith options, and how it presents the
+ * outcome. Undefined when watch-mode setup has already written its own result.
+ */
+export declare function scriptedRouteRun(args: ScriptedRouteArgs): RouteRun | undefined;
+export {};

package/dist/cli/commands/{lab-route-scripted.js → study-route-scripted.js}

@@ -3,10 +3,10 @@ import { Command } from "commander";
 import { cliAnalysisOptions } from "./analysis-signals.js";
 import { wantsJson, writeResult } from "../io.js";
 import { showObserver } from "../observer-follow.js";
-import { formatScriptedLabHuman } from "./lab-format.js";
-import { observerOpen, resolveRouteShouldOpen, watchFinishedPlan } from "./lab-route-open.js";
+import { formatScriptedStudyHuman } from "./study-format.js";
+import { observerOpen, resolveRouteShouldOpen, watchFinishedPlan } from "./study-route-open.js";
 /**
- * The scripted route's CLI setup: its open semantics and runLab options, and how it presents the
+ * The scripted route's CLI setup: its open semantics and runStudyWith options, and how it presents the
  * outcome. Undefined when watch-mode setup has already written its own result.
  */
 export function scriptedRouteRun(args) {
@@ -33,7 +33,7 @@ export function scriptedRouteRun(args) {
                 throw new Error(`Expected the scripted route, got ${outcome.route}.`);
             }
             const result = outcome.result;
-            writeResult(args.command, args.io, result, formatScriptedLabHuman);
+            writeResult(args.command, args.io, result, formatScriptedStudyHuman);
             args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
             // Watch mode serves the Observer the route rendered through its finished run.
             if (finishedPlan !== undefined && result.ok && result.observer !== undefined) {

package/dist/cli/commands/{lab-route-shared-world.d.ts → study-route-shared-world.d.ts}

@@ -1,13 +1,13 @@
 import { Command } from "commander";
-import type { LabConfig } from "../../lab/types.js";
-import { type CliIo, type LabCommandOptions } from "../io.js";
-import type { RouteRun } from "./lab-route-run.js";
+import type { StudyConfig } from "../../study/types.js";
+import { type CliIo, type StudyCommandOptions } from "../io.js";
+import type { RouteRun } from "./study-route-run.js";
 interface SharedWorldRouteArgs {
     command: Command;
     io: CliIo;
-    config: LabConfig;
+    config: StudyConfig;
     mode: "run" | "watch";
-    options: LabCommandOptions;
+    options: StudyCommandOptions;
 }
 /**
  * The shared-world route's CLI setup: dry run, open and follow semantics, the live Observer server

package/dist/cli/commands/{lab-route-shared-world.js → study-route-shared-world.js}

@@ -1,14 +1,14 @@
 import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
 import { Command } from "commander";
-import { resolveLabDryRun } from "../../lab/plan.js";
+import { resolveStudyDryRun } from "../../study/plan.js";
 import { serveObserver } from "../../observer/render.js";
 import { redactText } from "../../evidence/redaction.js";
 import { cliAnalysisOptions } from "./analysis-signals.js";
 import { parseObserverPort, wantsJson, writeResult, } from "../io.js";
 import { followObserver, showObserver, staticObserverOpen, withObserverServer, } from "../observer-follow.js";
-import { formatConcurrentSharedWorldLabHuman } from "./lab-format.js";
-import { resolveRouteShouldOpen, watchFinishedPlan } from "./lab-route-open.js";
-import { rosterOf } from "../../lab/parse/actors.js";
+import { formatConcurrentSharedWorldStudyHuman } from "./study-format.js";
+import { resolveRouteShouldOpen, watchFinishedPlan } from "./study-route-open.js";
+import { rosterOf } from "../../study/parse/actors.js";
 import { studyResultIdentity } from "../../run/study-result.js";
 /**
  * The shared-world route's CLI setup: dry run, open and follow semantics, the live Observer server
@@ -17,7 +17,7 @@ import { studyResultIdentity } from "../../run/study-result.js";
  */
 export function sharedWorldRouteRun(args) {
     const wantsMachine = wantsJson(args.command);
-    const dryRun = resolveLabDryRun(args.config, args.options.dryRun, true) ?? true;
+    const dryRun = resolveStudyDryRun(args.config, args.options.dryRun, true) ?? true;
     const shouldOpen = resolveRouteShouldOpen({
         optionOpen: args.options.open,
         defaultsOpen: args.config.defaults?.open,
@@ -42,7 +42,7 @@ export function sharedWorldRouteRun(args) {
             warnings: [],
             error: { code: "HUMANISH_SHARED_WORLD_FAILED", message },
         };
-        writeResult(args.command, args.io, result, formatConcurrentSharedWorldLabHuman);
+        writeResult(args.command, args.io, result, formatConcurrentSharedWorldStudyHuman);
         args.io.setExitCode(2);
     };
     if (wantsFollow && port === null) {
@@ -116,7 +116,7 @@ export function sharedWorldRouteRun(args) {
                     ],
                 };
             }
-            writeResult(args.command, args.io, output, formatConcurrentSharedWorldLabHuman);
+            writeResult(args.command, args.io, output, formatConcurrentSharedWorldStudyHuman);
             args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
             if (server && output.observer?.ok) {
                 await followObserver(args.io, output.observer, server);

package/dist/cli/commands/study-route-terminal.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import type { StudyConfig } from "../../study/types.js";
+import { type CliIo, type StudyCommandOptions } from "../io.js";
+import type { RouteRun } from "./study-route-run.js";
+interface TerminalRouteArgs {
+    command: Command;
+    io: CliIo;
+    config: StudyConfig;
+    mode: "run" | "watch";
+    options: StudyCommandOptions;
+}
+/**
+ * The terminal route's CLI setup: its open semantics and runStudyWith options, and how it presents the
+ * outcome. Undefined when watch-mode setup has already written its own result.
+ */
+export declare function terminalRouteRun(args: TerminalRouteArgs): RouteRun | undefined;
+export {};

package/dist/cli/commands/{lab-route-terminal.js → study-route-terminal.js}

@@ -3,10 +3,10 @@ import { Command } from "commander";
 import { cliAnalysisOptions } from "./analysis-signals.js";
 import { wantsJson, writeResult } from "../io.js";
 import { showObserver } from "../observer-follow.js";
-import { formatTerminalLabHuman } from "./lab-format.js";
-import { observerOpen, resolveRouteShouldOpen, watchFinishedPlan } from "./lab-route-open.js";
+import { formatTerminalStudyHuman } from "./study-format.js";
+import { observerOpen, resolveRouteShouldOpen, watchFinishedPlan } from "./study-route-open.js";
 /**
- * The terminal route's CLI setup: its open semantics and runLab options, and how it presents the
+ * The terminal route's CLI setup: its open semantics and runStudyWith options, and how it presents the
  * outcome. Undefined when watch-mode setup has already written its own result.
  */
 export function terminalRouteRun(args) {
@@ -33,7 +33,7 @@ export function terminalRouteRun(args) {
                 throw new Error(`Expected the terminal route, got ${outcome.route}.`);
             }
             const result = outcome.result;
-            writeResult(args.command, args.io, result, formatTerminalLabHuman);
+            writeResult(args.command, args.io, result, formatTerminalStudyHuman);
             args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
             if (finishedPlan !== undefined && result.ok && result.observer !== undefined) {
                 await showObserver({

package/dist/cli/commands/study-run.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { type CliIo, type StudyCommandOptions } from "../io.js";
+export declare function runStudyCommand(args: {
+    command: Command;
+    io: CliIo;
+    study: string;
+    mode: "run" | "watch";
+    options: StudyCommandOptions;
+}): Promise<void>;

package/dist/cli/commands/{lab-run.js → study-run.js}

@@ -2,26 +2,26 @@ import { automaticAnalysisBudget, formatAutomaticAnalysisBudget, } from "../../a
 import { resolve } from "node:path";
 import { Command } from "commander";
 import { deriveRunFacts } from "../telemetry.js";
-import { resolveLabManifest } from "../../lab/discover.js";
+import { resolveStudyManifest } from "../../study/discover.js";
 import { warnAndQueue } from "../deprecations.js";
-import { planLab, resolveLabDryRun } from "../../lab/plan.js";
-import { keyNamesOf } from "../../lab/requirements.js";
-import { routeOf } from "../../lab/plan.js";
-import { computerUseRouteRun } from "./lab-route-computer-use.js";
-import { runRoute } from "./lab-route-run.js";
-import { scriptedRouteRun } from "./lab-route-scripted.js";
-import { sharedWorldRouteRun } from "./lab-route-shared-world.js";
-import { previewRouteRun } from "./lab-route-preview.js";
-import { terminalRouteRun } from "./lab-route-terminal.js";
-import { maybeLoadAdapterScorer } from "./lab-scorer.js";
+import { planStudy, resolveStudyDryRun } from "../../study/plan.js";
+import { keyNamesOf } from "../../study/requirements.js";
+import { routeOf } from "../../study/plan.js";
+import { computerUseRouteRun } from "./study-route-computer-use.js";
+import { runRoute } from "./study-route-run.js";
+import { scriptedRouteRun } from "./study-route-scripted.js";
+import { sharedWorldRouteRun } from "./study-route-shared-world.js";
+import { previewRouteRun } from "./study-route-preview.js";
+import { terminalRouteRun } from "./study-route-terminal.js";
+import { maybeLoadAdapterScorer } from "./study-scorer.js";
 import { discoverCliKeys, formatRunHuman, noteRunFacts, writeResult, } from "../io.js";
 import { watchExposeRequested } from "../observer-follow.js";
 import { beginRunSignalPhase } from "./run-signals.js";
 import { WATCH_SAFE_NOT_APPLICABLE_MESSAGE } from "../../observer/exposure.js";
-export async function runLabCommand(args) {
-    const resolved = await resolveLabManifest(args.options.cwd, args.lab);
+export async function runStudyCommand(args) {
+    const resolved = await resolveStudyManifest(args.options.cwd, args.study);
     if (!resolved.ok) {
-        writeResult(args.command, args.io, resolved, formatLabResolveFailureHuman);
+        writeResult(args.command, args.io, resolved, formatStudyResolveFailureHuman);
         args.io.setExitCode(2);
         return;
     }
@@ -33,14 +33,14 @@ export async function runLabCommand(args) {
     const config = resolved.config;
     // The run's identity: which manifest, where it lives, and whether it is committed, a
     // local overlay, or an explicit path. Resolved once here (the only place that knows all three)
-    // and carried into the run's status record and bundle so the filesystem can answer "which lab
+    // and carried into the run's status record and bundle so the filesystem can answer "which study
     // produced this run" without the old `persona.source = "lab:<id>"` string convention.
-    const lab = { id: config.id, path: resolved.path, origin: resolved.origin };
-    // Named here, once, for every route: a preview or terminal result carries no labId, so the
-    // starter lab `first-run` went unnamed in telemetry while the computer-use ones were named.
-    noteRunFacts(args.command, deriveRunFacts({ labId: config.id }));
+    const study = { id: config.id, path: resolved.path, origin: resolved.origin };
+    // Named here, once, for every route, so the starter study `first-run` is named in telemetry
+    // whatever its route's result carries.
+    noteRunFacts(args.command, deriveRunFacts({ studyId: config.id }));
     const route = routeOf(config);
-    if (route !== "computer-use" && labRerunFlagsRequested(args.options)) {
+    if (route !== "computer-use" && studyRerunFlagsRequested(args.options)) {
         writeUnsupportedRerunFlagsResult(args, route);
         return;
     }
@@ -54,7 +54,7 @@ export async function runLabCommand(args) {
             warnings: [],
             error: {
                 code: "HUMANISH_WATCH_OPTION_CONFLICT",
-                message: `--expose/--tunnel/--oauth stream a live desktop and apply only to computer-use labs; this lab resolved to the ${route} route.`,
+                message: `--expose/--tunnel/--oauth stream a live desktop and apply only to computer-use studies; this study runs on the ${route} route.`,
             },
         };
         writeResult(args.command, args.io, result, formatRunHuman);
@@ -81,8 +81,8 @@ export async function runLabCommand(args) {
     // Only a live run reads provider keys, so a dry run looks none up: no `gh auth token`, no e2b
     // login, overlay or key store. A live run fills every key it finds and prints a line only for
     // the keys its plan reads. This comes after the option refusals above, which read no key, and
-    // before the route's CLI setup and prepareLab, which do.
-    if (resolveLabDryRun(config, args.options.dryRun, true) === false) {
+    // before the route's CLI setup and prepareStudy, which do.
+    if (resolveStudyDryRun(config, args.options.dryRun, true) === false) {
         const announced = announcedKeyNames(config, args.options);
         await discoverCliKeys({
             io: args.io,
@@ -90,15 +90,15 @@ export async function runLabCommand(args) {
             ...(announced === undefined ? {} : { announced }),
         });
     }
-    // The route's CLI setup refuses bad options, runLab's plan refuses bad labs, and the route's local
+    // The route's CLI setup refuses bad options, runStudyWith's plan refuses bad labs, and the route's local
     // checks (keys, runtime auth, subject env, the local agent, caps) refuse this machine, all before
     // the scorer loads, so none imports the scorer's host code. The scripted route's checks and the
     // run-id claim still come after it; the scripted route takes no scorer.
     const routeRun = routeRunFor(route, { ...args, config });
     if (routeRun === undefined)
         return;
-    // Every route's runLab options carry the lab's provenance, from here only.
-    const run = { ...routeRun, options: { ...routeRun.options, lab } };
+    // Every route's runStudyWith options carry the study's provenance, from here only.
+    const run = { ...routeRun, options: { ...routeRun.options, study } };
     // From here a signal marks the run interrupted and reclaims its sandboxes (run-signals.ts).
     const signals = beginRunSignalPhase(args.io);
     try {
@@ -126,12 +126,12 @@ export async function runLabCommand(args) {
             }
             const scorer = scorerLoad.scorer;
             if (scorer) {
-                // Cross-repo guardrail: `humanish lab run` now import()s host JS named in the manifest.
+                // Cross-repo guardrail: `humanish run` import()s host JS named in the manifest.
                 // Surface it so the invoker (who may not be the manifest author) knows executable code ran.
                 args.io.writeErr(`warning: review scorer ${scorer.provenance.ref} (${scorer.provenance.source}) is code that humanish loaded and ran in this process. Review it as you would any code you run.\n`);
             }
             const analysisBudget = automaticAnalysisBudget(config.review?.analysis, route);
-            if (analysisBudget && resolveLabDryRun(config, args.options.dryRun, true) === false) {
+            if (analysisBudget && resolveStudyDryRun(config, args.options.dryRun, true) === false) {
                 args.io.writeErr(`${formatAutomaticAnalysisBudget(analysisBudget)}\n`);
             }
             return scorer === undefined ? {} : { scorer };
@@ -147,12 +147,12 @@ export async function runLabCommand(args) {
 /**
  * The filled keys a live run prints a line for: the ones its plan reads. Count and rerun options
  * change who runs, not which keys. Undefined, so every fill is printed, when a scorer is declared,
- * since its host code may read any key, and when the lab does not plan.
+ * since its host code may read any key, and when the study does not plan.
  */
 function announcedKeyNames(config, options) {
     if (options.scorer !== undefined || config.review?.scorer !== undefined)
         return undefined;
-    const planned = planLab(config, { cwd: options.cwd, dryRun: false });
+    const planned = planStudy(config, { cwd: options.cwd, dryRun: false });
     return planned.ok ? keyNamesOf(planned.planned.plan) : undefined;
 }
 /** The route's CLI setup. Undefined when the setup has already written its own result. */
@@ -170,10 +170,10 @@ function routeRunFor(route, args) {
             return sharedWorldRouteRun(args);
         default:
             // Compile-time exhaustiveness: a future route must be handled here, not silently no-op.
-            throw new Error(`Unhandled lab route: ${String(route)}`);
+            throw new Error(`Unhandled study route: ${String(route)}`);
     }
 }
-function labRerunFlagsRequested(options) {
+function studyRerunFlagsRequested(options) {
     return options.rerunFailedFrom !== undefined || options.participants !== undefined;
 }
 function writeUnsupportedRerunFlagsResult(args, route) {
@@ -184,13 +184,13 @@ function writeUnsupportedRerunFlagsResult(args, route) {
         warnings: [],
         error: {
             code: "HUMANISH_UNSUPPORTED_RERUN_FLAGS",
-            message: `--rerun-failed-from/--participants apply only to computer-use fan-out labs; this lab resolved to the ${route} route.`,
+            message: `--rerun-failed-from/--participants apply only to computer-use studies with more than one participant; this study runs on the ${route} route.`,
         },
     };
     writeResult(args.command, args.io, result, formatRunHuman);
     args.io.setExitCode(2);
 }
-function formatLabResolveFailureHuman(result) {
+function formatStudyResolveFailureHuman(result) {
     const warnings = result.warnings.map((warning) => `warning: ${warning}\n`).join("");
     return { ...(warnings ? { stdout: warnings } : {}), error: result.error };
 }

package/dist/cli/commands/{lab-scorer.d.ts → study-scorer.d.ts}

@@ -1,7 +1,7 @@
-import { type AdapterScorerModule } from "../../lab/adapter-scorer-loader.js";
-import type { LabRoute } from "../../lab/plan.js";
+import { type AdapterScorerModule } from "../../study/adapter-scorer-loader.js";
+import type { StudyRoute } from "../../study/plan.js";
 import type { RunScorerProvenance } from "../../run/bundle.js";
-import type { LabConfig } from "../../lab/types.js";
+import type { StudyConfig } from "../../study/types.js";
 import type { RunResult } from "../../run/results.js";
 /** A config-declared scorer that resolved + loaded fail-closed, ready to thread into a backend. */
 export interface LoadedAdapterScorer {
@@ -16,8 +16,8 @@ export interface LoadedAdapterScorer {
  */
 export declare function maybeLoadAdapterScorer(args: {
     cwd: string;
-    config: LabConfig;
-    route: LabRoute;
+    config: StudyConfig;
+    route: StudyRoute;
     flag: string | undefined;
 }): Promise<{
     ok: true;

package/dist/cli/commands/{lab-scorer.js → study-scorer.js}

@@ -1,4 +1,4 @@
-import { loadAdapterScorer } from "../../lab/adapter-scorer-loader.js";
+import { loadAdapterScorer } from "../../study/adapter-scorer-loader.js";
 /**
  * Resolve `review.scorer.ref` (or the `--scorer` override) to a loaded adopter scorer, fail-closed
  * (typed error) pre-spend. Precedence: CLI `--scorer` overrides the manifest; `source` records which