humanish 0.108.0 → 0.109.0

package/dist/cli/commands/study.js

@@ -1,10 +1,8 @@
 import { formatAutomaticAnalysisBudget } from "../../analysis/automatic-config.js";
 import { resolve } from "node:path";
 import { Command, Option } from "commander";
-import { inspectLabManifest, listLabManifests } from "../../lab/discover.js";
-import { runLabPreflight, } from "../../lab/preflight.js";
-import { addRunOptions, handleRun } from "./run-command.js";
-import { deprecationMessage, warnAndQueue } from "../deprecations.js";
+import { inspectStudyManifest, listStudyManifests } from "../../study/discover.js";
+import { runStudyPreflight, } from "../../study/preflight.js";
 import { applyEnvFileOption, CWD_OPTION_DESCRIPTION, ENV_FILE_OPTION_DESCRIPTION, JSON_OPTION_DESCRIPTION, parsePositiveInteger, writeResult, humanError, } from "../io.js";
 export function registerStudyCommands(parent, io) {
     const study = parent
@@ -13,51 +11,23 @@ export function registerStudyCommands(parent, io) {
     listCommand(study.command("list"), io);
     showCommand(study.command("show"), io);
     checkCommand(study.command("check"), io);
-    // Removed in 0.109.0: the `lab` group stays one minor, hidden. Its list, inspect and preflight
-    // run as study list, show and check, and `lab run` runs as `run`, each after a warning.
-    const lab = parent
-        .command("lab", { hidden: true })
-        .description("Deprecated: use humanish study.");
-    listCommand(lab.command("list"), io, "humanish study list");
-    showCommand(lab.command("inspect"), io, "humanish study show <study>");
-    checkCommand(lab.command("preflight"), io, "humanish study check <study>");
-    addRunOptions(lab.command("run", { hidden: true }).argument("<study>", "Study id or .yaml path.")).action((name, options, command) => {
-        warnOldCommand(command, io, "humanish run <study>");
-        return handleRun(io, name, options, command);
-    });
-}
-/** The warning for a `lab` subcommand, naming its replacement. */
-function warnOldCommand(command, io, replacement) {
-    warnAndQueue(command, io, deprecationMessage(`humanish lab ${command.name()}`, replacement));
 }
-function listCommand(command, io, replacement) {
+function listCommand(command, io) {
     command
         .description("List the studies in this project, committed and local.")
         .option("--cwd <path>", CWD_OPTION_DESCRIPTION, ".")
         .option("--json", JSON_OPTION_DESCRIPTION)
-        .action((options, command) => {
-        if (replacement !== undefined)
-            warnOldCommand(command, io, replacement);
-        return handleStudyList(io, options, command);
-    });
-    if (replacement !== undefined)
-        command.description(`Deprecated: use ${replacement}.`);
+        .action((options, command) => handleStudyList(io, options, command));
 }
-function showCommand(command, io, replacement) {
+function showCommand(command, io) {
     command
         .argument("<study>", "Study id or .yaml path.")
         .description("Show a study's parsed file and its warnings without running it.")
         .option("--cwd <path>", CWD_OPTION_DESCRIPTION, ".")
         .option("--json", JSON_OPTION_DESCRIPTION)
-        .action((name, options, command) => {
-        if (replacement !== undefined)
-            warnOldCommand(command, io, replacement);
-        return handleStudyShow(io, name, options, command);
-    });
-    if (replacement !== undefined)
-        command.description(`Deprecated: use ${replacement}.`);
+        .action((name, options, command) => handleStudyShow(io, name, options, command));
 }
-function checkCommand(command, io, replacement) {
+function checkCommand(command, io) {
     command
         .argument("<study>", "Study id or .yaml path.")
         .description("Check the study file and, with --reachability, its named endpoints. humanish doctor --study <study> checks this machine.")
@@ -68,21 +38,15 @@ function checkCommand(command, io, replacement) {
         .option("--timeout-ms <ms>", "Target reachability timeout.", String(30_000))
         .option("--env-file <path>", ENV_FILE_OPTION_DESCRIPTION)
         .option("--json", JSON_OPTION_DESCRIPTION)
-        .action((name, options, command) => {
-        if (replacement !== undefined)
-            warnOldCommand(command, io, replacement);
-        return handleStudyCheck(io, name, options, command);
-    });
-    if (replacement !== undefined)
-        command.description(`Deprecated: use ${replacement}.`);
+        .action((name, options, command) => handleStudyCheck(io, name, options, command));
 }
 async function handleStudyList(io, options, command) {
-    const result = await listLabManifests(options.cwd);
+    const result = await listStudyManifests(options.cwd);
     writeResult(command, io, result, formatStudyListHuman);
     io.setExitCode(0);
 }
 async function handleStudyShow(io, name, options, command) {
-    const result = await inspectLabManifest(options.cwd, name);
+    const result = await inspectStudyManifest(options.cwd, name);
     writeResult(command, io, result, formatStudyShowHuman);
     io.setExitCode(result.ok ? 0 : 2);
 }
@@ -117,9 +81,9 @@ async function handleStudyCheck(io, name, options, command) {
         io.setExitCode(2);
         return;
     }
-    const result = await runLabPreflight({
+    const result = await runStudyPreflight({
         cwd: options.cwd,
-        lab: name,
+        study: name,
         reachability: options.reachability,
         timeoutMs,
     });
@@ -136,7 +100,7 @@ function formatStudyListHuman(result) {
     }
     return ([
         "humanish studies",
-        ...result.studies.map((lab) => `- ${lab.id} ${lab.source} ${lab.origin} ${lab.path}${lab.title ? ` (${lab.title})` : ""}${lab.error ? `\n  error: ${lab.error}` : ""}`),
+        ...result.studies.map((study) => `- ${study.id} ${study.source} ${study.origin} ${study.path}${study.title ? ` (${study.title})` : ""}`),
         ...result.warnings.map((warning) => `warning: ${warning}`),
     ].join("\n") + "\n");
 }

package/dist/cli/commands/tui.js

@@ -4,15 +4,15 @@ import { Command } from "commander";
 import { setUserKey } from "../../keys/key-resolution.js";
 import { saveCommsConnection } from "../../comms/connections.js";
 import { readCommsSetup } from "../../comms/setup.js";
-import { checkCommsConnection, configureCommsLab, } from "../../comms/setup.js";
+import { checkCommsConnection, configureCommsStudy, } from "../../comms/setup.js";
 import { inspectCommsRecovery, recoverCommsReceiving } from "../../comms/receiving-recovery.js";
 import { resolveReceivingConnection } from "../../comms/receiving-runtime.js";
 import { promptSecret } from "../secret-prompt.js";
-import { runInit } from "../../lab/init.js";
-import { listLabManifests } from "../../lab/discover.js";
+import { runInit } from "../../study/init.js";
+import { listStudyManifests } from "../../study/discover.js";
 import { reclaimRunSandboxes } from "../../run/reclaim.js";
 import { RunIndexCache, readRunIndex } from "../../run/run-index.js";
-import { readLabSummary } from "../../lab/summary.js";
+import { readStudySummary } from "../../study/summary.js";
 import { readProjectState } from "../../tui/project.js";
 import { createTuiObserverSession, stopRun, TUI_ACTION_SCHEMA } from "../../tui/actions.js";
 import { readRunDetail } from "../../run/detail.js";
@@ -128,7 +128,7 @@ function checkTuiSession(runtime, force) {
             ok: false,
             error: {
                 code: "HUMANISH_TUI_REQUIRES_TTY",
-                message: "humanish tui needs an interactive terminal. For scripted or agent use, `humanish runs --json` lists the same runs and `humanish run <lab> --json` starts one.",
+                message: "humanish tui needs an interactive terminal. For scripted or agent use, `humanish runs --json` lists the same runs and `humanish run <study> --json` starts one.",
             },
         };
     }
@@ -210,13 +210,13 @@ function tuiCapabilities(session) {
                 });
                 return session.connectionCheck;
             },
-            labs: async () => (await listLabManifests(cwd)).studies.map((lab) => ({
-                title: lab.title ?? lab.id,
-                path: lab.path,
+            studies: async () => (await listStudyManifests(cwd)).studies.map((study) => ({
+                title: study.title ?? study.id,
+                path: study.path,
             })),
-            configure: (lab, apply, planToken) => configureCommsLab({
+            configure: (study, apply, planToken) => configureCommsStudy({
                 cwd,
-                lab,
+                study,
                 connection: "agentmail",
                 apply,
                 ...(planToken ? { planToken } : {}),
@@ -244,11 +244,11 @@ function tuiCapabilities(session) {
         // One cache for the life of the surface: it refreshes on a cadence, and re-walking every
         // run tree each tick is the cost this index exists to avoid.
         readRunIndex: (target, readOptions) => readRunIndex(target, { ...readOptions, cache: runIndexCache }),
-        listLabs: listLabManifests,
+        listStudies: listStudyManifests,
         startRun: (launchOptions) => launchRun({ ...launchOptions, env: sessionEnv }),
         readLaunchLog: readLaunchLogTail,
         readRunDetail,
-        readLabSummary: (target, lab, readOptions) => readLabSummary(target, lab, { ...readOptions, env: sessionEnv }),
+        readStudySummary: (target, study, readOptions) => readStudySummary(target, study, { ...readOptions, env: sessionEnv }),
         readProjectState,
         openObserver: (target, observerPath) => observerSession.open(target, observerPath),
         reclaimRun: (target, runId) => reclaimRunSandboxes(target, runId),

package/dist/cli/commands/watch.js

@@ -1,10 +1,9 @@
 import { Command, Option } from "commander";
-import { renderObserver, serveObserver } from "../../observer/render.js";
+import { serveObserver } from "../../observer/render.js";
 import { WATCH_SAFE_NOT_APPLICABLE_MESSAGE } from "../../observer/exposure.js";
 import { runDryRun } from "../../run/dry-run.js";
-import { runLabCommand } from "./lab-run.js";
+import { runStudyCommand } from "./study-run.js";
 import { addRunOptions, studyOnlyFlags } from "./run-command.js";
-import { deprecationMessage, oldStudyOption, studyOptionValue, warnAndQueue, } from "../deprecations.js";
 import { applyEnvFileOption, collectRepeated, formatRunHuman, parseObserverPort, parsePositiveInteger, wantsJson, writeResult, } from "../io.js";
 import { followObserver, formatObserverHuman, watchExposeRequested } from "../observer-follow.js";
 export function registerWatchCommand(parent, io) {
@@ -14,10 +13,7 @@ export function registerWatchCommand(parent, io) {
         .argument("[study]", "Study id or .yaml path to run and observe.")
         .description("Run a study, open its Observer and keep the shell attached.")
         .summary("Run a study and follow it in the Observer.")
-        .option("--study <id-or-path>", "Study id or .yaml path, in place of the argument.")
-        .addOption(oldStudyOption("id-or-path"))
-        // Removed in 0.109.0: watch --run stays one minor, hidden; observe --run shows a saved run.
-        .addOption(new Option("--run <id>", "Deprecated: use humanish observe --run <id>.").hideHelp()))
+        .option("--study <id-or-path>", "Study id or .yaml path, in place of the argument."))
         .option("--expose", "Computer-use studies only: share the live run through an authenticated tunnel, to watch from a phone. Requires --oauth or --public-url.")
         .addOption(new Option("--tunnel <provider>", "Spawn the external tunnel binary against the loopback port.").choices(["ngrok"]))
         .option("--tunnel-domain <domain>", "Reserved domain passed to ngrok as --url (e.g. observer.example.com). Requires --tunnel.")
@@ -51,10 +47,7 @@ export function registerWatchCommand(parent, io) {
 }
 async function handleWatch(io, named, parsed, command) {
     const options = parsed;
-    if (options.run !== undefined) {
-        warnAndQueue(command, io, deprecationMessage("humanish watch --run", "humanish observe --run <id>"));
-    }
-    const option = studyOptionValue(command, io, options);
+    const option = options.study;
     const study = option ?? named;
     if (option !== undefined && named !== undefined) {
         refuseWatch(command, io, options.cwd, {
@@ -68,7 +61,7 @@ async function handleWatch(io, named, parsed, command) {
         cwd: options.cwd,
         envFile: options.envFile,
         io,
-        // runLabCommand discovers keys for a live lab; a preview or a saved run needs none.
+        // runStudyCommand discovers keys for a live study; a preview run needs none.
         discoverKeys: false,
     }))) {
         return;
@@ -85,9 +78,9 @@ async function handleWatch(io, named, parsed, command) {
         });
         return;
     }
-    // Exposure is only meaningful for a live computer-use study run (it serves the live desktop). The
-    // non-lab watch path (existing evidence, or a fresh synthetic run) has no live desktop to
-    // stream, so exposure flags there are refused rather than silently ignored; use `observe --all`.
+    // Exposure is only meaningful for a live computer-use study run (it serves the live desktop). A
+    // watch without a study starts a fresh synthetic run with no live desktop to stream, so exposure
+    // flags there are refused rather than silently ignored; use `observe --all`.
     if (watchExposeRequested(options)) {
         refuseWatch(command, io, options.cwd, {
             code: "HUMANISH_WATCH_OPTION_CONFLICT",
@@ -103,7 +96,7 @@ async function handleWatch(io, named, parsed, command) {
         });
         return;
     }
-    const target = resolveWatchTarget(options, command);
+    const target = resolveWatchTarget(options);
     if ("code" in target) {
         refuseWatch(command, io, options.cwd, target);
         return;
@@ -136,24 +129,13 @@ function refuseWatch(command, io, cwd, refusal) {
     writeResult(command, io, result, formatRunHuman);
     io.setExitCode(2);
 }
-/** A study argument starts that study under watch; `--run` would name other evidence. */
+/** A study argument starts that study under watch. */
 async function watchStudy(io, command, study, options) {
-    if (options.run !== undefined) {
-        refuseWatch(command, io, options.cwd, {
-            code: "HUMANISH_WATCH_OPTION_CONFLICT",
-            message: "Use either a study to start evidence or --run to watch existing evidence, not both.",
-        });
-        return;
-    }
-    // Forwarded wholesale, as `run` forwards its options, so a run flag reaches the lab either way.
-    await runLabCommand({ command, io, lab: study, mode: "watch", options });
+    // Forwarded wholesale, as `run` forwards its options, so a run flag reaches the run either way.
+    await runStudyCommand({ command, io, study, mode: "watch", options });
 }
-/** Without a study, watch shows existing evidence (`--run`) or a fresh synthetic run (`--count`). */
-function resolveWatchTarget(options, command) {
-    const runOptionSource = typeof command.getOptionValueSource === "function"
-        ? command.getOptionValueSource("run")
-        : undefined;
-    const runWasOmitted = runOptionSource === undefined || runOptionSource === "default";
+/** Without a study, watch starts a fresh synthetic run of `--count` participants, 4 by default. */
+function resolveWatchTarget(options) {
     const participantCount = options.count === undefined ? undefined : parsePositiveInteger(options.count);
     const port = parseObserverPort(options.port);
     if (participantCount === null) {
@@ -162,48 +144,31 @@ function resolveWatchTarget(options, command) {
             message: "--count must be a positive integer.",
         };
     }
-    if (!runWasOmitted && participantCount !== undefined) {
-        return {
-            code: "HUMANISH_WATCH_OPTION_CONFLICT",
-            message: "Use either --run to watch existing evidence or --count to start a fresh run, not both.",
-        };
-    }
-    if (!runWasOmitted && options.runId !== undefined) {
-        return {
-            code: "HUMANISH_WATCH_OPTION_CONFLICT",
-            message: "--run-id only applies to fresh watch runs; remove --run or remove --run-id.",
-        };
-    }
     if (port === null) {
         return {
             code: "HUMANISH_INVALID_PORT",
             message: "--port must be an integer between 0 and 65535.",
         };
     }
-    return { requestedParticipantCount: participantCount ?? (runWasOmitted ? 4 : undefined), port };
+    return { requestedParticipantCount: participantCount ?? 4, port };
 }
-/** Render the evidence to show; undefined when a fresh run failed and its result was written. */
+/** Render the fresh run; undefined when it failed and its result was written. */
 async function renderWatchEvidence(io, command, options, requestedParticipantCount, staticOpen) {
-    if (requestedParticipantCount !== undefined && requestedParticipantCount !== null) {
-        // A fresh run renders through its finished run, so the page shown is the run just
-        // written, never a directory swapped in under its id.
-        const runResult = await runDryRun({
-            cwd: options.cwd,
-            dryRun: true,
-            participantCount: requestedParticipantCount,
-            ...(options.runId === undefined ? {} : { runId: options.runId }),
-            observer: { open: staticOpen },
-        });
-        if (!runResult.ok || runResult.observer === undefined) {
-            writeResult(command, io, runResult, formatRunHuman);
-            io.setExitCode(2);
-            return undefined;
-        }
-        return runResult.observer;
-    }
-    return renderObserver(options.cwd, options.run ?? "latest", {
-        open: staticOpen,
+    // A fresh run renders through its finished run, so the page shown is the run just written,
+    // never a directory swapped in under its id.
+    const runResult = await runDryRun({
+        cwd: options.cwd,
+        dryRun: true,
+        participantCount: requestedParticipantCount,
+        ...(options.runId === undefined ? {} : { runId: options.runId }),
+        observer: { open: staticOpen },
     });
+    if (!runResult.ok || runResult.observer === undefined) {
+        writeResult(command, io, runResult, formatRunHuman);
+        io.setExitCode(2);
+        return undefined;
+    }
+    return runResult.observer;
 }
 /** Write the result, then keep a live server attached when following. */
 async function reportWatch(io, command, rendered, serve) {

package/dist/cli/deprecations.d.ts

@@ -1,18 +1,6 @@
-import { Option, type Command } from "commander";
+import type { Command } from "commander";
 import type { CliIo } from "./io.js";
-/** `<old> is deprecated and is removed in the next minor. Use <replacement>.` */
-export declare function deprecationMessage(old: string, replacement: string): string;
 /** Print `warning: <message>` on stderr, and queue the message for the command's JSON result. */
 export declare function warnAndQueue(command: Command, io: CliIo, message: string): void;
 /** `output` with the command's queued warnings at the front of its `warnings`. */
 export declare function withQueuedWarnings<T>(command: Command, output: T): T;
-/**
- * The 0.107 spelling of `--study`, hidden for one minor. Commander refuses it together with
- * `--study`. Read the value with studyOptionValue.
- */
-export declare function oldStudyOption(valueName: string): Option;
-/** The `--study` value, or the `--lab` value with its deprecation warning. */
-export declare function studyOptionValue(command: Command, io: CliIo, options: {
-    study?: string | undefined;
-    lab?: string | undefined;
-}): string | undefined;

package/dist/cli/deprecations.js

@@ -1,12 +1,4 @@
-// A warning a command prints, such as a deprecated spelling or a study file 0.109 stops reading,
-// goes to stderr when it happens and into the `warnings` array of the command's JSON result, so a
-// caller that reads only stdout sees it too. writeResult adds the queued warnings.
-import { Option } from "commander";
 const queued = new WeakMap();
-/** `<old> is deprecated and is removed in the next minor. Use <replacement>.` */
-export function deprecationMessage(old, replacement) {
-    return `${old} is deprecated and is removed in the next minor. Use ${replacement}.`;
-}
 /** Print `warning: <message>` on stderr, and queue the message for the command's JSON result. */
 export function warnAndQueue(command, io, message) {
     io.writeErr(`warning: ${message}\n`);
@@ -24,25 +16,3 @@ export function withQueuedWarnings(command, output) {
         return output;
     return { ...output, warnings: [...messages, ...(existing ?? [])] };
 }
-/**
- * The 0.107 spelling of `--study`, hidden for one minor. Commander refuses it together with
- * `--study`. Read the value with studyOptionValue.
- */
-export function oldStudyOption(valueName) {
-    return new Option(`--lab <${valueName}>`).hideHelp().conflicts("study");
-}
-/** The `--study` value, or the `--lab` value with its deprecation warning. */
-export function studyOptionValue(command, io, options) {
-    if (options.lab === undefined)
-        return options.study;
-    const path = commandPath(command);
-    warnAndQueue(command, io, deprecationMessage(`humanish ${path} --lab`, `humanish ${path} --study <study>`));
-    return options.lab;
-}
-/** The command's words after `humanish`, such as `comms check`. */
-function commandPath(command) {
-    const words = [];
-    for (let at = command; at?.parent; at = at.parent)
-        words.unshift(at.name());
-    return words.join(" ");
-}

package/dist/cli/doctor.d.ts

@@ -1,6 +1,6 @@
 import { type KeyResolutionDeps } from "../keys/key-resolution.js";
 import { type DetectLocalAgentsOptions } from "../actors/local-agent/cli.js";
-import { type LabSetupCheckArgs } from "../lab/doctor.js";
+import { type StudySetupCheckArgs } from "../study/doctor.js";
 declare const DOCTOR_SCHEMA = "humanish.doctor-result.v1";
 /**
  * A row's verdict, as the human output prints it. A "note" is advisory: it never fails the run, so
@@ -41,12 +41,12 @@ export type DoctorCheckDraft = Omit<DoctorResult["checks"][number], "status"> &
     status?: "note";
 };
 export declare function doctor(cwdInput: string, options?: {
-    lab?: string;
+    study?: string;
     env?: NodeJS.ProcessEnv;
     localAgents?: DetectLocalAgentsOptions;
     /** Where the key probe looks for vendor stores; tests point it at a temp home. */
     keyDeps?: KeyResolutionDeps;
     /** The hosted Codex participant's operator handshake; tests replace it. */
-    codexParticipantReadiness?: LabSetupCheckArgs["codexParticipantReadiness"];
+    codexParticipantReadiness?: StudySetupCheckArgs["codexParticipantReadiness"];
 }): Promise<DoctorResult>;
 export {};

package/dist/cli/doctor.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { probeKeySources, } from "../keys/key-resolution.js";
 import { nodeSupportsTui, terminalSurfaceMessage, TUI_BUNDLE_URL } from "../tui/contract.js";
 import { detectLocalAgents, localAgentDoctorMessage, NO_LOCAL_AGENT_MESSAGE, } from "../actors/local-agent/cli.js";
-import { labSetupChecks, studiesByRequiredKey } from "../lab/doctor.js";
+import { studySetupChecks, studiesByRequiredKey, } from "../study/doctor.js";
 import { prepareSelectedOutputDirectory, } from "../run/contained-output.js";
 import { implicitProjectDirectoryExists, readImplicitProjectFile, validateCwd, } from "../run/project.js";
 const DOCTOR_SCHEMA = "humanish.doctor-result.v1";
@@ -65,12 +65,12 @@ export async function doctor(cwdInput, options = {}) {
     }
     const env = options.env ?? process.env;
     const agents = await detectLocalAgents({ ...options.localAgents, env });
-    const { probes, receivingKey } = await probeDoctorKeys(cwd, env, options.lab, options.keyDeps);
+    const { probes, receivingKey } = await probeDoctorKeys(cwd, env, options.study, options.keyDeps);
     const keyPresent = (name) => probes.some((probe) => probe.name === name && probe.source !== null);
-    const setup = options.lab
-        ? await labSetupChecks({
+    const setup = options.study
+        ? await studySetupChecks({
             cwd,
-            lab: options.lab,
+            study: options.study,
             env,
             agents,
             keyPresent,
@@ -79,7 +79,7 @@ export async function doctor(cwdInput, options = {}) {
                 : { codexParticipantReadiness: options.codexParticipantReadiness }),
         })
         : undefined;
-    // Without --lab, each key row names the labs that need it instead of failing.
+    // Without --study, each key row names the studies that need it instead of failing.
     const keyUsers = setup ? undefined : await studiesByRequiredKey(cwd, keyPresent);
     const checks = [
         ...(await projectChecks(projectRoot)),
@@ -195,7 +195,7 @@ async function desktopSdkCheck(setup) {
     });
     const version = present ? await installedDesktopSdkVersion() : undefined;
     const advisory = desktopSdkAdvisory(version);
-    // Without --lab nothing selects a desktop route yet, so an absent SDK is advisory.
+    // Without --study nothing selects a desktop route yet, so an absent SDK is advisory.
     const advisoryOnly = !present && setup === undefined;
     return {
         name: "e2b desktop sdk",
@@ -236,13 +236,13 @@ function terminalSurfaceCheck() {
         }),
     };
 }
-/** Probes the live-run keys, plus the receiving-email key a real-comms lab names. */
-async function probeDoctorKeys(cwd, env, lab, keyDeps) {
+/** Probes the live-run keys, plus the receiving-email key a real-comms study names. */
+async function probeDoctorKeys(cwd, env, study, keyDeps) {
     const keyNames = new Set(["OPENAI_API_KEY", "E2B_API_KEY", "GH_TOKEN", "CODEX_API_KEY"]);
     let receivingKey = null;
-    if (lab) {
-        const { resolveLabManifest } = await import("../lab/discover.js");
-        const resolved = await resolveLabManifest(cwd, lab);
+    if (study) {
+        const { resolveStudyManifest } = await import("../study/discover.js");
+        const resolved = await resolveStudyManifest(cwd, study);
         if (resolved.ok && resolved.config.comms?.email?.kind === "real") {
             const { receivingRequiredKey } = await import("../comms/setup.js");
             receivingKey = await receivingRequiredKey(cwd, resolved.config.comms.email.connection);
@@ -284,7 +284,7 @@ function studyList(studies) {
  * chain a live command resolves (env/--env-file, project overlay, vendor stores, the
  * humanish user store). Values never appear; sources and fill commands do.
  *
- * With --lab, a key the selected route requires fails when missing. Without it, `keyUsers` maps
+ * With --study, a key the selected route requires fails when missing. Without it, `keyUsers` maps
  * each key to the project's labs that need it, and a key row never fails: a missing key one of
  * them needs is a note.
  */
@@ -303,12 +303,12 @@ function keyChecks(probes, receivingKey, setup, keyUsers) {
                 ...(present || usedBy === undefined ? {} : { status: "note" }),
                 message: present
                     ? `supplied by ${probe.source}; presence only, validity not tested${usedBy ? `; ${usedBy}` : ""}`
-                    : `missing; ${usedBy ?? "not used by any lab in this project"}; ${hint}`,
+                    : `missing; ${usedBy ?? "not used by any study in this project"}; ${hint}`,
             };
         }
         // GH_TOKEN is needed only for private clone subjects, so its absence is informational.
         const required = setup.keys.includes(probe.name);
-        // A key the lab is known not to read says so, so a present but unused key does not read as
+        // A key the study is known not to read says so, so a present but unused key does not read as
         // one the run will use.
         const unused = setup.reads !== undefined && !setup.reads.has(probe.name);
         return {
@@ -316,7 +316,7 @@ function keyChecks(probes, receivingKey, setup, keyUsers) {
             ok: present || !required,
             message: present
                 ? unused
-                    ? `present (${probe.source}), not used by this lab`
+                    ? `present (${probe.source}), not used by this study`
                     : `supplied by ${probe.source}; presence only, validity not tested`
                 : required
                     ? `missing from every source; ${hint}`

package/dist/cli/first-run-path.d.ts

@@ -30,17 +30,17 @@ export interface FirstRunEnvironment {
 }
 export type FirstRunActor = "openai-computer-use" | "local-agent";
 /**
- * Which brain the starter live lab should be written for. A machine with a signed-in coding agent
- * and no provider key can still do a real live run; writing the lab for the credential the
+ * Which brain the starter live study should be written for. A machine with a signed-in coding agent
+ * and no provider key can still do a real live run; writing the study for the credential the
  * operator doesn't have is how a starter file becomes homework.
  */
 export declare function starterActorFor(env: FirstRunEnvironment): FirstRunActor;
 /**
- * The `localAgent` a local-agent starter lab names. Left out, the lab would default to Codex and
+ * The `localAgent` a local-agent starter study names. Left out, the study would default to Codex and
  * refuse to run on a machine where only Claude Code is signed in.
  */
 export declare function starterLocalAgentFor(env: FirstRunEnvironment): LocalAgentId | undefined;
-/** Hosts the local browser lab runs on: Linux x64 and Apple Silicon Macs. */
+/** Hosts that run local browser studies: Linux x64 and Apple Silicon Macs. */
 export declare function supportsLocalBrowser(platform: NodeJS.Platform | undefined, arch: string | undefined): boolean;
 export interface FirstRunStep {
     /** The exact command to run. */

package/dist/cli/first-run-path.js

@@ -1,6 +1,6 @@
 // What a person, or the coding agent setting humanish up for them, should do next.
 //
-// Why: `humanish init` wrote twenty files and stopped. The only lab that could actually run was a
+// Why: `humanish init` wrote twenty files and stopped. The only study that could actually run was a
 // $0 dry run; the two live ones were templates with `your-org/your-app` in them, so the first live
 // run a newcomer tried could not succeed no matter what credentials they had. Three independent
 // sources reached the same place: a participant in our own TUI study walked to the Start row and
@@ -13,8 +13,8 @@
 // command, and names the one that will actually work on this machine, because a next step that
 // fails is worse than none.
 /**
- * Which brain the starter live lab should be written for. A machine with a signed-in coding agent
- * and no provider key can still do a real live run; writing the lab for the credential the
+ * Which brain the starter live study should be written for. A machine with a signed-in coding agent
+ * and no provider key can still do a real live run; writing the study for the credential the
  * operator doesn't have is how a starter file becomes homework.
  */
 export function starterActorFor(env) {
@@ -27,7 +27,7 @@ function preferredAgent(env) {
     return env.localAgents.find((agent) => agent.id === "codex") ?? env.localAgents[0];
 }
 /**
- * The `localAgent` a local-agent starter lab names. Left out, the lab would default to Codex and
+ * The `localAgent` a local-agent starter study names. Left out, the study would default to Codex and
  * refuse to run on a machine where only Claude Code is signed in.
  */
 export function starterLocalAgentFor(env) {
@@ -38,7 +38,7 @@ export function starterLocalAgentFor(env) {
  * a dev-dependency install puts no \`humanish\` on \`PATH\`, so a bare name can reach a stale global one.
  */
 const HUMANISH = "npx humanish";
-/** Hosts the local browser lab runs on: Linux x64 and Apple Silicon Macs. */
+/** Hosts that run local browser studies: Linux x64 and Apple Silicon Macs. */
 export function supportsLocalBrowser(platform, arch) {
     return (platform === "linux" && arch === "x64") || (platform === "darwin" && arch === "arm64");
 }
@@ -99,7 +99,7 @@ export function firstRunSteps(env) {
     }
     steps.push({
         command: `${HUMANISH} keys set openai`,
-        why: "openai-computer-use needs an API key; to use a Codex or Claude Code login instead, sign in and change the lab to actors[0].type: local-agent" +
+        why: "openai-computer-use needs an API key; to use a Codex or Claude Code login instead, sign in and change the study to actors[0].type: local-agent" +
             localUnavailable,
     });
     return steps;
@@ -144,7 +144,7 @@ export function agentsSection() {
         "  bundles into an issue; `humanish feedback issue` writes a redacted, share-safe draft.",
         "- `humanish tui` is for people and refuses to run in an agent session. Use the `--json`",
         "  commands above instead, and tell the person you are working for that `humanish tui` exists.",
-        "- A live run spends money. `execution.caps.maxUsd` in each lab caps estimated model spend: the run",
+        "- A live run spends money. `execution.caps.maxUsd` in each study caps estimated model spend: the run",
         "  stops before its next request once the estimate passes it, so the last request can go over, and",
         "  hosted desktop time is billed on top. Do not raise it without asking the person you are working for.",
         "",

package/dist/cli/io.d.ts

@@ -17,7 +17,7 @@ export declare const ENV_FILE_OPTION_DESCRIPTION = "Load unset variables from th
 export declare const PORT_OPTION_DESCRIPTION = "Port to listen on at 127.0.0.1.";
 /** `--port` for a loopback server whose default, 0, lets the OS pick a free port. */
 export declare function freePortOption(): Option;
-export interface LabCommandOptions {
+export interface StudyCommandOptions {
     count?: string | undefined;
     cwd: string;
     detach?: boolean | undefined;
@@ -50,7 +50,7 @@ export declare function applyEnvFileOption(args: {
     io: CliIo;
     env?: NodeJS.ProcessEnv;
     onDiscovered?: (names: string[]) => void;
-    /** False for the lab-running commands, which discover only once the lab resolves to live. */
+    /** False for the study-running commands, which discover only once the study resolves to live. */
     discoverKeys?: boolean;
 }): Promise<boolean>;
 /**
@@ -67,7 +67,7 @@ export declare function discoverCliKeys(args: {
     /** Announce only the fills of these names; every key is still filled. Undefined announces all. */
     announced?: ReadonlySet<string>;
 }): Promise<void>;
-export declare function parseLabCount(value: string | undefined, fallback: number): number | null;
+export declare function parseStudyCount(value: string | undefined, fallback: number): number | null;
 export declare function parseParticipantIds(value: string | undefined): string[];
 /** An error as a result carries it. A result with only a message, such as keys or comms, has no code. */
 export interface CliError {

package/dist/cli/io.js

@@ -106,7 +106,7 @@ export async function discoverCliKeys(args) {
         // Discovery must never break a command; a rung that fails to read is a miss, not an error.
     }
 }
-export function parseLabCount(value, fallback) {
+export function parseStudyCount(value, fallback) {
     return value === undefined ? fallback : parsePositiveInteger(value);
 }
 export function parseParticipantIds(value) {
@@ -126,7 +126,7 @@ export function parseParticipantIds(value) {
 }
 /**
  * The command to run next, by code. A code is listed only when its messages do not already name a
- * command: the run-not-found and lab-less run messages do.
+ * command: the run-not-found and missing-study messages do.
  */
 const NEXT_COMMAND = {
     HUMANISH_STUDY_NOT_FOUND: "humanish study list",