humanish 0.108.0 → 0.109.1

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

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

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

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

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

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

package/dist/cli/commands/study.js

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

package/dist/cli/commands/tui.js

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

package/dist/cli/commands/watch.js

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

package/dist/cli/deprecations.d.ts

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

package/dist/cli/deprecations.js

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

package/dist/cli/doctor.d.ts

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