humanish 0.108.0 → 0.109.0

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. */

package/dist/comms/external-evidence.js

@@ -4,10 +4,11 @@
 // shape for pattern redaction to find.
 import { redactText, toErrorMessage } from "../evidence/redaction.js";
 import { scrubSecretValues } from "../evidence/secret-scrub.js";
-import { addressedRecipients } from "../lab/parse/comms.js";
+import { addressedRecipients } from "../study/parse/comms.js";
 import { writeContainedOutputFile } from "../run/contained-output.js";
 import { FakeInbox } from "./fake-inbox.js";
 import { collectExternalCommsThread } from "./sandbox-catch.js";
+import { plural } from "../run/text.js";
 /**
  * The shortest catch bearer token humanish uses. The token guards GET /deliveries on a host the run
  * reaches over the network, so it must not be guessable: 16 random base64 characters are 96 bits.
@@ -33,7 +34,7 @@ export function catchTokenRefusal(token) {
         return undefined;
     return `The comms catch token is ${token.length} characters; it must be at least ${MIN_CATCH_TOKEN_LENGTH}, such as the output of \`openssl rand -hex 16\`, on the catch and in the run.`;
 }
-/** The catch token the run sends: the value of `authTokenEnv`, when the lab names one. */
+/** The catch token the run sends: the value of `authTokenEnv`, when the study names one. */
 export function catchTokenOf(external, env) {
     return external.authTokenEnv === undefined ? undefined : env[external.authTokenEnv];
 }
