humanish 0.107.0 → 0.109.0

package/dist/substrates/e2b/desktop-media.d.ts

@@ -1,10 +1,10 @@
 import { startDesktopMedia } from "../../guest/desktop-media.js";
 import type { E2BDesktopSandbox } from "./sdk.js";
-import type { LabDesktopMedia } from "../../lab/types.js";
+import type { StudyDesktopMedia } from "../../study/types.js";
 /** The same worker and conversation contract, transported by the hosted SDK's stdin/stdout. */
 export declare function startE2BDesktopMedia(options: {
     desktop: E2BDesktopSandbox;
-    media: LabDesktopMedia;
+    media: StudyDesktopMedia;
     signal: AbortSignal;
     onTerminal(): void;
     requestTimeoutMs: number;
@@ -22,8 +22,8 @@ export interface DesktopMediaEvidence {
 }
 /**
  * Put the declared camera feed in the sandbox and return the Chromium flags that present it as a
- * capture device (#509). Fails CLOSED: a feed that cannot be produced (no ffmpeg on the image, an
+ * capture device. Fails closed: a feed that cannot be produced (no ffmpeg on the image, an
  * unreadable host file) is named before the browser launches, because a participant told it has
  * a camera and finds none reports the instrument's gap as the product's.
  */
-export declare function prepareDesktopMedia(desktop: E2BDesktopSandbox, media: LabDesktopMedia, permission: "prompt" | "granted", cwd: string, requestTimeoutMs: number, readHostFile?: (absolutePath: string) => Promise<Buffer>): Promise<DesktopMediaEvidence>;
+export declare function prepareDesktopMedia(desktop: E2BDesktopSandbox, media: StudyDesktopMedia, permission: "prompt" | "granted", cwd: string, requestTimeoutMs: number, readHostFile?: (absolutePath: string) => Promise<Buffer>): Promise<DesktopMediaEvidence>;

package/dist/substrates/e2b/desktop-media.js

@@ -91,7 +91,7 @@ const SANDBOX_CAMERA_PATH = `${SANDBOX_MEDIA_DIR}/camera.y4m`;
 const SYNTHETIC_CAMERA_COMMAND = `mkdir -p ${SANDBOX_MEDIA_DIR} && ffmpeg -y -loglevel error -f lavfi -i testsrc=size=640x480:rate=10 -t 6 -pix_fmt yuv420p ${SANDBOX_CAMERA_PATH}`;
 /**
  * Put the declared camera feed in the sandbox and return the Chromium flags that present it as a
- * capture device (#509). Fails CLOSED: a feed that cannot be produced (no ffmpeg on the image, an
+ * capture device. Fails closed: a feed that cannot be produced (no ffmpeg on the image, an
  * unreadable host file) is named before the browser launches, because a participant told it has
  * a camera and finds none reports the instrument's gap as the product's.
  */

package/dist/substrates/e2b/desktop-screenshot-cleanup.d.ts

@@ -4,12 +4,12 @@ export declare function desktopScreenshotCleanupFailures(desktop: object): numbe
 /**
  * @e2b/desktop 2.3.3 screenshot() awaits capture and files.read(path), then discards the
  * files.remove(path) promise. A removal that races sandbox teardown can therefore crash Node
- * AFTER valid bytes were returned. Installed-SDK conformance tests pin that behavior (#662).
+ * after valid bytes were returned. Installed-SDK conformance tests pin that behavior.
  *
- * Observe only removal of a file successfully read within THIS screenshot invocation. The
+ * Observe only removal of a file successfully read within this screenshot invocation. The
  * exact path comes from the SDK, not a guessed filename pattern. AsyncLocalStorage isolates
  * concurrent screenshots and unrelated file operations without changing SDK method receivers.
- * The ORIGINAL removal promise is returned: an SDK version (or caller) that awaits it still
+ * The original removal promise is returned: an SDK version (or caller) that awaits it still
  * receives the original rejection. No process-wide rejection handler or filesystem retry.
  */
 export declare function protectDesktopScreenshotCleanup<T extends E2BDesktopSandbox>(desktop: T): T;

package/dist/substrates/e2b/desktop-screenshot-cleanup.js

@@ -11,12 +11,12 @@ export function desktopScreenshotCleanupFailures(desktop) {
 /**
  * @e2b/desktop 2.3.3 screenshot() awaits capture and files.read(path), then discards the
  * files.remove(path) promise. A removal that races sandbox teardown can therefore crash Node
- * AFTER valid bytes were returned. Installed-SDK conformance tests pin that behavior (#662).
+ * after valid bytes were returned. Installed-SDK conformance tests pin that behavior.
  *
- * Observe only removal of a file successfully read within THIS screenshot invocation. The
+ * Observe only removal of a file successfully read within this screenshot invocation. The
  * exact path comes from the SDK, not a guessed filename pattern. AsyncLocalStorage isolates
  * concurrent screenshots and unrelated file operations without changing SDK method receivers.
- * The ORIGINAL removal promise is returned: an SDK version (or caller) that awaits it still
+ * The original removal promise is returned: an SDK version (or caller) that awaits it still
  * receives the original rejection. No process-wide rejection handler or filesystem retry.
  */
 export function protectDesktopScreenshotCleanup(desktop) {

package/dist/substrates/e2b/lifetime.js

@@ -1,7 +1,7 @@
 // How long an E2B sandbox may live, and the budgets the desktop routes add to a participant's own
 // deadline when they set a sandbox's server-side timeout. A dead host process can never orphan a
 // sandbox past that timeout, so every route derives it from these values.
-import { readPositiveInt } from "../../lab/parse/values.js";
+import { readPositiveInt } from "../../study/parse/values.js";
 /**
  * E2B refuses a sandbox lifetime over one hour ("400: Timeout cannot be greater than 1 hours").
  * A derived deadline has to stay under it, and saying so at plan time beats discovering it from a

package/dist/substrates/e2b/sandbox.d.ts

@@ -1,6 +1,6 @@
 import type { PreparedOutputRoot } from "../../run/contained-output.js";
 import { type DesktopReleaseResult, type OwnedDesktopAllocation } from "../desktop-session.js";
-import type { LabConfig } from "../../lab/types.js";
+import type { StudyConfig } from "../../study/types.js";
 import { type E2BDesktopCreateOptions, type E2BDesktopModule, type E2BDesktopSandbox } from "./sdk.js";
 /** Where an allocation's receipt goes: the run's prepared root, under a public-safe participant
  *  label. The receipt line saves it as `laneId`. */
@@ -66,9 +66,9 @@ export declare function destroyE2BSandbox(module: E2BDesktopModule, sandboxId: s
 }): Promise<E2BSandboxDestroyOutcome>;
 /** Versioned public template built by runtime/browser-media/e2b-template.mjs. */
 export declare const E2B_SPEECH_TEMPLATE = "7409n13kr83f7g7abx5g";
-/** The desktop template a lab asks for; undefined selects the SDK default. */
+/** The desktop template a study asks for; undefined selects the SDK default. */
 export declare function e2bDesktopTemplate(config: {
-    readonly execution?: Pick<NonNullable<LabConfig["execution"]>, "target" | "desktop">;
+    readonly execution?: Pick<NonNullable<StudyConfig["execution"]>, "target" | "desktop">;
 }): string | undefined;
 /** How a caller hears about the one retry; `sleep` is injectable so tests never wait. */
 export interface TransientRetryHooks {
@@ -89,7 +89,7 @@ export declare const TRANSIENT_RETRY_DELAY_MS = 3000;
  *   describing, the same routing gap seen from the upload side.
  * - transport resets (`fetch failed`, `ECONNRESET`, `socket hang up`, 502/503/504).
  *
- * NOT retried: timeouts (the budget is spent), auth (401/403), quota and rate limits (429: a burst
+ * Not retried: timeouts (the budget is spent), auth (401/403), quota and rate limits (429: a burst
  * that hit the limit should be spaced, not repeated), and anything that names the request as wrong.
  */
 export declare function isTransientE2BError(error: unknown): boolean;

package/dist/substrates/e2b/sandbox.js

@@ -158,7 +158,7 @@ export async function destroyE2BSandbox(module, sandboxId, options) {
 }
 /** Versioned public template built by runtime/browser-media/e2b-template.mjs. */
 export const E2B_SPEECH_TEMPLATE = "7409n13kr83f7g7abx5g";
-/** The desktop template a lab asks for; undefined selects the SDK default. */
+/** The desktop template a study asks for; undefined selects the SDK default. */
 export function e2bDesktopTemplate(config) {
     if (config.execution?.target === "local")
         return undefined;
@@ -181,7 +181,7 @@ export const TRANSIENT_RETRY_DELAY_MS = 3_000;
  *   describing, the same routing gap seen from the upload side.
  * - transport resets (`fetch failed`, `ECONNRESET`, `socket hang up`, 502/503/504).
  *
- * NOT retried: timeouts (the budget is spent), auth (401/403), quota and rate limits (429: a burst
+ * Not retried: timeouts (the budget is spent), auth (401/403), quota and rate limits (429: a burst
  * that hit the limit should be spaced, not repeated), and anything that names the request as wrong.
  */
 export function isTransientE2BError(error) {

package/dist/substrates/e2b/sdk.d.ts

@@ -3,25 +3,25 @@ export interface E2BDesktopModule {
         /** The stock `desktop` template (no custom image). */
         create(options: E2BDesktopCreateOptions): Promise<E2BDesktopSandbox>;
         /**
-         * Launch on a CUSTOM E2B desktop template (image) by NAME or ID — the SDK's
-         * `Sandbox.create(template, opts)` overload. Lets a lab run on an adopter-maintained image
+         * Launch on a custom E2B desktop template (image) by name or ID: the SDK's
+         * `Sandbox.create(template, opts)` overload. Lets a study run on an adopter-maintained image
          * with extra runtimes baked in (e.g. node/bun/a local Postgres the stock `desktop` template
          * lacks), instead of the stock template. The base @e2b/desktop SDK implements this; the
          * wrapper just exposes it. Threaded from `execution.desktop.template`.
          */
         create(template: string, options: E2BDesktopCreateOptions): Promise<E2BDesktopSandbox>;
         /**
-         * Kill the sandbox specified by exact id. Returns true iff THAT sandbox was found and
-         * killed, false otherwise (the SDK's own doc comment). This boolean is the PRIMARY by-id
+         * Kill the sandbox specified by exact id. Returns true iff that sandbox was found and
+         * killed, false otherwise (the SDK's own doc comment). This boolean is the primary by-id
          * cleanup proof: a caller never needs to re-list to confirm reclamation.
          */
         kill?(sandboxId: string, options?: {
             requestTimeoutMs?: number;
         }): Promise<boolean>;
         /**
-         * Fetch ONE sandbox by its exact id (never account-wide). Throws a SandboxNotFoundError-
+         * Fetch one sandbox by its exact id (never account-wide). Throws a SandboxNotFoundError-
          * shaped error (see isSandboxNotFoundError below) when the id no longer exists; that thrown
-         * error IS the by-id confirmation that a killed sandbox is gone. Optional: older SDKs may
+         * error is the by-id confirmation that a killed sandbox is gone. Optional: older SDKs may
          * lack it, so callers fall back to kill()'s own boolean rather than ever calling Sandbox.list.
          */
         getInfo?(sandboxId: string, options?: {
@@ -123,10 +123,10 @@ export interface E2BDesktopSandbox {
     /** Open a file or URL with the desktop's default application (present on @e2b/desktop >= 1.x). */
     open?(fileOrUrl: string): Promise<void>;
     /**
-     * Map an in-sandbox port to a reachable host URL — `https://<port>-<sandboxId>.e2b.app`,
-     * TOKENLESS (no authKey, unlike `stream.getUrl`). The base `e2b` SDK (v2.27.0) implements this;
-     * the wrapper just exposes it. Used by the CONCURRENT shared-world topology (#164 phase 2) to
-     * expose the ONE subject service plane to N actor sandboxes. Optional: older SDKs may lack it, so
+     * Map an in-sandbox port to a reachable host URL, `https://<port>-<sandboxId>.e2b.app`,
+     * tokenless (no authKey, unlike `stream.getUrl`). The base `e2b` SDK (v2.27.0) implements this;
+     * the wrapper just exposes it. Used by the concurrent shared-world topology to
+     * expose the one subject service plane to N actor sandboxes. Optional: older SDKs may lack it, so
      * the concurrent backend fails closed when it is absent rather than calling a missing method.
      */
     getHost?(port: number): string;
@@ -169,7 +169,7 @@ export declare class E2BDesktopStartupError extends Error {
     constructor(error: unknown, cleanup: DesktopCreateCleanup, cleanupDetail?: string | undefined);
 }
 /**
- * Preserve ownership before the desktop SDK starts Xvfb/XFCE (#581). Its public generic create
+ * Preserve ownership before the desktop SDK starts Xvfb/XFCE. Its public generic create
  * constructs `new this(...)` through the base SDK, then awaits desktop startup. Newer SDKs
  * attempt their own kill before rejecting create; older SDKs leave cleanup to the caller.
  * Both paths share one bounded cleanup result so an internal kill cannot delay our deadline
@@ -183,7 +183,7 @@ export declare class E2BDesktopStartupError extends Error {
  */
 export declare function guardDesktopSandboxCreate(module: E2BDesktopModule): E2BDesktopModule;
 /**
- * Detect a SandboxNotFoundError-shaped error from the real @e2b/desktop SDK, WITHOUT importing
+ * Detect a SandboxNotFoundError-shaped error from the real @e2b/desktop SDK, without importing
  * its class (this module stays optional-peer / lazily-loaded, same as everything else here).
  * The real SDK sets `this.name = "SandboxNotFoundError"` on the class (it extends the
  * deprecated NotFoundError), so checking `.name` is the stable, import-free detection contract.

package/dist/substrates/e2b/sdk.js

@@ -18,9 +18,9 @@ export async function loadE2BDesktopModule() {
                 ? "Live E2B desktop launch requires the optional peer @e2b/desktop. Install it beside humanish " +
                     "in this project: `npm i -D @e2b/desktop`."
                 : "Live E2B desktop launch requires the optional peer @e2b/desktop, and humanish is running from an " +
-                    "npx cache rather than from this project — so installing the peer here cannot help, because Node " +
-                    "resolves it relative to humanish itself. Install BOTH into the project and run it from there: " +
-                    "`npm i -D humanish @e2b/desktop` then `npx humanish run <lab>`.");
+                    "npx cache. Node resolves the peer relative to humanish itself, so a copy installed in this project " +
+                    "is not found. Install both into the project and run it from there: " +
+                    "`npm i -D humanish @e2b/desktop` then `npx humanish run <study>`.");
         }
         throw error;
     }
@@ -44,7 +44,7 @@ export class E2BDesktopStartupError extends Error {
     }
 }
 /**
- * Preserve ownership before the desktop SDK starts Xvfb/XFCE (#581). Its public generic create
+ * Preserve ownership before the desktop SDK starts Xvfb/XFCE. Its public generic create
  * constructs `new this(...)` through the base SDK, then awaits desktop startup. Newer SDKs
  * attempt their own kill before rejecting create; older SDKs leave cleanup to the caller.
  * Both paths share one bounded cleanup result so an internal kill cannot delay our deadline
@@ -147,8 +147,8 @@ async function reclaimFailedDesktopCreate(kill, timeoutMs) {
 /**
  * Is humanish running from this project's node_modules, or from an npx cache?
  *
- * It decides which advice is TRUE. `npx humanish@latest` resolves its optional peer relative to
- * ITSELF, so "install @e2b/desktop in this project" is advice that cannot work there — and that
+ * It decides which advice is true. `npx humanish@latest` resolves its optional peer relative to
+ * itself, so "install @e2b/desktop in this project" is advice that cannot work there, and that
  * message cost two cold verification runs before the difference was noticed. A one-shot npx
  * invocation cannot do a live desktop run at all; humanish has to be installed alongside the peer.
  */
@@ -161,7 +161,7 @@ function isMissingE2BDesktopDependency(error) {
     return value.code === "ERR_MODULE_NOT_FOUND" && value.message?.includes("@e2b/desktop") === true;
 }
 /**
- * Detect a SandboxNotFoundError-shaped error from the real @e2b/desktop SDK, WITHOUT importing
+ * Detect a SandboxNotFoundError-shaped error from the real @e2b/desktop SDK, without importing
  * its class (this module stays optional-peer / lazily-loaded, same as everything else here).
  * The real SDK sets `this.name = "SandboxNotFoundError"` on the class (it extends the
  * deprecated NotFoundError), so checking `.name` is the stable, import-free detection contract.

package/dist/substrates/local/runtime-config.d.ts

@@ -1,6 +1,6 @@
-import type { LabConfig } from "../../lab/types.js";
+import type { StudyConfig } from "../../study/types.js";
 export declare const LOCAL_BROWSER_LIFETIME_MS: number;
-export declare function isLocalBrowserLab(config: LabConfig): boolean;
+export declare function isLocalBrowserStudy(config: StudyConfig): boolean;
 /** Defaults for the explicitly selected local substrate; hosted configurations are untouched. */
-export declare function localBrowserDefaults(config: LabConfig): LabConfig;
-export declare function localBrowserUnsupportedReason(config: LabConfig): string | undefined;
+export declare function localBrowserDefaults(config: StudyConfig): StudyConfig;
+export declare function localBrowserUnsupportedReason(config: StudyConfig): string | undefined;

package/dist/substrates/local/runtime-config.js

@@ -1,15 +1,15 @@
-import { rosterOf } from "../../lab/parse/actors.js";
+import { rosterOf } from "../../study/parse/actors.js";
 // The runtime image enforces a 30-minute lifetime; reserve setup/teardown room.
 export const LOCAL_BROWSER_LIFETIME_MS = 30 * 60_000;
 const MAX_SESSION_MS = 20 * 60_000;
-export function isLocalBrowserLab(config) {
+export function isLocalBrowserStudy(config) {
     return (config.subject.source === "app-url" &&
         config.execution?.target === "local" &&
         ["local-agent", "openai-computer-use"].includes(config.actors[0]?.type ?? ""));
 }
 /** Defaults for the explicitly selected local substrate; hosted configurations are untouched. */
 export function localBrowserDefaults(config) {
-    if (!isLocalBrowserLab(config))
+    if (!isLocalBrowserStudy(config))
         return config;
     return {
         ...config,
@@ -40,7 +40,7 @@ export function localBrowserUnsupportedReason(config) {
     if (config.actors.length !== 1 ||
         !actor ||
         (actor.type === "local-agent" && actor.localAgent !== undefined && actor.localAgent !== "codex")) {
-        return "Local browser labs currently support Codex local-agent or openai-computer-use participants.";
+        return "Local browser studies support only Codex local-agent or openai-computer-use participants.";
     }
     if (desktop?.resolution?.[0] !== 960 ||
         desktop.resolution[1] !== 720 ||

package/dist/tui/actions.d.ts

@@ -25,7 +25,7 @@ export declare function createTuiObserverSession(cwdInput: string, options?: {
  * The counterpart to starting one: a study that is going nowhere costs money every turn, and until
  * now the only way to end it was to find the pid yourself.
  *
- * It signals the PROCESS GROUP, not the process. A run is spawned detached — its own group — and it
+ * It signals the process group, not the process. A run is spawned detached, in its own group, and it
  * has children: the CLI, and whatever it spawned to reach the sandbox. Signalling only the parent
  * leaves those orphaned and still working.
  *

package/dist/tui/actions.js

@@ -1,9 +1,9 @@
 import { requestAutomaticAnalysisCancellation } from "../analysis/automatic.js";
-// The two things a run card can DO (#455 rev 8).
+// The two things a run card can do.
 //
-// The mock's run screen is an outcome CARD with actions, not a field list, and an action that does
-// nothing is worse than no action — so this ships the two that are genuinely implementable today
-// and nothing else. `Share…` waits for the export contract (#471) rather than appearing as a
+// The mock's run screen is an outcome card with actions, not a field list, and an action that does
+// nothing is worse than no action, so this ships the two that are genuinely implementable today
+// and nothing else. `Share…` waits for the export contract rather than appearing as a
 // control that fails.
 import { readFile } from "node:fs/promises";
 import path from "node:path";
@@ -32,7 +32,7 @@ export function createTuiObserverSession(cwdInput, options = {}) {
     return {
         async open(targetCwd, observerPath) {
             if (closed)
-                return result(false, "this terminal session has closed — reopen humanish tui to view the run");
+                return result(false, "this terminal session has closed; reopen `humanish tui` to view the run");
             if (path.resolve(targetCwd) !== cwd)
                 return result(false, "Observer can only open runs from this terminal session's project");
             // The capability takes the run-card path, not an arbitrary file, URL, or second project.
@@ -58,7 +58,7 @@ export function createTuiObserverSession(cwdInput, options = {}) {
                 return result(false, "this run's evidence directory is missing or unsafe to open");
             }
             if (closed)
-                return result(false, "this terminal session has closed — reopen humanish tui to view the run");
+                return result(false, "this terminal session has closed; reopen `humanish tui` to view the run");
             try {
                 // Share the pending start too: two quick selections must not create two listeners.
                 serverPromise ??= serveObserverLibrary(cwd, {
@@ -78,13 +78,13 @@ export function createTuiObserverSession(cwdInput, options = {}) {
                 });
                 const server = await serverPromise;
                 if (closed)
-                    return result(false, "this terminal session has closed — reopen humanish tui to view the run");
+                    return result(false, "this terminal session has closed; reopen `humanish tui` to view the run");
                 const url = new URL(`_humanish/runs/${encodeURIComponent(runId)}/observer/index.html`, server.url).href;
                 const opened = open(url);
-                return result(true, `${url} — follows saved captures; keep this TUI open.${opened.warning ? ` ${opened.warning}` : " If no browser appeared, open this URL on this machine or forward its port over SSH."}`);
+                return result(true, `${url} follows saved captures while you keep this TUI open.${opened.warning ? ` ${opened.warning}` : " If no browser appeared, open this URL on this machine or forward its port over SSH."}`);
             }
             catch {
-                return result(false, "Observer could not start — try humanish observe --run with this run's id in another terminal");
+                return result(false, "Observer could not start; run `humanish observe --run <run id>` in another terminal");
             }
         },
         close() {
@@ -104,7 +104,7 @@ export function createTuiObserverSession(cwdInput, options = {}) {
  * The counterpart to starting one: a study that is going nowhere costs money every turn, and until
  * now the only way to end it was to find the pid yourself.
  *
- * It signals the PROCESS GROUP, not the process. A run is spawned detached — its own group — and it
+ * It signals the process group, not the process. A run is spawned detached, in its own group, and it
  * has children: the CLI, and whatever it spawned to reach the sandbox. Signalling only the parent
  * leaves those orphaned and still working.
  *
@@ -144,7 +144,7 @@ export async function stopRun(cwd, runId, intent = "run") {
         return {
             schema: TUI_ACTION_SCHEMA,
             ok: false,
-            message: "this run has no status record, so there is no pid to stop — it predates the contract or never started",
+            message: "this run has no status record, so there is no pid to stop; it predates status records or never started",
         };
     }
     if (!isRunStatusRecord(record)) {
@@ -177,7 +177,7 @@ export async function stopRun(cwd, runId, intent = "run") {
         return { schema: TUI_ACTION_SCHEMA, ok: false, message: "this run recorded no usable pid" };
     }
     // Is it actually still there? A pid whose process is already gone means the run died without
-    // finalizing — nothing to stop, and the record will read as interrupted on its own.
+    // finalizing: nothing to stop, and the record will read as interrupted on its own.
     try {
         process.kill(pid, 0);
     }
@@ -185,7 +185,7 @@ export async function stopRun(cwd, runId, intent = "run") {
         return {
             schema: TUI_ACTION_SCHEMA,
             ok: false,
-            message: `nothing is running under pid ${pid} — it has already stopped, and its record will read as interrupted`,
+            message: `nothing is running under pid ${pid}; it has already stopped, and its record will read as interrupted`,
         };
     }
     try {

package/dist/tui/contract.d.ts

@@ -1,5 +1,5 @@
-import type { LabListResult } from "../lab/discover.js";
-import type { LabSummary, ReadLabSummaryOptions } from "../lab/summary.js";
+import type { StudyListResult } from "../study/discover.js";
+import type { StudySummary, ReadStudySummaryOptions } from "../study/summary.js";
 import type { RunDetail } from "../run/detail.js";
 import type { ReclaimResult } from "../run/reclaim.js";
 import type { TuiActionResult } from "./actions.js";
@@ -25,11 +25,11 @@ export interface TuiCapabilities {
         read(): Promise<CommsSetupStatus>;
         save(): Promise<CommsSetupResult>;
         check?(): Promise<CommsCheckResult>;
-        labs?(): Promise<{
+        studies?(): Promise<{
             title: string;
             path: string;
         }[]>;
-        configure?(lab: string, apply: boolean, planToken?: string): Promise<CommsConfigureResult>;
+        configure?(study: string, apply: boolean, planToken?: string): Promise<CommsConfigureResult>;
         recovery?(): Promise<CommsRecoveryEntry[]>;
         recover?(runId: string, connectionName: string): Promise<{
             ok: boolean;
@@ -39,32 +39,32 @@ export interface TuiCapabilities {
     /** Read every run in the project, cheapest source first. */
     readRunIndex(cwd: string, options?: ReadRunIndexOptions): Promise<RunIndexResult>;
     /**
-     * The labs DECLARED in this project. Listed separately from run history because neither side is
+     * The labs declared in this project. Listed separately from run history because neither side is
      * the whole truth: a fresh project has manifests and no runs, and a long-lived one has runs from
      * manifests since renamed or deleted.
      */
-    listLabs(cwd: string): Promise<LabListResult>;
+    listStudies(cwd: string): Promise<StudyListResult>;
     /**
-     * Start a run and return once it is running. The run is DETACHED: it outlives this surface, so
-     * quitting the TUI — or losing the connection it runs over — does not kill a study that costs
+     * Start a run and return once it is running. The run is detached: it outlives this surface, so
+     * quitting the TUI (or losing the connection it runs over) does not kill a study that costs
      * real money. The surface then follows it through `status.json` like any other reader.
      */
     startRun(options: Omit<LaunchRunOptions, "spawn" | "cliPath" | "now">): Promise<LaunchRunResult>;
     /** The tail of a launch log: the only account of a run that died before writing evidence. */
     readLaunchLog(logPath: string): Promise<string>;
     /**
-     * Who is in ONE run and what they are thinking. Opens that run's bundle, which the index
-     * deliberately does not — affordable because it is asked only for the run being watched.
+     * Who is in one run and what they are thinking. Opens that run's bundle, which the index
+     * deliberately does not. That is affordable because it is asked only for the run being watched.
      * `null` when the run has not written a bundle yet.
      */
     readRunDetail(cwd: string, runId: string): Promise<RunDetail | null>;
     /**
-     * What a lab IS — subject, participants, model, spend caps, and whether the keys a live run needs
-     * resolve right now. Read for the lab being looked at, because it is what someone reads before
+     * What a study is: subject, participants, model, spend caps, and whether the keys a live run needs
+     * resolve right now. Read for the study being looked at, because it is what someone reads before
      * deciding to spend money.
      */
-    readLabSummary(cwd: string, lab: string, options?: ReadLabSummaryOptions): Promise<LabSummary | null>;
-    /** Whether this directory is a humanish project — an empty project and a wrong directory are
+    readStudySummary(cwd: string, study: string, options?: ReadStudySummaryOptions): Promise<StudySummary | null>;
+    /** Whether this directory is a humanish project: an empty project and a wrong directory are
      *  different problems and must not share a screen. */
     readProjectState(cwd: string): TuiProjectState;
     /** Open the selected run in the session-owned local evidence server; closes when the TUI exits. */
@@ -72,12 +72,12 @@ export interface TuiCapabilities {
     /** Stop the sandboxes an interrupted run left behind, keeping its evidence. */
     reclaimRun(cwd: string, runId: string): Promise<ReclaimResult>;
     /** End a run that is still going. "analysis" is marker-only regardless of the current status;
-     * it MUST NOT probe or signal a process. The default "run" intent stops the participant process. */
+     * it must not probe or signal a process. The default "run" intent stops the participant process. */
     stopRun(cwd: string, runId: string, intent?: "run" | "analysis"): Promise<TuiActionResult>;
     /**
-     * Set this directory up as a humanish project. The surface's only WRITING action outside of
-     * starting runs — offered because "cd somewhere else and run init" is a dead end shown to
-     * exactly the person who has just arrived (#505).
+     * Set this directory up as a humanish project. The surface's only writing action outside of
+     * starting runs, offered because "cd somewhere else and run init" is a dead end shown to
+     * exactly the person who has just arrived.
      */
     initProject(cwd: string): Promise<TuiActionResult>;
 }
@@ -100,7 +100,7 @@ export interface TuiOptions {
     exitAfterFirstFrame?: boolean;
 }
 /**
- * Start the surface. Resolves with the process exit code when the operator quits — the TUI owns the
+ * Start the surface. Resolves with the process exit code when the operator quits; the TUI owns the
  * screen until then, so the CLI must not write to stdout while this is pending.
  */
 export type TuiHandoff = {
@@ -125,14 +125,14 @@ export declare function nodeSupportsTui(versionString?: string): boolean;
  */
 export declare const TUI_BUNDLE_URL: import("url").URL;
 /**
- * What `doctor` says about the stakeholder surface — a pure function of the machine's state and,
- * crucially, of WHO IS READING.
+ * What `doctor` says about the stakeholder surface: a pure function of the machine's state and,
+ * crucially, of who is reading.
  *
  * A real first-contact study (labs/first-contact.yaml) is why the reader matters. An autonomous
  * agent evaluating humanish read "`humanish tui` is available in an interactive terminal",
- * correctly concluded it was not in one, and dropped it — then wrote a report FOR A HUMAN that
+ * correctly concluded it was not in one, and dropped it, then wrote a report for a human that
  * never mentioned the human surface at all. Discovery worked and handoff did not. A capability
- * described to a reader who cannot use it has to be phrased as something to PASS ON, or it reads
+ * described to a reader who cannot use it has to be phrased as something to pass on, or it reads
  * as "not for you" and dies in the transcript.
  */
 export declare function terminalSurfaceMessage(state: {

package/dist/tui/contract.js

@@ -1,11 +1,11 @@
-// The boundary between the CLI and the terminal UI (#455).
+// The boundary between the CLI and the terminal UI.
 //
-// `humanish tui` loads a PRE-BUILT bundle (dist/tui-app.js) that contains Ink, React and the
-// screens — and nothing else. Everything the surface needs to KNOW is passed across this interface
+// `humanish tui` loads a pre-built bundle (dist/tui-app.js) that contains Ink, React and the
+// screens, and nothing else. Everything the surface needs to know is passed across this interface
 // by the CLI, which imports it from the same modules every other command uses.
 //
 // The reason for the seam: a terminal UI that reads the filesystem itself would become a second
-// implementation of "what is a run, which lab does it belong to, is it alive" — one that ships
+// implementation of "what is a run, which study does it belong to, is it alive", one that ships
 // minified, is invisible to the root test suite, and drifts from `humanish runs` the first time
 // either side changes. Injection keeps exactly one implementation, already unit-tested, and leaves
 // the bundle a view layer that can be reasoned about as one.
@@ -29,14 +29,14 @@ export function nodeSupportsTui(versionString = process.version) {
  */
 export const TUI_BUNDLE_URL = new URL("../tui-app.js", import.meta.url);
 /**
- * What `doctor` says about the stakeholder surface — a pure function of the machine's state and,
- * crucially, of WHO IS READING.
+ * What `doctor` says about the stakeholder surface: a pure function of the machine's state and,
+ * crucially, of who is reading.
  *
  * A real first-contact study (labs/first-contact.yaml) is why the reader matters. An autonomous
  * agent evaluating humanish read "`humanish tui` is available in an interactive terminal",
- * correctly concluded it was not in one, and dropped it — then wrote a report FOR A HUMAN that
+ * correctly concluded it was not in one, and dropped it, then wrote a report for a human that
  * never mentioned the human surface at all. Discovery worked and handoff did not. A capability
- * described to a reader who cannot use it has to be phrased as something to PASS ON, or it reads
+ * described to a reader who cannot use it has to be phrased as something to pass on, or it reads
  * as "not for you" and dies in the transcript.
  */
 export function terminalSurfaceMessage(state) {
@@ -44,9 +44,9 @@ export function terminalSurfaceMessage(state) {
         return `\`humanish tui\` needs Node ${TUI_MIN_NODE_MAJOR}+ (this is ${state.nodeVersion}); every other command works here`;
     }
     if (!state.bundlePresent) {
-        return "`humanish tui` bundle is not built in this checkout — run `pnpm build` (installed packages ship it prebuilt)";
+        return "`humanish tui` is not built in this checkout; run `pnpm build` (installed packages ship it prebuilt)";
     }
     return state.interactive
-        ? "`humanish tui` opens the interactive surface for browsing labs and runs"
-        : "`humanish tui` is the interactive surface a PERSON uses to watch and start runs here — this shell is not a terminal, so pass it on to whoever is";
+        ? "`humanish tui` opens the interactive surface for browsing studies and runs"
+        : "`humanish tui` is the interactive screen a person uses to watch and start runs here. This shell is not a terminal, so pass it on to a person at one";
 }

package/dist/tui/launch.d.ts

@@ -1,10 +1,10 @@
 import { spawn } from "node:child_process";
-export declare function isSafeLabHandle(value: string): boolean;
+export declare function isSafeStudyHandle(value: string): boolean;
 export interface LaunchRunOptions {
     cwd: string;
-    /** The manifest handle (filename stem), as `humanish lab run` takes it. */
-    lab: string;
-    /** Exact selected manifest, avoiding a same-name committed lab shadowing a local copy. */
+    /** The manifest handle (filename stem), as `humanish run` takes it. */
+    study: string;
+    /** Exact selected manifest, avoiding a same-name committed study shadowing a local copy. */
     manifestPath?: string;
     mode: "dry-run" | "live";
     /** Injected in tests; defaults to the real spawn. */
@@ -19,7 +19,7 @@ export interface LaunchedRun {
     /** The spawned CLI's pid. The run's `status.json` stamps the same value. */
     pid: number;
     /**
-     * When the launch happened. A pid ALONE cannot identify a run: pids are recycled by the OS and a
+     * When the launch happened. A pid alone cannot identify a run: pids are recycled by the OS and a
      * finished run keeps its pid in `status.json` forever, so a week-old record can carry the pid the
      * kernel just handed this child. Anything matching on pid must also require the record to be
      * newer than this.
@@ -40,11 +40,11 @@ export type LaunchRunResult = {
         message: string;
     };
 };
-export type LaunchErrorCode = "HUMANISH_LAUNCH_INVALID_LAB" | "HUMANISH_LAUNCH_FAILED";
+export type LaunchErrorCode = "HUMANISH_LAUNCH_INVALID_STUDY" | "HUMANISH_LAUNCH_FAILED";
 /**
  * Start a run and return as soon as it is running. Never throws: a launch that cannot happen is a
  * result the surface can render, not an exception that would tear down the screen.
  */
 export declare function launchRun(options: LaunchRunOptions): Promise<LaunchRunResult>;
-/** Read the tail of a launch log — the only account of a run that died before writing evidence. */
+/** Read the tail of a launch log: the only account of a run that died before writing evidence. */
 export declare function readLaunchLogTail(logPath: string, maxBytes?: number): Promise<string>;