humanish 0.108.0 → 0.109.0

package/dist/run/costs.d.ts

@@ -1,3 +1,4 @@
+import { type PreparedRunArtifactPaths } from "./paths.js";
 import type { RunIndexEntry } from "./run-index.js";
 /** Additive accounting for retained attempts. Null means no estimate, never an invented zero. */
 export interface CostTotals {
@@ -25,3 +26,25 @@ export declare function emptyCostTotals(): CostTotals;
 export declare function addCostTotals(into: CostTotals, next: CostTotals): void;
 /** A read-only, bounded accounting pass. Never validates findings, dispatches, repairs or writes. */
 export declare function readCostTotals(cwd: string, entry: RunIndexEntry): Promise<CostRow>;
+/** One run's analysis history, every distinct attempt counted once. */
+export interface AnalysisAccounting {
+    attempts: number;
+    /** Attempts that sent a request and recorded its usage. */
+    dispatched: number;
+    notDispatched: number;
+    /** Dispatched or possibly dispatched attempts without a complete price. */
+    unpriced: number;
+    /** A dispatch marker survives with no usable final accounting. */
+    unresolved: number;
+    /** The known estimates of the dispatched attempts; 0 when every attempt sent nothing. */
+    estimatedUsd: number | null;
+    /** Who billed the dispatched attempts. */
+    providers: Array<"openai" | "codex">;
+    /** History that could not be read whole; ANALYSIS_HISTORY_NOT_RECORDED when there is none. */
+    warnings: string[];
+}
+/**
+ * The single reader of a run's analysis spend. Stats totals and every surface that shows one
+ * run's cost read it, so they cannot disagree. Receipts are read without opening evidence.
+ */
+export declare function readAnalysisAccounting(prepared: PreparedRunArtifactPaths): Promise<AnalysisAccounting>;

package/dist/run/costs.js

@@ -87,49 +87,14 @@ export async function readCostTotals(cwd, entry) {
             costs.incompleteRunEstimates = 1;
             runWarnings.push("RUN_COST_COMPLETENESS_UNKNOWN");
         }
-        const [history, automatic] = await Promise.all([
-            readAnalysisAccountingRecords(prepared),
-            readAutomaticAnalysisAccounting(prepared),
-        ]);
-        analysisWarnings.push(...history.warnings);
-        const records = new Map(history.records.map((record) => [record.id, record]));
-        if (automatic === "unknown")
-            analysisWarnings.push("AUTOMATIC_ANALYSIS_ACCOUNTING_UNKNOWN");
-        else if (automatic) {
-            if (automatic.uncertain)
-                analysisWarnings.push("AUTOMATIC_ANALYSIS_ACCOUNTING_UNKNOWN");
-            const id = automatic.reused ? automatic.analysisId : automatic.attemptId;
-            if (id && (automatic.started || automatic.analysisId !== null) && !records.has(id)) {
-                records.set(id, { id, receipt: null, start: null, legacy: false });
-            }
-        }
-        for (const record of records.values()) {
-            costs.analysisAttempts += 1;
-            if (record.legacy)
-                analysisWarnings.push("ANALYSIS_LEGACY_REPORT_ACCOUNTING");
-            const usage = record.receipt?.usage;
-            if (!usage) {
-                costs.analysisUnpricedAttempts += 1;
-                costs.analysisUnresolvedAttempts += 1;
-                continue;
-            }
-            if (!usage.dispatched) {
-                costs.analysisNotDispatchedAttempts += 1;
-                costs.analysisEstimatedUsd = sumKnown(costs.analysisEstimatedUsd, 0);
-            }
-            else {
-                costs.analysisDispatchedAttempts += 1;
-                if (isKnownUsd(usage.estimatedCostUsd)) {
-                    costs.analysisEstimatedUsd = sumKnown(costs.analysisEstimatedUsd, usage.estimatedCostUsd);
-                }
-                if (!isKnownUsd(usage.estimatedCostUsd) || !usage.usageComplete)
-                    costs.analysisUnpricedAttempts += 1;
-            }
-        }
-        // A skipped/queued automatic job says nothing about historical manual requests.
-        // Only final no-dispatch receipts contribute a supported zero to recorded attempts.
-        if (records.size === 0)
-            analysisWarnings.push("ANALYSIS_HISTORY_NOT_RECORDED");
+        const analysis = await readAnalysisAccounting(prepared);
+        analysisWarnings.push(...analysis.warnings);
+        costs.analysisAttempts = analysis.attempts;
+        costs.analysisDispatchedAttempts = analysis.dispatched;
+        costs.analysisNotDispatchedAttempts = analysis.notDispatched;
+        costs.analysisUnpricedAttempts = analysis.unpriced;
+        costs.analysisUnresolvedAttempts = analysis.unresolved;
+        costs.analysisEstimatedUsd = analysis.estimatedUsd;
         costs.analysisHistoryUncertainRuns = analysisWarnings.length > 0 ? 1 : 0;
     }
     catch {
@@ -144,3 +109,67 @@ export async function readCostTotals(cwd, entry) {
         warnings: [...new Set([...runWarnings, ...analysisWarnings])],
     };
 }
