humanish 0.108.0 → 0.109.1

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",

package/dist/cli/observer-follow.d.ts

@@ -1,7 +1,7 @@
 import { Command } from "commander";
 import type { ObserverResult, ObserverServer } from "../observer/render.js";
 import type { ExposureRequest } from "../observer/exposure.js";
-import { type CliIo, type LabCommandOptions, type HumanOutput } from "./io.js";
+import { type CliIo, type StudyCommandOptions, type HumanOutput } from "./io.js";
 /** How a command shows an Observer, decided before the run it shows starts. */
 export interface ObserverPlan {
     port: number;
@@ -52,5 +52,5 @@ export declare function watchExposeRequested(o: {
     allowDomain?: string[] | undefined;
     publicUrl?: string | undefined;
 }): boolean;
-export declare function exposureRequestFromOptions(options: LabCommandOptions): ExposureRequest;
+export declare function exposureRequestFromOptions(options: StudyCommandOptions): ExposureRequest;
 export {};

package/dist/cli/observer-follow.js

@@ -133,7 +133,7 @@ export function exitCodeForSignal(signal) {
     }
 }
 // True when any tunnel-edge exposure flag is present (not --safe, which is an orthogonal filter).
-// Callers refuse exposure with it on the non-lab watch path and on non-computer-use routes, where
+// Callers refuse exposure with it on the watch path without a study and on non-computer-use routes, where
 // there is no live desktop to stream.
 export function watchExposeRequested(o) {
     return (o.expose === true ||
@@ -144,7 +144,7 @@ export function watchExposeRequested(o) {
         (o.allowDomain?.length ?? 0) > 0 ||
         o.publicUrl !== undefined);
 }
-// Map LabCommandOptions onto the shared exposure validator input.
+// Map StudyCommandOptions onto the shared exposure validator input.
 export function exposureRequestFromOptions(options) {
     return {
         expose: options.expose === true,

package/dist/cli/orientation.d.ts

@@ -3,10 +3,10 @@ export interface OrientationState {
     schema: typeof ORIENTATION_SCHEMA;
     /** Whether this project has a committed `humanish/` source plane. */
     initialized: boolean;
-    /** Committed + gitignored lab manifests discovered in this project. */
-    labCount: number;
-    /** Ids of a few labs worth naming in a suggestion. */
-    labIds: string[];
+    /** Committed and gitignored study files found in this project. */
+    studyCount: number;
+    /** Ids of a few studies worth naming in a suggestion. */
+    studyIds: string[];
     /** Runs already on disk, and the most recent one if there is one. */
     runCount: number;
     latestRunId?: string;

package/dist/cli/orientation.js

@@ -12,8 +12,9 @@
 // Both audiences are served by the same data (docs/principles/three-roles.md). A human on a
 // terminal gets prose and an offer to set things up; an agent gets the same facts as stable text,
 // or as JSON with `--json`. Neither is a special case of the other bolted on afterwards.
-import { listLabManifests } from "../lab/discover.js";
+import { listStudyManifests } from "../study/discover.js";
 import { listRuns } from "../run/stored-runs.js";
+import { plural } from "../run/text.js";
 import { supportsLocalBrowser } from "./first-run-path.js";
 import { PRODUCT_SENTENCE } from "./product-sentence.js";
 export const ORIENTATION_SCHEMA = "humanish.orientation.v1";
@@ -22,26 +23,39 @@ export const ORIENTATION_SCHEMA = "humanish.orientation.v1";
  * a provider: bare invocation must not be able to spend money or mutate a repo.
  */
 export async function readOrientation(cwd, host = process) {
-    const [labs, runs] = await Promise.all([
-        listLabManifests(cwd).catch(() => undefined),
+    const [found, runs] = await Promise.all([
+        listStudyManifests(cwd).catch(() => undefined),
         listRuns(cwd).catch(() => undefined),
     ]);
-    const labIds = (labs?.studies ?? [])
-        .map((lab) => lab.id)
+    const studyIds = (found?.studies ?? [])
+        .map((study) => study.id)
         .filter((id) => typeof id === "string");
     const runIds = (runs?.runs ?? [])
         .map((run) => run.runId)
         .filter((id) => typeof id === "string");
     const latest = typeof runs?.latest === "string" ? runs.latest : runIds[0];
-    const initialized = (labs?.studies ?? []).some((lab) => lab.origin === "committed") || labIds.length > 0;
+    const retiredFiles = found?.retired ?? [];
+    const retired = {
+        v2: retiredFiles.filter((file) => file.code === "HUMANISH_STUDY_V2_UNSUPPORTED").length,
+        moved: retiredFiles.filter((file) => file.code === "HUMANISH_STUDY_RETIRED_DIRECTORY").length,
+    };
+    const initialized = (found?.studies ?? []).some((study) => study.origin === "committed") ||
+        studyIds.length > 0 ||
+        retiredFiles.length > 0;
     return {
         schema: ORIENTATION_SCHEMA,
         initialized,
-        labCount: labIds.length,
-        labIds: labIds.slice(0, 3),
+        studyCount: studyIds.length,
+        studyIds: studyIds.slice(0, 3),
         runCount: runIds.length,
         ...(latest === undefined ? {} : { latestRunId: latest }),
-        nextCommands: nextCommandsFor({ initialized, labIds, hasRun: runIds.length > 0, host }),
+        nextCommands: nextCommandsFor({
+            initialized,
+            studyIds,
+            retired,
+            hasRun: runIds.length > 0,
+            host,
+        }),
     };
 }
 /**
@@ -49,6 +63,30 @@ export async function readOrientation(cwd, host = process) {
  * is commander's help, which nobody reads.
  */
 function nextCommandsFor(args) {
+    const { v2, moved } = args.retired;
+    const fixes = [
+        ...(v2 === 0
+            ? []
+            : [
+                {
+                    command: "humanish migrate --dry-run",
+                    why: `${plural(v2, "study file")} ${v2 === 1 ? "uses" : "use"} humanish.lab.v2, which humanish no longer reads; this lists the conversion, and humanish migrate writes it`,
+                },
+            ]),
+        ...(moved === 0
+            ? []
+            : [
+                {
+                    command: "humanish study list",
+                    why: `${plural(moved, "study file")} ${moved === 1 ? "is" : "are"} in a labs/ directory, which humanish no longer reads; this names each one and the studies/ directory to move it to`,
+                },
+            ]),
+    ];
+    // A fix that is already `humanish study list` replaces the plain suggestion of the same command.
+    const named = new Set(fixes.map((fix) => fix.command));
+    return [...fixes, ...nextCommandsForStudies(args).filter((next) => !named.has(next.command))];
+}
+function nextCommandsForStudies(args) {
     const dryRun = {
         command: "humanish run first-run",
         why: "a dry run: no browser or model runs, no keys, no spend",
@@ -57,31 +95,31 @@ function nextCommandsFor(args) {
         return [
             {
                 command: "humanish init --yes",
-                why: "write starter labs, personas and an AGENTS.md (--dry-run lists every file first)",
+                why: "write starter studies, personas and an AGENTS.md (--dry-run lists every file first)",
             },
             dryRun,
         ];
     }
-    // The starter live lab this host can run. The other starter labs are templates whose subject
+    // The starter live study this host can run. The other starter studies are templates whose subject
     // still names your-org/your-app, so they are never suggested.
-    const liveLab = (supportsLocalBrowser(args.host.platform, args.host.arch)
+    const liveStudy = (supportsLocalBrowser(args.host.platform, args.host.arch)
         ? ["local-browser", "try-live"]
-        : ["try-live"]).find((id) => args.labIds.includes(id));
+        : ["try-live"]).find((id) => args.studyIds.includes(id));
     if (!args.hasRun) {
         return [
             dryRun,
-            liveLab === undefined
+            liveStudy === undefined
                 ? { command: "humanish study list", why: "see the studies this project declares" }
                 : {
-                    command: `humanish doctor --study ${liveLab}`,
-                    why: `check what the ${liveLab} study still needs before a live run`,
+                    command: `humanish doctor --study ${liveStudy}`,
+                    why: `check what the ${liveStudy} study still needs before a live run`,
                 },
         ];
     }
     return [
-        ...(liveLab === undefined
+        ...(liveStudy === undefined
             ? []
-            : [{ command: `humanish run ${liveLab}`, why: "run a real participant against an app" }]),
+            : [{ command: `humanish run ${liveStudy}`, why: "run a real participant against an app" }]),
         {
             command: "humanish verify --run latest",
             why: "check the last run's evidence and public-safety gates",
@@ -99,13 +137,13 @@ export function formatOrientationHuman(state) {
         lines.push("This project is not set up yet.");
     }
     else {
-        const labs = state.labCount === 1 ? "1 lab" : `${state.labCount} labs`;
+        const studies = state.studyCount === 1 ? "1 study" : `${state.studyCount} studies`;
         const runs = state.runCount === 0
             ? "no runs yet"
             : state.runCount === 1
                 ? "1 run"
                 : `${state.runCount} runs`;
-        lines.push(`This project has ${labs} and ${runs}${state.latestRunId ? ` (latest: ${state.latestRunId})` : ""}.`);
+        lines.push(`This project has ${studies} and ${runs}${state.latestRunId ? ` (latest: ${state.latestRunId})` : ""}.`);
     }
     lines.push("");
     for (const next of state.nextCommands) {

package/dist/cli/program.js

@@ -12,7 +12,7 @@ import { registerCommsCommands } from "./commands/comms.js";
 import { registerFeedbackCommands } from "./commands/feedback.js";
 import { registerStudyCommands } from "./commands/study.js";
 import { registerMigrateCommand } from "./commands/migrate.js";
-import { registerObserveCommand, registerServeCommand } from "./commands/observe.js";
+import { registerObserveCommand } from "./commands/observe.js";
 import { registerCleanupCommand, registerExportCommand, registerReclaimCommand, registerReviewCommand, registerRunCommand, registerRunsCommand, registerRuntimeCommands, registerStatsCommand, registerVerifyCommand, } from "./commands/runs.js";
 import { registerDoctorCommand, registerInitCommand, registerKeysCommand, registerTelemetryCommand, } from "./commands/setup.js";
 import { defaultTuiRuntime, registerTuiCommand } from "./commands/tui.js";
@@ -73,7 +73,7 @@ async function recordCommandTelemetry(command, ok, durationMs, exitCode) {
             event: "cli_command",
             anonymousId: state.anonymousId,
             version: CLI_VERSION,
-            // The study facts (mode, outcome, starter lab, brain, our own error code) were read off the
+            // The study facts (mode, outcome, starter study, brain, our own error code) were read off the
             // result document when it was written; see writeResult. Without them every `run` event
             // looked the same whether it was a dry run or the first live study that ever worked.
             properties: {
@@ -116,7 +116,7 @@ function reportActiveHandles(command, io) {
         io.writeErr(`humanish debug: active resources after \`${commandPath(command) || "humanish"}\` settled: ${summary}\n`);
     }).unref?.();
 }
-/** `lab run`, not `run`, so the two are distinguishable, and nothing else from the invocation. */
+/** `study show`, not `show`, so subcommands are distinguishable, and nothing else from the invocation. */
 function commandPath(command) {
     const parts = [];
     let current = command;
@@ -370,7 +370,6 @@ export function createProgram(io = {}) {
     registerCleanupCommand(program, cliIo);
     registerKeysCommand(program, cliIo);
     registerTelemetryCommand(program, cliIo);
-    registerServeCommand(program, cliIo);
     registerTuiCommand(program, cliIo, { ...defaultTuiRuntime, ...io.tuiRuntime });
     registerCodexCommands(program, cliIo);
     // Only the root takes a stray word, so the action above can name the command it meant. Set after

package/dist/cli/telemetry.d.ts

@@ -78,7 +78,7 @@ export declare function buildPayload(args: {
     nodeVersion?: string;
 }): TelemetryPayload;
 /**
- * Read the study facts off a command's result document: mode, outcome, starter lab, brain route,
+ * Read the study facts off a command's result document: mode, outcome, starter study, brain route,
  * and our own error code. Duck-typed over every result shape the CLI writes, because the point is
  * one derivation at the one seam every command already passes through (writeResult), so that a
  * backend added later cannot forget to report. Returns {} for results that carry no study.

package/dist/cli/telemetry.js

@@ -5,9 +5,9 @@
 // working first run". A tool that cannot see its own activation is guessing.
 //
 // What it will never send, and this is stricter than the convention because of what humanish is:
-// no paths, no cwd, no repo names, no URLs, no lab titles or ids that are not our own starter labs,
+// no paths, no cwd, no repo names, no URLs, no study titles or ids that are not our own starter studies,
 // no persona or mission text, no run ids, no evidence, no key values, no key names. A study's
-// subject is the adopter's product and often unannounced; leaking a lab id would leak a roadmap.
+// subject is the adopter's product and often unannounced; leaking a study id would leak a roadmap.
 // The allowlist below is the whole vocabulary: anything not on it cannot be sent by construction.
 import { isCuaDiagnosticCategory, isCuaDiagnosticStopCause, } from "../routes/computer-use/diagnostics.js";
 import { randomUUID } from "node:crypto";
@@ -175,12 +175,8 @@ export function buildPayload(args) {
     const given = args.properties ?? {};
     if (given.command !== undefined)
         properties.command = given.command;
-    if (given.study !== undefined) {
+    if (given.study !== undefined)
         properties.study = given.study;
-        // Removed in 0.109.0: `lab`, the property's 0.107 name, carries the same value until then, so
-        // a dashboard that filters on `lab` keeps reading 0.108 events while older clients send `lab`.
-        properties.lab = given.study;
-    }
     if (given.mode !== undefined)
         properties.mode = given.mode;
     if (given.outcome !== undefined)
@@ -236,7 +232,7 @@ function asRecord(value) {
         : undefined;
 }
 /**
- * Read the study facts off a command's result document: mode, outcome, starter lab, brain route,
+ * Read the study facts off a command's result document: mode, outcome, starter study, brain route,
  * and our own error code. Duck-typed over every result shape the CLI writes, because the point is
  * one derivation at the one seam every command already passes through (writeResult), so that a
  * backend added later cannot forget to report. Returns {} for results that carry no study.
@@ -257,18 +253,16 @@ export function deriveRunFacts(result) {
     else if (r.mode === "dry-run" || r.mode === "live")
         facts.mode = r.mode;
     const studyRecord = asRecord(r.study) ?? asRecord(r.lab);
-    const labId = typeof r.studyId === "string"
+    const studyId = typeof r.studyId === "string"
         ? r.studyId
-        : typeof r.labId === "string"
-            ? r.labId
-            : typeof studyRecord?.id === "string"
-                ? studyRecord.id
-                : typeof r.study === "string"
-                    ? r.study
-                    : typeof r.lab === "string"
-                        ? r.lab
-                        : undefined;
-    const study = safeStudyId(labId);
+        : typeof studyRecord?.id === "string"
+            ? studyRecord.id
+            : typeof r.study === "string"
+                ? r.study
+                : typeof r.lab === "string"
+                    ? r.lab
+                    : undefined;
+    const study = safeStudyId(studyId);
     if (study !== undefined)
         facts.study = study;
     const error = asRecord(r.error);
@@ -323,7 +317,7 @@ export function deriveRunFacts(result) {
 /** The notice, shown once, before anything is sent. */
 export const TELEMETRY_NOTICE = [
     "humanish collects anonymous usage data (which command ran, whether it worked, how long it took).",
-    "It never sends your labs, subjects, personas, paths, or evidence. Opt out any time:",
+    "It never sends your studies, subjects, personas, paths, or evidence. Opt out any time:",
     "  humanish telemetry disable        (or set DO_NOT_TRACK=1)",
     "  humanish telemetry status         shows exactly what is collected",
 ].join("\n");

package/dist/comms/catch-host.d.ts

@@ -15,7 +15,7 @@ export interface CommsCatchHostOptions {
     /** Optional loopback SMTP listener sharing the HTTP capture and inbox pipeline. */
     smtpPort?: number;
     /** Restrict the rendered inbox to these addresses. Omit to render whatever the app actually mailed;
-     *  a standalone catch has no lab roster to read recipients from, and an operator who forgets to
+     *  a standalone catch has no study roster to read recipients from, and an operator who forgets to
      *  name one should not get a healthy catch that renders an empty inbox forever. */
     recipients?: string[];
     /** Inbox re-render cadence in ms (test seam). */

package/dist/comms/catch-host.js

@@ -11,7 +11,7 @@
 // Shipping it as a command rather than a spec matters: the adopter runs the identical
 // implementation humanish deploys in-sandbox, so the capture shape, the inbox surface, and the
 // drain contract cannot drift between the two planes. Point the app's email-API base URL at this
-// server and point the lab's `catchBaseUrl` at it too.
+// server and point the study's `catchBaseUrl` at it too.
 //
 // Runtime: the catch is a python3 stdlib server with no dependencies (that was the 0.29.0 lesson:
 // a co-located catcher must use a runtime the environment guarantees). This command writes the
@@ -135,11 +135,11 @@ export async function runCommsCatchHost(options, io) {
             ]),
         `  POST /emails        <- point your app's email-API base URL here`,
         `  GET  /inbox         <- shared operator inbox${inboxPort === undefined ? " (loopback only without --inbox-port)" : ""}`,
-        `  GET  /inbox/for/... <- assigned participant inbox (linked by the lab)`,
+        `  GET  /inbox/for/... <- assigned participant inbox (linked by the study)`,
         `  GET  /deliveries    <- humanish drains this${options.token ? " (bearer token required)" : ""}`,
         `  GET  /health        <- readiness marker humanish probes before a run`,
         ``,
-        `Declare it in the lab:`,
+        `Declare it in the study:`,
         `  comms:`,
         `    email:`,
         `      external:`,

package/dist/comms/connections.d.ts

@@ -16,5 +16,5 @@ export interface CommsSetupResult {
 }
 /** Offline and non-mutating. Unsafe storage is an error, never an empty configuration. */
 export declare function readCommsConnections(cwd: string): Promise<CommsConnections>;
-/** Add one exact profile. No lab mutation, network, provider resources or credential values. */
+/** Add one exact profile. No study mutation, network, provider resources or credential values. */
 export declare function saveCommsConnection(cwd: string, name?: string, apiKeyEnv?: string): Promise<CommsSetupResult>;

package/dist/comms/connections.js

@@ -65,7 +65,7 @@ export async function readCommsConnections(cwd) {
         throw new Error("Invalid connection configuration.");
     }
 }
-/** Add one exact profile. No lab mutation, network, provider resources or credential values. */
+/** Add one exact profile. No study mutation, network, provider resources or credential values. */
 export async function saveCommsConnection(cwd, name = DEFAULT_COMMS_PROVIDER.id, apiKeyEnv = DEFAULT_COMMS_PROVIDER.keyEnv) {
     const provider = DEFAULT_COMMS_PROVIDER.id;
     try {
@@ -94,7 +94,7 @@ export async function saveCommsConnection(cwd, name = DEFAULT_COMMS_PROVIDER.id,
             await writeContainedOutputFile(root, "comms.yaml", stringify(config), "utf8");
             return {
                 ok: true,
-                message: "Connection saved for this project. Select it in a supported lab to use fresh real inboxes.",
+                message: "Connection saved for this project. Select it in a supported study to use fresh real inboxes.",
             };
         }
         finally {

package/dist/comms/external-evidence.d.ts

@@ -1,4 +1,4 @@
-import type { LabCommsEmail, LabCommsExternal } from "../lab/types.js";
+import type { StudyCommsEmail, StudyCommsExternal } from "../study/types.js";
 import type { PreparedRunArtifactPaths } from "../run/paths.js";
 /**
  * Why a catch token cannot be used, or undefined when it can. An unset or empty token is none. A
@@ -6,8 +6,8 @@ import type { PreparedRunArtifactPaths } from "../run/paths.js";
  * refused with the short ones.
  */
 export declare function catchTokenRefusal(token: string | undefined): string | undefined;
-/** The catch token the run sends: the value of `authTokenEnv`, when the lab names one. */
-export declare function catchTokenOf(external: LabCommsExternal, env: Record<string, string | undefined>): string | undefined;
+/** The catch token the run sends: the value of `authTokenEnv`, when the study names one. */
+export declare function catchTokenOf(external: StudyCommsExternal, env: Record<string, string | undefined>): string | undefined;
 /**
  * Drains the catch, routes its sends to the declared recipients' inboxes and writes the thread to
  * `comms/thread.json`. Returns that path when a message matched, and the warnings to add to the
@@ -15,8 +15,8 @@ export declare function catchTokenOf(external: LabCommsExternal, env: Record<str
  * throws: the run continues without comms evidence.
  */
 export declare function collectExternalCommsEvidence(args: {
-    external: LabCommsExternal;
-    email: LabCommsEmail;
+    external: StudyCommsExternal;
+    email: StudyCommsEmail;
     env: Record<string, string | undefined>;
     runPaths: PreparedRunArtifactPaths;
     /** The run's known secret values. The route may add to it until the drain runs. */