@@ -73,7 +74,7 @@ export async function collectExternalCommsEvidence(args) {
         if (collected.captured > 0) {
             return {
                 warnings: scrubbed([
-                    `The email catch captured ${collected.captured} email send(s), but none matched a declared recipient inbox, so no email evidence was written. Set comms.email.recipients[].address to the address the app sends to.`,
+                    `The email catch captured ${plural(collected.captured, "email send")}, but none matched a declared recipient inbox, so no email evidence was written. Set comms.email.recipients[].address to the address the app sends to.`,
                 ]),
             };
         }

package/dist/comms/fake-inbox.d.ts

@@ -21,11 +21,11 @@ export declare class FakeInbox implements CommsChannel {
     constructor(options?: FakeInboxOptions);
     provision(participantId: string): Promise<CommsAddress>;
     /**
-     * Provision an inbox for `participantId` at an explicit address (a lab-declared recipient), so
+     * Provision an inbox for `participantId` at an explicit address (a study-declared recipient), so
      * the app-under-test's send to that literal address resolves in `deliverRaw` (which drops
      * recipients with no provisioned inbox). Declaring the same address intentionally shares its
      * inbox; if `participantId` already held a different auto-generated address, the declared
-     * address supersedes it (the lab's declaration wins). Idempotent: re-declaring the same address
+     * address supersedes it (the study's declaration wins). Idempotent: re-declaring the same address
      * returns the existing inbox without clearing it.
      */
     provisionAddress(participantId: string, value: string): Promise<CommsAddress>;

package/dist/comms/fake-inbox.js

@@ -60,11 +60,11 @@ export class FakeInbox {
         return address;
     }
     /**
-     * Provision an inbox for `participantId` at an explicit address (a lab-declared recipient), so
+     * Provision an inbox for `participantId` at an explicit address (a study-declared recipient), so
      * the app-under-test's send to that literal address resolves in `deliverRaw` (which drops
      * recipients with no provisioned inbox). Declaring the same address intentionally shares its
      * inbox; if `participantId` already held a different auto-generated address, the declared
-     * address supersedes it (the lab's declaration wins). Idempotent: re-declaring the same address
+     * address supersedes it (the study's declaration wins). Idempotent: re-declaring the same address
      * returns the existing inbox without clearing it.
      */
     async provisionAddress(participantId, value) {

package/dist/comms/receiving-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { LabConfig } from "../lab/types.js";
+import type { StudyConfig } from "../study/types.js";
 import { type CommsConnection } from "./connections.js";
 import { type KeyResolutionDeps } from "../keys/key-resolution.js";
 import type { ReceivingAdapter } from "./receiving-types.js";
@@ -14,9 +14,9 @@ export declare function resolveReceivingConnection(cwd: string, name: string, en
     apiKey: string;
     adapter: ReceivingAdapter;
 }>;
-/** What receiving reads from a lab: its email declaration and the subject env it guards. */
+/** What receiving reads from a study: its email declaration and the subject env it guards. */
 export interface ReceivingSource {
-    readonly comms?: LabConfig["comms"];
+    readonly comms?: StudyConfig["comms"];
     readonly subject: {
         readonly env?: readonly string[];
         readonly envValues?: Readonly<Record<string, string>>;
@@ -32,7 +32,7 @@ export declare function prepareReceivingRun(args: {
     registerSecrets(values: string[]): void;
 }): Promise<import("./receiving.js").CommsReceivingRun | undefined>;
 /** The restriction survives restarts and screenshot redaction; it is not a claim of local processing. */
-export declare function receivingPublication(config: Pick<LabConfig, "comms">, dryRun: boolean): {
+export declare function receivingPublication(config: Pick<StudyConfig, "comms">, dryRun: boolean): {
     publication: {
         restrictions: ["real-communications"];
     };

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

@@ -78,7 +78,7 @@ export declare function drainCommsCatch(shell: Shell, deployed: Pick<DeployedCom
 export declare function parseDeliveriesNdjson(text: string): RawCapturedSend[];
 /**
  * The distinct `to` addresses the captured mail was actually sent to, parsed with the same profiles
- * that route it. A lab run knows its recipients from the declared roster; a standalone catch does not,
+ * that route it. A run knows its recipients from the declared roster; a standalone catch does not,
  * so it discovers them from the mail itself. Otherwise an operator who forgot to name an address gets
  * a technically-healthy catch rendering an empty inbox forever: a false green.
  */
@@ -139,7 +139,7 @@ export declare function externalInboxUrl(external: ExternalCommsCatch): string;
 /**
  * Probe an adopter-hosted catch the way the in-sandbox one is probed: assert humanish's service marker in
  * /health, not merely any 2xx: an adopter's reverse proxy or a captive portal will happily return
- * 200 for anything, and a comms lab whose catch is not actually there collects nothing while
+ * 200 for anything, and a comms study whose catch is not actually there collects nothing while
  * looking fine. Fail-closed callers treat `false` as a hard stop before spending on a run.
  */
 export declare function externalCatchHealthy(external: ExternalCommsCatch, options?: {

package/dist/comms/sandbox-catch.js

@@ -171,7 +171,7 @@ export function parseDeliveriesNdjson(text) {
 }
 /**
  * The distinct `to` addresses the captured mail was actually sent to, parsed with the same profiles
- * that route it. A lab run knows its recipients from the declared roster; a standalone catch does not,
+ * that route it. A run knows its recipients from the declared roster; a standalone catch does not,
  * so it discovers them from the mail itself. Otherwise an operator who forgot to name an address gets
  * a technically-healthy catch rendering an empty inbox forever: a false green.
  */
@@ -298,7 +298,7 @@ export function externalInboxUrl(external) {
 /**
  * Probe an adopter-hosted catch the way the in-sandbox one is probed: assert humanish's service marker in
  * /health, not merely any 2xx: an adopter's reverse proxy or a captive portal will happily return
- * 200 for anything, and a comms lab whose catch is not actually there collects nothing while
+ * 200 for anything, and a comms study whose catch is not actually there collects nothing while
  * looking fine. Fail-closed callers treat `false` as a hard stop before spending on a run.
  */
 export async function externalCatchHealthy(external, options = {}) {

package/dist/comms/setup.d.ts

@@ -55,9 +55,9 @@ export interface CommsConfigureResult {
     connection?: string;
 }
 /** Save a local copy, never rewrite a committed manifest or silently shadow it by handle. */
-export declare function configureCommsLab(args: {
+export declare function configureCommsStudy(args: {
     cwd: string;
-    lab: string;
+    study: string;
     connection: string;
     apply?: boolean;
     planToken?: string;