+/**
+ * The single reader of a run's analysis spend. Stats totals and every surface that shows one
+ * run's cost read it, so they cannot disagree. Receipts are read without opening evidence.
+ */
+export async function readAnalysisAccounting(prepared) {
+    const accounting = {
+        attempts: 0,
+        dispatched: 0,
+        notDispatched: 0,
+        unpriced: 0,
+        unresolved: 0,
+        estimatedUsd: null,
+        providers: [],
+        warnings: [],
+    };
+    const [history, automatic] = await Promise.all([
+        readAnalysisAccountingRecords(prepared),
+        readAutomaticAnalysisAccounting(prepared),
+    ]);
+    accounting.warnings.push(...history.warnings);
+    const records = new Map(history.records.map((record) => [record.id, record]));
+    if (automatic === "unknown")
+        accounting.warnings.push("AUTOMATIC_ANALYSIS_ACCOUNTING_UNKNOWN");
+    else if (automatic) {
+        if (automatic.uncertain)
+            accounting.warnings.push("AUTOMATIC_ANALYSIS_ACCOUNTING_UNKNOWN");
+        const id = automatic.reused ? automatic.analysisId : automatic.attemptId;
+        if (id && (automatic.started || automatic.analysisId !== null) && !records.has(id)) {
+            records.set(id, { id, receipt: null, start: null, legacy: false });
+        }
+    }
+    const providers = new Set();
+    for (const record of records.values()) {
+        accounting.attempts += 1;
+        if (record.legacy)
+            accounting.warnings.push("ANALYSIS_LEGACY_REPORT_ACCOUNTING");
+        const usage = record.receipt?.usage;
+        if (!usage) {
+            accounting.unpriced += 1;
+            accounting.unresolved += 1;
+            continue;
+        }
+        if (!usage.dispatched) {
+            accounting.notDispatched += 1;
+            accounting.estimatedUsd = sumKnown(accounting.estimatedUsd, 0);
+            continue;
+        }
+        accounting.dispatched += 1;
+        if (record.receipt)
+            providers.add(record.receipt.provider);
+        if (isKnownUsd(usage.estimatedCostUsd)) {
+            accounting.estimatedUsd = sumKnown(accounting.estimatedUsd, usage.estimatedCostUsd);
+        }
+        if (!isKnownUsd(usage.estimatedCostUsd) || !usage.usageComplete)
+            accounting.unpriced += 1;
+    }
+    // A skipped or queued automatic job says nothing about earlier manual requests. Only final
+    // no-dispatch receipts contribute a supported zero.
+    if (records.size === 0)
+        accounting.warnings.push("ANALYSIS_HISTORY_NOT_RECORDED");
+    accounting.providers = [...providers].sort();
+    accounting.warnings = [...new Set(accounting.warnings)];
+    return accounting;
+}

package/dist/run/dry-run-inputs.d.ts

@@ -1,4 +1,4 @@
-import { type ResolvedPersona } from "../lab/persona.js";
+import { type ResolvedPersona } from "../study/persona.js";
 import type { PreparedSelectedOutputDirectory } from "./contained-output.js";
 import type { RunBundle } from "./bundle.js";
 export declare function loadDryRunInputs(projectRoot: PreparedSelectedOutputDirectory, humanishSource: "present" | "missing"): Promise<{

package/dist/run/dry-run-inputs.js

@@ -1,5 +1,5 @@
 import { parse as parseYaml } from "yaml";
-import { parseResolvedPersona } from "../lab/persona.js";
+import { parseResolvedPersona } from "../study/persona.js";
 import { digestText } from "../evidence/redaction.js";
 import { readImplicitProjectFile } from "./project.js";
 import { escapeRegExp } from "./text.js";

package/dist/run/dry-run.js

@@ -40,7 +40,7 @@ async function runDryRunInScope(options, scope) {
             message: "--count must be a positive integer.",
         });
     }
-    // Bind the physical project, as the lab routes do: a symlinked cwd retargeted mid-run cannot
+    // Bind the physical project, as the routes do: a symlinked cwd retargeted mid-run cannot
     // redirect source reads or run storage into another project.
     const physicalCwd = await realpath(requestedCwd);
     const projectRoot = await prepareSelectedOutputDirectory(path.dirname(physicalCwd), physicalCwd);
@@ -64,7 +64,7 @@ async function runDryRunInScope(options, scope) {
         runId: options.runId,
         mintRunId: () => `dryrun-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`,
         mode: options.dryRun ? "dry-run" : "live",
-        lab: options.lab,
+        study: options.study,
         renderReview: renderReviewMarkdown,
         // The run starts at the time its id and source were stamped with.
         now: () => Date.parse(createdAt),

package/dist/run/outcomes.d.ts

@@ -1,6 +1,6 @@
 import { type ActorStatus } from "../actors/contract.js";
 import { type CuaGoalSource } from "../actors/goal-source.js";
-import type { TaskFunnel } from "../lab/tasks.js";
+import type { TaskFunnel } from "../study/tasks.js";
 import type { ParticipantOutcomes, ReviewSummary, RunTaskFunnel } from "./bundle.js";
 /** Tally participant outcomes from actor statuses. Statuses this does not recognise are counted in
  *  `total` but nowhere else, so the parts can never exceed the whole. */

package/dist/run/participant.d.ts

@@ -1,5 +1,5 @@
 import type { ActorPersonaRef } from "../actors/contract.js";
-import type { Participant } from "../lab/plan-participants.js";
+import type { Participant } from "../study/plan-participants.js";
 import type { RunParticipantAssignment } from "./streams.js";
 /**
  * A planned participant resolved for one run: the plan's record unchanged, plus what the route

package/dist/run/preflight-receipts.js

@@ -1,4 +1,4 @@
-// Sandbox receipts for `humanish lab preflight`. A probe has no run directory, so it journals its
+// Sandbox receipts for `humanish study check`. A probe has no run directory, so it journals its
 // sandbox under .humanish/preflight/<probe-id>/ before any work runs in it. A confirmed kill
 // removes the journal. A journal that stays means the probe's sandbox may still be running, and
 // `humanish reclaim --preflight` kills it by the recorded id once it is safe to.

package/dist/run/pricing.js

@@ -67,7 +67,7 @@ export const MODEL_RATES = {
     // cyber = the Daybreak frontier tier.
     "gpt-5.6-sol": rateWithLongContextTier(4, 0.4, 5, 20, GPT56_SOL_PROMO_AS_OF),
     // "gpt-5.6" is OpenAI's own alias for gpt-5.6-sol (models index); priced identically so a
-    // lab configured with the alias never reads as unpriced.
+    // study configured with the alias never reads as unpriced.
     "gpt-5.6": rateWithLongContextTier(4, 0.4, 5, 20, GPT56_SOL_PROMO_AS_OF),
     "gpt-5.6-terra": rateWithLongContextTier(2, 0.2, 2.5, 12),
     "gpt-5.6-luna": rateWithLongContextTier(0.2, 0.02, 0.25, 1.2),
@@ -79,7 +79,7 @@ export const MODEL_RATES = {
     "daybreak-red-latest": rateWithLongContextTier(12.5, 1.25, 15.625, 75),
     // gpt-6-astra (shipped 2026-09-03; API access announced as rolling out). Same two mechanics
     // as the 5.6 family on the sheet: writes at 1.25x, >272K re-tiers at 2x input-side / 1.5x
-    // output ($20 / $2 / $25 / $75 long-context columns). These rates cover explicit lab
+    // output ($20 / $2 / $25 / $75 long-context columns). These rates cover explicit study
     // model choices and the study-analysis default; the computer-use default is separate.
     "gpt-6-astra": rateWithLongContextTier(10, 1, 12.5, 50, GPT6_ASTRA_AS_OF, GPT6_ASTRA_SOURCE),
 };

package/dist/run/projection.d.ts

@@ -1,32 +1,32 @@
 import type { RunIndexEntry } from "./run-index.js";
-/** One lab as the labs list shows it. */
-export interface LabRollup {
-    labId: string;
-    /** Total runs attributed to this lab. */
+/** One study as the study list shows it. */
+export interface StudyRollup {
+    studyId: string;
+    /** Total runs attributed to this study. */
     runs: number;
     /** Runs whose status record is fresh right now. */
     live: number;
-    /** The newest run of this lab, whatever its state. */
+    /** The newest run of this study, whatever its state. */
     latest?: RunIndexEntry;
     /** Live runs, newest first; the labs list shows the first one inline. */
     liveRuns: RunIndexEntry[];
 }
 /**
- * Group runs by lab, newest-first within each lab and by recency between labs. Runs with no lab
+ * Group runs by study, newest-first within each study and by recency between studies. Runs with no study
  * attribution are collected under `unattributed` rather than invented into a study. That is the
  * home for pre-contract runs and library callers.
  */
-export declare function groupRunsByLab(entries: readonly RunIndexEntry[]): {
-    labs: LabRollup[];
+export declare function groupRunsByStudy(entries: readonly RunIndexEntry[]): {
+    studies: StudyRollup[];
     unattributed: RunIndexEntry[];
 };
 /**
- * What the launch screen may claim about a lab, and on what evidence. Every figure carries the
+ * What the launch screen may claim about a study, and on what evidence. Every figure carries the
  * number of runs it came from; `sample: 0` means there is nothing to claim and the caller must
  * say so rather than showing an empty number.
  */
-export interface LabExpectation {
-    /** How many completed runs of this lab the figures are drawn from. */
+export interface StudyExpectation {
+    /** How many completed runs of this study the figures are drawn from. */
     sample: number;
     medianDurationMs?: number;
     /** Range across the sample, so the UI can show a span instead of a false point estimate. */
@@ -40,7 +40,7 @@ export interface LabExpectation {
     costUnknown: number;
 }
 /**
- * Derive what to expect from a lab's own history. Only finished runs count: an interrupted run's
+ * Derive what to expect from a study's own history. Only finished runs count: an interrupted run's
  * duration is the length of an accident, not of a study, and including it would quietly bias the
  * estimate the operator uses to decide whether to press Start.
  *
@@ -49,22 +49,22 @@ export interface LabExpectation {
  * next to a control that spends money. Pass the mode the figure is about; omit it only for a
  * summary that is not attached to an action.
  */
-export declare function expectationFor(entries: readonly RunIndexEntry[], mode?: "dry-run" | "live"): LabExpectation;
+export declare function expectationFor(entries: readonly RunIndexEntry[], mode?: "dry-run" | "live"): StudyExpectation;
 /**
  * The one sentence the launch screen shows about time and money, with its denominator attached.
- * A lab with no history says so plainly instead of borrowing another lab's numbers or inventing
+ * A study with no history says so plainly instead of borrowing another study's numbers or inventing
  * a range. "No runs yet" is information, and the operator can still press Start.
  */
-export declare function expectationLine(expectation: LabExpectation): string;
+export declare function expectationLine(expectation: StudyExpectation): string;
 /**
- * The one line a lab may say about itself, wherever it is shown.
+ * The one line a study may say about itself, wherever it is shown.
  *
  * Prefers live figures: cost and duration are what someone reads before spending, and a median
  * diluted by dry runs reports a live study as cheaper and faster than it has ever been. With no
  * live history it reports the count and claims nothing about time or money. That is why this is
  * shared rather than reimplemented per surface, since the two disagreeing is the whole failure.
  */
-export declare function labSummaryLine(row: Pick<LabRow, "runs" | "declared" | "expectation" | "liveExpectation">): string;
+export declare function studySummaryLine(row: Pick<StudyRow, "runs" | "declared" | "expectation" | "liveExpectation">): string;
 /** Compact duration: seconds under a minute, then m/s, then h/m. */
 export declare function formatDuration(ms: number): string;
 export interface NormalizedThought {
@@ -101,16 +101,16 @@ export declare function listWindow(args: {
 };
 /** The label for a run's state, in the register the surfaces share. */
 export declare function livenessLabel(entry: Pick<RunIndexEntry, "liveness" | "verdict">): string;
-/** A lab as the labs list shows it: what is declared, joined to what actually happened. */
-export interface LabRow {
+/** A study as the study list shows it: what is declared, joined to what actually happened. */
+export interface StudyRow {
     /**
-     * Stable identity for this row. A manifest's path when it has one, else the lab id, because two
+     * Stable identity for this row. A manifest's path when it has one, else the study id, because two
      * manifests can declare the same id, and keying rows by id makes them collapse into a pair of
      * indistinguishable duplicates.
      */
     key: string;
     /** The declared id. Run history attributes to this, so it is not unique across manifests. */
-    labId: string;
+    studyId: string;
     /**
      * The handle an operator would actually type. Lab resolution is by filename, so the manifest
      * `\`.humanish/labs/persona-contrast-live.yaml\`` is reached as `persona-contrast-live` even when
@@ -121,24 +121,24 @@ export interface LabRow {
     title?: string;
     /**
      * The shortest label that is unique among the rows it is listed with: the title when no other
-     * lab shares it, else the filename, else the full path. A list is only navigable if every row can
+     * study shares it, else the filename, else the full path. A list is only navigable if every row can
      * be told from every other one, and a title is not guaranteed to be distinct: two manifests in
      * this repo carry the same title and the same declared id, differing only by filename.
      */
     label: string;
     /** The manifest's own words, for the list to say what this study is. */
     description?: string;
-    /** Repo-relative manifest path, absent for a lab known only from run history. */
+    /** Repo-relative manifest path, absent for a study known only from run history. */
     path?: string;
     origin?: "committed" | "ignored" | "explicit";
     /**
-     * False for a lab that has runs but no manifest here: renamed, deleted, or run from a path that
+     * False for a study that has runs but no manifest here: renamed, deleted, or run from a path that
      * is gone. Its runs are still evidence and must stay reachable, so it is listed and marked rather
      * than dropped.
      */
     declared: boolean;
     /**
-     * How many other manifests declare this same lab id. Above zero, the run history below is shared
+     * How many other manifests declare this same study id. Above zero, the run history below is shared
      * between them and cannot be attributed to one file. That is worth saying, because it is a
      * misconfiguration the operator almost certainly does not know about.
      */
@@ -148,11 +148,11 @@ export interface LabRow {
     latest?: RunIndexEntry;
     liveRuns: RunIndexEntry[];
     /** Across every finished run, whatever its mode. A summary, never attached to a spend decision. */
-    expectation: LabExpectation;
+    expectation: StudyExpectation;
     /** Live runs only: the figure that belongs beside anything that spends money. */
-    liveExpectation: LabExpectation;
+    liveExpectation: StudyExpectation;
 }
-export interface DeclaredLab {
+export interface DeclaredStudy {
     id: string;
     title?: string;
     /** The manifest's own description, so a list of studies can say what each one is. */
@@ -161,7 +161,7 @@ export interface DeclaredLab {
     origin?: "committed" | "ignored" | "explicit";
 }
 /**
- * Join declared lab manifests to run history.
+ * Join declared study manifests to run history.
  *
  * Neither side alone is the truth. A fresh project has manifests and no runs, and those labs are the
  * whole screen, and a list built only from history would be empty on exactly the first visit that
@@ -174,11 +174,11 @@ export interface DeclaredLab {
  * share an id. Collapsing them hides a real file; keying by id duplicates a row with no way to tell
  * the copies apart. Both happen in practice: this repo has exactly that pair.
  *
- * Order puts a lab someone is working in first, then labs by how recently they ran, then declared
+ * Order puts a study someone is working in first, then studies by how recently they ran, then declared
  * labs that have never run (alphabetically by the displayed label, so the order on screen is the
  * order a reader can predict), then labs known only from history.
  */
-export declare function labRows(declared: readonly DeclaredLab[], entries: readonly RunIndexEntry[]): {
-    rows: LabRow[];
+export declare function studyRows(declared: readonly DeclaredStudy[], entries: readonly RunIndexEntry[]): {
+    rows: StudyRow[];
     unattributed: RunIndexEntry[];
 };

package/dist/run/projection.js

@@ -1,5 +1,5 @@
 // The disk→view-model projection. Pure functions, no I/O, no rendering: this is where
-// lab grouping, the trust line's arithmetic, thought normalization and list-window math live, so
+// study grouping, the trust line's arithmetic, thought normalization and list-window math live, so
 // the parts most likely to be wrong are testable without a terminal.
 //
 // The rules these encode, because they are the ones a UI is most tempted to break:
@@ -8,42 +8,42 @@
 //   - truncation is reported, never silent;
 //   - a participant's reported thinking is quoted, never paraphrased or summarized.
 /**
- * Group runs by lab, newest-first within each lab and by recency between labs. Runs with no lab
+ * Group runs by study, newest-first within each study and by recency between studies. Runs with no study
  * attribution are collected under `unattributed` rather than invented into a study. That is the
  * home for pre-contract runs and library callers.
  */
-export function groupRunsByLab(entries) {
-    const byLab = new Map();
+export function groupRunsByStudy(entries) {
+    const byStudy = new Map();
     const unattributed = [];
     for (const entry of entries) {
-        const labId = entry.study?.id;
-        if (labId === undefined) {
+        const studyId = entry.study?.id;
+        if (studyId === undefined) {
             unattributed.push(entry);
             continue;
         }
-        const bucket = byLab.get(labId);
+        const bucket = byStudy.get(studyId);
         if (bucket === undefined)
-            byLab.set(labId, [entry]);
+            byStudy.set(studyId, [entry]);
         else
             bucket.push(entry);
     }
-    const labs = [...byLab.entries()].map(([labId, runs]) => {
+    const studies = [...byStudy.entries()].map(([studyId, runs]) => {
         const liveRuns = runs.filter((run) => run.liveness === "running");
         return {
-            labId,
+            studyId,
             runs: runs.length,
             live: liveRuns.length,
             ...(runs[0] === undefined ? {} : { latest: runs[0] }),
             liveRuns,
         };
     });
-    // A lab someone is working in sorts first; otherwise most recently used.
-    labs.sort((left, right) => {
+    // A study someone is working in sorts first; otherwise most recently used.
+    studies.sort((left, right) => {
         if (left.live !== right.live)
             return right.live - left.live;
         return recencyOf(right.latest) - recencyOf(left.latest);
     });
-    return { labs, unattributed };
+    return { studies, unattributed };
 }
 function recencyOf(entry) {
     if (entry === undefined)
@@ -58,7 +58,7 @@ function recencyOf(entry) {
     return 0;
 }
 /**
- * Derive what to expect from a lab's own history. Only finished runs count: an interrupted run's
+ * Derive what to expect from a study's own history. Only finished runs count: an interrupted run's
  * duration is the length of an accident, not of a study, and including it would quietly bias the
  * estimate the operator uses to decide whether to press Start.
  *
@@ -103,7 +103,7 @@ function median(sorted) {
 }
 /**
  * The one sentence the launch screen shows about time and money, with its denominator attached.
- * A lab with no history says so plainly instead of borrowing another lab's numbers or inventing
+ * A study with no history says so plainly instead of borrowing another study's numbers or inventing
  * a range. "No runs yet" is information, and the operator can still press Start.
  */
 export function expectationLine(expectation) {
@@ -132,14 +132,14 @@ export function expectationLine(expectation) {
     return `${parts.join(" · ")} · ${sample}${unknown}`;
 }
 /**
- * The one line a lab may say about itself, wherever it is shown.
+ * The one line a study may say about itself, wherever it is shown.
  *
  * Prefers live figures: cost and duration are what someone reads before spending, and a median
  * diluted by dry runs reports a live study as cheaper and faster than it has ever been. With no
  * live history it reports the count and claims nothing about time or money. That is why this is
  * shared rather than reimplemented per surface, since the two disagreeing is the whole failure.
  */
-export function labSummaryLine(row) {
+export function studySummaryLine(row) {
     if (row.runs === 0)
         return row.declared ? "never run" : "no runs";
     if (row.liveExpectation.sample > 0)
@@ -240,12 +240,12 @@ export function livenessLabel(entry) {
     }
 }
 /** The addressable handle for a manifest: its filename without directory or extension. */
-function labNameFromPath(manifestPath) {
+function studyNameFromPath(manifestPath) {
     const base = manifestPath.split("/").pop() ?? manifestPath;
     return base.replace(/\.(ya?ml)$/i, "");
 }
 /**
- * Join declared lab manifests to run history.
+ * Join declared study manifests to run history.
  *
  * Neither side alone is the truth. A fresh project has manifests and no runs, and those labs are the
  * whole screen, and a list built only from history would be empty on exactly the first visit that
@@ -258,57 +258,57 @@ function labNameFromPath(manifestPath) {
  * share an id. Collapsing them hides a real file; keying by id duplicates a row with no way to tell
  * the copies apart. Both happen in practice: this repo has exactly that pair.
  *
- * Order puts a lab someone is working in first, then labs by how recently they ran, then declared
+ * Order puts a study someone is working in first, then studies by how recently they ran, then declared
  * labs that have never run (alphabetically by the displayed label, so the order on screen is the
  * order a reader can predict), then labs known only from history.
  */
-export function labRows(declared, entries) {
-    const { labs, unattributed } = groupRunsByLab(entries);
-    const byId = new Map(labs.map((lab) => [lab.labId, lab]));
+export function studyRows(declared, entries) {
+    const { studies, unattributed } = groupRunsByStudy(entries);
+    const byId = new Map(studies.map((study) => [study.studyId, study]));
     const runsOf = new Map();
     for (const entry of entries) {
-        const labId = entry.study?.id;
-        if (labId === undefined)
+        const studyId = entry.study?.id;
+        if (studyId === undefined)
             continue;
-        const bucket = runsOf.get(labId);
+        const bucket = runsOf.get(studyId);
         if (bucket === undefined)
-            runsOf.set(labId, [entry]);
+            runsOf.set(studyId, [entry]);
         else
             bucket.push(entry);
     }
     const idCounts = new Map();
-    for (const lab of declared)
-        idCounts.set(lab.id, (idCounts.get(lab.id) ?? 0) + 1);
-    const build = (labId, manifest, isDeclared) => {
-        const rollup = byId.get(labId);
+    for (const study of declared)
+        idCounts.set(study.id, (idCounts.get(study.id) ?? 0) + 1);
+    const build = (studyId, manifest, isDeclared) => {
+        const rollup = byId.get(studyId);
         const manifestPath = manifest?.path;
         return {
-            key: manifestPath ?? `id:${labId}`,
-            labId,
-            name: manifestPath === undefined ? labId : labNameFromPath(manifestPath),
+            key: manifestPath ?? `id:${studyId}`,
+            studyId,
+            name: manifestPath === undefined ? studyId : studyNameFromPath(manifestPath),
             ...(manifest?.title === undefined ? {} : { title: manifest.title }),
             ...(manifestPath === undefined ? {} : { path: manifestPath }),
             ...(manifest?.origin === undefined ? {} : { origin: manifest.origin }),
             declared: isDeclared,
             // Replaced by assignLabels once the whole set is known; a label is only meaningful relative
             // to the rows it sits beside.
-            label: manifest?.title ?? (manifestPath === undefined ? labId : labNameFromPath(manifestPath)),
+            label: manifest?.title ?? (manifestPath === undefined ? studyId : studyNameFromPath(manifestPath)),
             ...(manifest?.description === undefined ? {} : { description: manifest.description }),
-            sharesIdWith: Math.max(0, (idCounts.get(labId) ?? 0) - 1),
+            sharesIdWith: Math.max(0, (idCounts.get(studyId) ?? 0) - 1),
             runs: rollup?.runs ?? 0,
             live: rollup?.live ?? 0,
             ...(rollup?.latest === undefined ? {} : { latest: rollup.latest }),
             liveRuns: rollup?.liveRuns ?? [],
-            expectation: expectationFor(runsOf.get(labId) ?? []),
-            liveExpectation: expectationFor(runsOf.get(labId) ?? [], "live"),
+            expectation: expectationFor(runsOf.get(studyId) ?? []),
+            liveExpectation: expectationFor(runsOf.get(studyId) ?? [], "live"),
         };
     };
-    const declaredIds = new Set(declared.map((lab) => lab.id));
+    const declaredIds = new Set(declared.map((study) => study.id));
     const rows = [
-        ...declared.map((lab) => build(lab.id, lab, true)),
-        ...labs
-            .filter((lab) => !declaredIds.has(lab.labId))
-            .map((lab) => build(lab.labId, undefined, false)),
+        ...declared.map((study) => build(study.id, study, true)),
+        ...studies
+            .filter((study) => !declaredIds.has(study.studyId))
+            .map((study) => build(study.studyId, undefined, false)),
     ];
     // Resolve each row's label before sorting, so the list is ordered by what a reader actually sees.
     assignLabels(rows);
@@ -334,7 +334,7 @@ export function labRows(declared, entries) {
  *
  * Falling straight back to the filename whenever a title repeats, instead of decorating the
  * duplicate with a suffix, keeps the label something the operator can act on, because the filename
- * is exactly what `humanish lab run` takes.
+ * is exactly what `humanish run` takes.
  */
 function assignLabels(rows) {
     const count = (values) => {

package/dist/run/reclaim.d.ts

@@ -38,7 +38,7 @@ export declare function reclaimRunSandboxes(cwd: string, runInput: string, hooks
  */
 export declare function reclaimPinnedRunSandboxes(cwd: string, runPaths: PreparedRunArtifactPaths, hooks?: ReclaimHooks): Promise<ReclaimResult>;
 /**
- * Kill the sandboxes left by interrupted `humanish lab preflight` probes. A probe journals under
+ * Kill the sandboxes left by interrupted `humanish study check` probes. A probe journals under
  * .humanish/preflight/<probe-id>/ and removes the journal after a confirmed kill, so what is left
  * belongs to a probe that died or could not confirm its teardown. A journal whose probe may still
  * be running is left alone with the reason (see preflightReclaimDecision).

package/dist/run/reclaim.js

@@ -80,7 +80,7 @@ async function reclaimRun(cwd, runInput, locate, hooks) {
     return result;
 }
 /**
- * Kill the sandboxes left by interrupted `humanish lab preflight` probes. A probe journals under
+ * Kill the sandboxes left by interrupted `humanish study check` probes. A probe journals under
  * .humanish/preflight/<probe-id>/ and removes the journal after a confirmed kill, so what is left
  * belongs to a probe that died or could not confirm its teardown. A journal whose probe may still
  * be running is left alone with the reason (see preflightReclaimDecision).