humanish 0.106.1 → 0.108.0

package/dist/run/streams.d.ts

@@ -1,5 +1,5 @@
 import type { CodexAppServerTrace } from "../actors/codex/app-server-trace.js";
-import type { ActorTrace, ActorTraceItem } from "../actors/contract.js";
+import type { ActorStatus, ActorTrace, ActorTraceItem } from "../actors/contract.js";
 import type { RunDesktopRecording } from "../evidence/desktop-recording-types.js";
 export type RunStreamKind = "ui" | "browser" | "terminal" | "tui" | "codex-ui" | "artifact" | "summary";
 export type RunSimulationStatus = "queued" | "preparing" | "running" | "passed" | "abandoned" | "incomplete" | "complete" | "blocked" | "timed_out" | "failed" | "contract_proof_only";
@@ -29,10 +29,10 @@ interface RunStreamCompletion {
     meaningfulUse?: RunMeaningfulUseScore;
 }
 /**
- * The CLOSED set of core meaningful-use scoring components. Closed by design: these are the generic
+ * The closed set of core meaningful-use scoring components. Closed by design: these are the generic
  * dimensions core itself meters (setup/filesystem/nested/actor/product/feedback). A
- * product-specific scorecard does NOT extend this enum, so adopters' nouns stay out of core. It
- * ships as a thin in-repo extension that emits a namespaced `RunAdapterScore` via the lane's
+ * product-specific scorecard does not extend this enum, so adopters' nouns stay out of core. It
+ * ships as a thin in-repo extension that emits a namespaced `RunAdapterScore` via the route's
  * `score` hook, leaving its own component breakdown in that score's `data`. Exported so a thin
  * adapter can type against core's score shape without forking.
  */
@@ -64,14 +64,14 @@ export interface RunDesktopGeometry {
             source: "xdpyinfo";
         };
         /**
-         * The device preset as DECLARED by the lab, present only when it differs from `requested`
+         * The device preset as declared by the lab, present only when it differs from `requested`
          * because the rendered width was floored to MIN_DESKTOP_RENDER_WIDTH.
          *
          * Without this, a floored run is indistinguishable from a faithful one: `verified` compares
          * the floored number with itself and reports a match, so a reader of the bundle sees
          * requested 500 / verified 500 and reasonably concludes a 500-wide preset was asked for. A
-         * `mobile` (414) and a `small-mobile` (360) seat both render at 500 and look identical here.
-         * When this field is set, the preset width did NOT render; see #221.
+         * `mobile` (414) and a `small-mobile` (360) participant both render at 500 and look identical
+         * here. When this field is set, the preset width did not render.
          */
         declared?: {
             width: number;
@@ -96,7 +96,7 @@ export interface RunDesktopGeometry {
         source: "cdp";
     };
     /**
-     * Mobile fidelity beyond viewport size (#221), present only when the lab asked for it. `requested`
+     * Mobile fidelity beyond viewport size, present only when the lab asked for it. `requested`
      * is what was applied through CDP; `resolved` is what the page reported about itself afterwards
      * and is the proof, never copied from the request. A run without this block is a
      * responsive-viewport study, whatever its preset is named.
@@ -121,10 +121,10 @@ export interface RunDesktopGeometry {
             source: "cdp";
         };
         /**
-         * Page targets the participant drove AFTER the launch page (a link that opened in a new tab)
-         * whose own read-back reported the requested viewport width (#623). Absent when the
-         * participant never left the launch tab; a later tab that did NOT report the width is a lane
-         * warning instead.
+         * Page targets the participant drove after the launch page (a link that opened in a new tab)
+         * whose own read-back reported the requested viewport width. Absent when the
+         * participant never left the launch tab; a later tab that did not report the width is a
+         * participant warning instead.
          */
         laterTargets?: {
             targetId: string;
@@ -154,20 +154,27 @@ export interface RunParticipantAssignment {
 export interface RunStream {
     id: string;
     simId: string;
-    /** Adapter-owned lane id for fan-out / target-swarm runs. Safe categorical metadata only. */
+    /** Adapter-owned participant id for fan-out / target-swarm runs. Safe categorical metadata only. */
     laneId?: string;
-    /** Adapter-owned actor class for grouping lanes, e.g. viewer/reviewer/admin. */
+    /** Adapter-owned actor class for grouping participants, e.g. viewer/reviewer/admin. */
     actorType?: string;
-    /** Adapter-owned product surface label for grouping lanes without parsing URLs. */
+    /** Adapter-owned product surface label for grouping participants without parsing URLs. */
     surface?: string;
     /** Adapter-owned scenario/case grouping label. */
     caseGroup?: string;
-    /** Authored/default mission and lane focus, redacted before persistence. Missing on older
+    /** Authored/default mission and participant focus, redacted before persistence. Missing on older
      * bundles and uninstrumented routes; never reconstructed from study context or narration. */
     assignment?: RunParticipantAssignment;
     kind: RunStreamKind;
     label: string;
     status: RunSimulationStatus;
+    /**
+     * The judge's status for this participant (`judgedStatus` in src/run/judge.ts). It differs from
+     * the trace status when a goal_satisfied session reported a blocker or never engaged. Computer-use
+     * fan-out writes it for a finished live participant; rerun selection reads it. Absent elsewhere,
+     * and in bundles written before it existed.
+     */
+    judgedStatus?: ActorStatus;
     transport: "snapshot" | "polling" | "sse" | "pty" | "app-server";
     updatedAt: string;
     url?: string;
@@ -176,7 +183,7 @@ export interface RunStream {
         url?: string;
         title?: string;
     };
-    /** Set by the attached watch server when the lane's sandbox is gone: the injected live URL
+    /** Set by the attached watch server when the participant's sandbox is gone: the injected live URL
      *  would render a provider error page, so viewers fall back to recorded evidence. Runtime-only
      *  and never persisted into bundles; declared here because the served observer-data carries it
      *  and the client is typed against this contract. */
@@ -192,7 +199,7 @@ export interface RunStream {
         deviceScaleFactor?: number;
         isMobile?: boolean;
     };
-    /** Truthful screen/window/viewport evidence for hosted desktop browser lanes. */
+    /** Truthful screen/window/viewport evidence for hosted desktop browser participants. */
     desktopGeometry?: RunDesktopGeometry;
     terminal?: {
         title: string;
@@ -227,10 +234,10 @@ export interface RunStream {
     };
     actor?: ActorTrace;
     /**
-     * Mid-run partial actor evidence (#441): the redacted trace items recorded SO FAR,
-     * flushed while a live lane is still running so the attached Observer's timeline can
-     * grow. Deliberately NOT an ActorTrace — a running lane has no honest status,
-     * completionReason, or completedAt, and this shape cannot claim them. Present ONLY on
+     * Mid-run partial actor evidence: the redacted trace items recorded so far,
+     * flushed while a live participant is still running so the attached Observer's timeline can
+     * grow. It is deliberately not an ActorTrace: a running participant has no final status,
+     * completionReason, or completedAt, and this shape cannot claim them. Present only on
      * `inProgress` bundles; the final write replaces it with the real `actor` and never
      * carries it.
      */

package/dist/run/study-provenance.d.ts

@@ -0,0 +1,47 @@
+/** Which study a run came from, when it came from one. */
+export interface RunStudyProvenance {
+    /** The study id its file declares (`config.id`). */
+    id: string;
+    /** Project-relative path of the study file, when the run came from a file on disk. */
+    path?: string;
+    /**
+     * `committed` = humanish/studies or humanish/labs, `ignored` = a local overlay, `explicit` = a
+     * path the operator passed.
+     */
+    origin?: "committed" | "ignored" | "explicit";
+}
+/** Whether a saved record's `study` or `lab` field is absent or shaped like a provenance. */
+export declare function isProvenanceField(value: unknown): boolean;
+/**
+ * A saved record's study: a valid `study`, else a valid `lab`, else the id its persona or scenario
+ * source names by convention.
+ */
+export declare function studyProvenanceOf(record: {
+    study?: unknown;
+    lab?: unknown;
+    persona?: {
+        source?: unknown;
+    };
+    scenario?: {
+        source?: unknown;
+    };
+}): RunStudyProvenance | undefined;
+/** `study` and `lab` with the same value, as run.json and status.json write them until 0.109. */
+export declare function studyFields(study: RunStudyProvenance | undefined): {
+    study?: RunStudyProvenance;
+    lab?: RunStudyProvenance;
+};
+/**
+ * The study id a run names by the `study:<id>` or `lab:<id>` convention on its persona or scenario
+ * source, the only attribution a run written before `lab` and `study` has. A prefix with an empty
+ * remainder is not an id. Ids may contain colons (`lab:oss:meta`), so only the prefix is stripped.
+ * Readers keep both prefixes for good: saved runs say `lab:`.
+ */
+export declare function inferLegacyStudyId(bundle: {
+    persona?: {
+        source?: unknown;
+    };
+    scenario?: {
+        source?: unknown;
+    };
+}): string | undefined;

package/dist/run/study-provenance.js

@@ -0,0 +1,63 @@
+// Which study a saved run came from. run.json and status.json write it as `study`, and as `lab`
+// with the same value until 0.109 drops `lab`. Every reader goes through
+// studyProvenanceOf, which also reads a run older than both fields by the `study:<id>` or
+// `lab:<id>` convention on its persona and scenario sources.
+const ORIGINS = ["committed", "ignored", "explicit"];
+/** `value` as a provenance when it has an id, keeping only its fields that are valid. */
+function provenance(value) {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const record = value;
+    if (typeof record.id !== "string" || record.id === "")
+        return undefined;
+    const origin = record.origin;
+    return {
+        id: record.id,
+        ...(typeof record.path === "string" ? { path: record.path } : {}),
+        ...(typeof origin === "string" && ORIGINS.includes(origin)
+            ? { origin: origin }
+            : {}),
+    };
+}
+/** Whether a saved record's `study` or `lab` field is absent or shaped like a provenance. */
+export function isProvenanceField(value) {
+    if (value === undefined)
+        return true;
+    if (value === null || typeof value !== "object")
+        return false;
+    return typeof value.id === "string";
+}
+/**
+ * A saved record's study: a valid `study`, else a valid `lab`, else the id its persona or scenario
+ * source names by convention.
+ */
+export function studyProvenanceOf(record) {
+    const declared = provenance(record.study) ?? provenance(record.lab);
+    if (declared !== undefined)
+        return declared;
+    const id = inferLegacyStudyId(record);
+    return id === undefined ? undefined : { id };
+}
+/** `study` and `lab` with the same value, as run.json and status.json write them until 0.109. */
+export function studyFields(study) {
+    return study === undefined ? {} : { study, lab: study };
+}
+/**
+ * The study id a run names by the `study:<id>` or `lab:<id>` convention on its persona or scenario
+ * source, the only attribution a run written before `lab` and `study` has. A prefix with an empty
+ * remainder is not an id. Ids may contain colons (`lab:oss:meta`), so only the prefix is stripped.
+ * Readers keep both prefixes for good: saved runs say `lab:`.
+ */
+export function inferLegacyStudyId(bundle) {
+    for (const source of [bundle.persona?.source, bundle.scenario?.source]) {
+        if (typeof source !== "string")
+            continue;
+        const prefix = ["study:", "lab:"].find((candidate) => source.startsWith(candidate));
+        if (prefix === undefined)
+            continue;
+        const id = source.slice(prefix.length).trim();
+        if (id !== "")
+            return id;
+    }
+    return undefined;
+}

package/dist/run/study-result.d.ts

@@ -0,0 +1,16 @@
+/** The schema of a study's result on every route. */
+export declare const STUDY_RESULT_SCHEMA = "humanish.study-result.v1";
+/** The fields every route's result carries to name its route and its study. */
+export interface StudyResultIdentity<R extends string> {
+    schema: typeof STUDY_RESULT_SCHEMA;
+    route: R;
+    /** The study's `id`. */
+    studyId: string;
+    /**
+     * The study's `id`, the same value as `studyId`.
+     * @deprecated Read `studyId`. The next minor removes it.
+     */
+    labId: string;
+}
+/** The identity fields for a result of route `route` from the study `studyId`. */
+export declare function studyResultIdentity<R extends string>(route: R, studyId: string): StudyResultIdentity<R>;

package/dist/run/study-result.js

@@ -0,0 +1,9 @@
+// The schema every route's result carries when a study runs: preview, computer use, scripted,
+// terminal and shared world. `route` says which, and route-specific fields stay on their route's
+// result type.
+/** The schema of a study's result on every route. */
+export const STUDY_RESULT_SCHEMA = "humanish.study-result.v1";
+/** The identity fields for a result of route `route` from the study `studyId`. */
+export function studyResultIdentity(route, studyId) {
+    return { schema: STUDY_RESULT_SCHEMA, route, studyId, labId: studyId };
+}

package/dist/run/terminal-contract.d.ts

@@ -1,15 +1,15 @@
 export declare const TERMINAL_EVENTS_ARTIFACT = "terminal-events.ndjson";
 export declare const TERMINAL_TRANSCRIPT_ARTIFACT = "terminal-transcript.txt";
 export declare const TERMINAL_LEDGERS_ARTIFACT = "terminal-ledgers.json";
-/** The cost categories the lane meters. product/media/payment are adapter signals; core can
+/** The cost categories the terminal route meters. product/media/payment are adapter signals; core can
  *  populate the provider line from the actor trace's tokenUsage.costUsd when present. */
 export type CostCategory = "product" | "media" | "payment" | "provider";
 /** The four cost categories, in a fixed order so the ledger shape is stable across runs. */
 export declare const COST_CATEGORIES: readonly CostCategory[];
 /**
  * Strip ANSI/control noise from a captured terminal transcript into stable, scannable text. Pure
- * (no IO). Exported so the terminal-product lane (src/routes/terminal/live-sandbox.ts) normalizes
- * its captured exec stream EXACTLY as the local-actor lanes do — the verdict-nonce scorer is only
+ * (no IO). Exported so the terminal-product route (src/routes/terminal/live-sandbox.ts) normalizes
+ * its captured exec stream exactly as the local-actor routes do: the verdict-nonce scorer is only
  * sound against the same normalization the marker is matched on, so the logic must not diverge.
  */
 export declare function normalizeLocalActorTranscript(transcript: string): string;
@@ -18,8 +18,8 @@ type ActorVerdict = "passed" | "blocked" | "failed";
  * Extract the per-run verdict from a normalized transcript: the agent must print exactly
  * `HUMANISH_ACTOR_VERDICT=<status> HUMANISH_ACTOR_NONCE=<nonce>`, and the nonce is mandatory so a
  * bare marker (echoed or replayed from untrusted text) can never forge a verdict. Pure (no IO).
- * Exported so the terminal-product lane scores its in-sandbox `codex exec` run by the same marker;
- * divergent verdict logic would let the two lanes disagree about what "passed" means.
+ * Exported so the terminal-product route scores its in-sandbox `codex exec` run by the same marker;
+ * divergent verdict logic would let the two routes disagree about what "passed" means.
  */
 export declare function extractLocalActorVerdict(transcript: string, verdictNonce: string): ActorVerdict | null;
 export {};

package/dist/run/terminal-contract.js

@@ -14,8 +14,8 @@ export const COST_CATEGORIES = [
 ];
 /**
  * Strip ANSI/control noise from a captured terminal transcript into stable, scannable text. Pure
- * (no IO). Exported so the terminal-product lane (src/routes/terminal/live-sandbox.ts) normalizes
- * its captured exec stream EXACTLY as the local-actor lanes do — the verdict-nonce scorer is only
+ * (no IO). Exported so the terminal-product route (src/routes/terminal/live-sandbox.ts) normalizes
+ * its captured exec stream exactly as the local-actor routes do: the verdict-nonce scorer is only
  * sound against the same normalization the marker is matched on, so the logic must not diverge.
  */
 export function normalizeLocalActorTranscript(transcript) {
@@ -31,8 +31,8 @@ export function normalizeLocalActorTranscript(transcript) {
  * Extract the per-run verdict from a normalized transcript: the agent must print exactly
  * `HUMANISH_ACTOR_VERDICT=<status> HUMANISH_ACTOR_NONCE=<nonce>`, and the nonce is mandatory so a
  * bare marker (echoed or replayed from untrusted text) can never forge a verdict. Pure (no IO).
- * Exported so the terminal-product lane scores its in-sandbox `codex exec` run by the same marker;
- * divergent verdict logic would let the two lanes disagree about what "passed" means.
+ * Exported so the terminal-product route scores its in-sandbox `codex exec` run by the same marker;
+ * divergent verdict logic would let the two routes disagree about what "passed" means.
  */
 export function extractLocalActorVerdict(transcript, verdictNonce) {
     const compactTranscript = transcript.replace(/\s+/g, "");

package/dist/run/text.d.ts

@@ -1,2 +1,4 @@
 /** Escape a literal string for use inside a RegExp source. */
 export declare function escapeRegExp(value: string): string;
+/** "1 run", "2 runs"; `plural` names the irregular form, as in plural(n, "analysis", "analyses"). */
+export declare function plural(count: number, singular: string, pluralForm?: string): string;

package/dist/run/text.js

@@ -2,3 +2,7 @@
 export function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+/** "1 run", "2 runs"; `plural` names the irregular form, as in plural(n, "analysis", "analyses"). */
+export function plural(count, singular, pluralForm = `${singular}s`) {
+    return `${count} ${count === 1 ? singular : pluralForm}`;
+}

package/dist/run/transient-comms-secrets.d.ts

@@ -3,3 +3,8 @@ export declare function withTransientCommsSecrets<T>(work: () => Promise<T>): Pr
 export declare function registerTransientCommsSecrets(values: string[]): void;
 /** Literal, longest-first replacement in one pass; replacement text is never matched recursively. */
 export declare function scrubTransientCommsText(text: string): string;
+/**
+ * The scope's values as a scrubSecretValues scrub, which also finds them percent-encoded, escaped or
+ * base64-encoded and returns decoded text. Outside a scope it changes nothing.
+ */
+export declare function transientCommsEncodedScrub(): (text: string) => string;

package/dist/run/transient-comms-secrets.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { scrubSecretValues } from "../evidence/secret-scrub.js";
 import { escapeRegExp } from "./text.js";
 const scopes = new AsyncLocalStorage();
 const MAX_VALUES = 8192;
@@ -70,3 +71,14 @@ export function scrubTransientCommsText(text) {
         return fail(scope);
     }
 }
+/**
+ * The scope's values as a scrubSecretValues scrub, which also finds them percent-encoded, escaped or
+ * base64-encoded and returns decoded text. Outside a scope it changes nothing.
+ */
+export function transientCommsEncodedScrub() {
+    const scope = scopes.getStore();
+    if (!scope)
+        return (text) => text;
+    usable(scope);
+    return scrubSecretValues([...scope.values]);
+}

package/dist/run-lab.d.ts

@@ -1,22 +1,29 @@
-import type { AutomaticAnalysisHooks } from "./analysis/automatic-completion.js";
+import type { LocalVmInput } from "./routes/computer-use/types.js";
 import { type LateScorer } from "./lab/route-inputs.js";
-import { type LabBackend, type LabRoute } from "./lab/plan.js";
-import { type RunLabDriving, type RunLabHomes } from "./lab/run-lab-options.js";
+import { type LabRoute } from "./lab/plan.js";
+import type { LabDeps } from "./lab/lab-deps.js";
+import type { RunLabDriving, RunLabHomes } from "./lab/run-lab-homes.js";
 import { type LabConfig } from "./lab/types.js";
 import type { ObserverResult } from "./observer/render.js";
-import { type CuaActorLabHooks, type CuaActorLabResult } from "./routes/computer-use/types.js";
-import { type ScriptedBrowserLabHooks, type ScriptedBrowserLabResult } from "./routes/scripted/types.js";
-import { type ConcurrentSharedWorldLabResult, type SharedWorldLabHooks } from "./routes/shared-world/types.js";
-import { type TerminalProductLabHooks, type TerminalProductLabResult } from "./routes/terminal/types.js";
+import { type CuaActorLabResult } from "./routes/computer-use/types.js";
+import { type PreviewStudyResult } from "./routes/preview.js";
+import { type ScriptedBrowserLabResult } from "./routes/scripted/types.js";
+import { type ConcurrentSharedWorldLabResult } from "./routes/shared-world/types.js";
+import { type TerminalProductLabResult } from "./routes/terminal/types.js";
 import { type RunScorerProvenance } from "./run/bundle.js";
-import { type RunResult } from "./run/results.js";
-import { type RunLabProvenance } from "./run/status.js";
+import type { RunStudyProvenance } from "./run/study-provenance.js";
 /**
  * Runs a lab on its route. The options are checked against the route and mapped into the route's
  * hook bags before anything runs. Each route closes the run it started on every exit through its
  * own run scope (`src/run/run.ts`).
  */
-export declare function runLab(config: LabConfig, options: RunLabOptions): Promise<LabOutcome>;
+export declare function runLab(config: LabConfig, options: InternalRunLabOptions, deps?: LabDeps): Promise<LabOutcome>;
+/**
+ * runLab as the package exports it (`src/index.ts`): the public options only. A JavaScript caller
+ * that passes a field RunLabOptions no longer has is refused in the route's own result envelope
+ * before anything runs.
+ */
+export declare function runPackageLab(config: LabConfig, options: RunLabOptions): Promise<LabOutcome>;
 /** A lab planned once: the route's refusal, or the run of its plan. */
 export type PreparedLab = {
     readonly ok: false;
@@ -28,62 +35,57 @@ export type PreparedLab = {
 };
 /**
  * Normalizes the options and plans the lab once, so a caller can present a refusal before it loads
- * anything the run needs. A local browser study's desktop lane and provider are bound first, so the
- * plan is made with them; with createDesktopLane the caller provides the desktop, and with
- * buildExecutor it drives the app in process and needs none.
+ * anything the run needs. A local browser study's provider is bound first, so the plan is made with
+ * it, and its desktop goes to the computer-use run as `localVm`; with inProcess the caller drives
+ * the app in process and needs no desktop.
  */
-export declare function prepareLab(config: LabConfig, options: RunLabOptions): Promise<PreparedLab>;
+export declare function prepareLab(config: LabConfig, options: InternalRunLabOptions, deps?: LabDeps): Promise<PreparedLab>;
 /**
- * Runtime overrides from CLI flags, the typed homes (`RunLabHomes`, `RunLabDriving`) and the older
- * route hook bags they replace. Each wins over the config when provided.
+ * What a package caller passes to runLab: the run's settings and the typed homes (`RunLabHomes`,
+ * `RunLabDriving`). Each wins over the config when provided.
  */
 export type RunLabOptions = RunLabBase & RunLabHomes & RunLabDriving;
 interface RunLabBase {
-    automaticAnalysis?: AutomaticAnalysisHooks;
     cwd: string;
     runId?: string;
-    /** Which manifest this run came from (#455): threaded to the route so the run's own
-     *  status record and bundle can say which lab produced it. Absent for library callers who
-     *  hand a LabConfig directly — the run is then honestly lab-less rather than guessed. */
-    lab?: RunLabProvenance;
     dryRun?: boolean;
     open?: boolean;
     /** Participant count override: preview participants or computer-use desktops. */
     count?: number;
-    /** CUA fan-out only: create a new run for failed/selected lanes from a prior run. */
+    /** CUA fan-out only: create a new run for failed/selected participants from a prior run. */
     rerun?: {
         sourceRunId: string;
         participantIds?: string[];
-        /** @deprecated The older name of `participantIds`. */
-        laneIds?: string[];
     };
     onObserverReady?: (observer: ObserverResult & {
         ok: true;
     }) => Promise<void> | void;
-    /** Computer-use route hooks: subject provisioning (library callers) + test DI seams. */
-    cuaHooks?: CuaActorLabHooks;
-    /** Scripted-browser route hooks: browser injection + test DI seams (mirror of cuaHooks). */
-    scriptedHooks?: ScriptedBrowserLabHooks;
-    /** Terminal-product route hooks: sandbox/runtime-auth DI seams (mirror of cuaHooks). */
-    terminalHooks?: TerminalProductLabHooks;
-    /** Shared-world route hooks: sandbox / runSession / checkpoint DI seams (mirror of cuaHooks). */
-    sharedWorldHooks?: SharedWorldLabHooks;
+}
+/** runLab's options inside the package: the public ones plus what only the CLI and tests set. */
+export type InternalRunLabOptions = RunLabOptions & RunLabInternals;
+interface RunLabInternals {
+    /**
+     * Which manifest this run came from. planLab puts it on the plan, and the route reads
+     * plan.lab for the run's status record and bundle. Absent for a library caller that passes a
+     * LabConfig directly; that run records no lab.
+     */
+    lab?: RunStudyProvenance;
     /**
-     * CONFIG-DECLARED scorer provenance (#316), forwarded alongside whichever hooks bag carries the
+     * Config-declared scorer provenance, forwarded alongside the
      * loaded scorer. Its presence is the "declared" marker the terminal route reads to flip a
      * status:"fail" verdict; the browser routes stamp it as evidence (they already flip). Core-computed
      * (path + digest), never adopter-supplied; absent for library callers.
      */
     scorerProvenance?: RunScorerProvenance;
+    /** The local VM study's desktop, analysis gate and signal, for a local browser lab. */
+    localVm?: LocalVmInput;
 }
 /** A run's result and the route it ran on. */
-interface RouteOutcome<R extends LabRoute, B extends LabBackend, T> {
+interface RouteOutcome<R extends LabRoute, T> {
     route: R;
-    /** @deprecated The route's older name. Use `route`; this field goes in the next minor. */
-    backend: B;
     result: T;
 }
-export type LabOutcome = RouteOutcome<"preview", "synthetic", RunResult> | RouteOutcome<"computer-use", "cua", CuaActorLabResult> | RouteOutcome<"scripted", "scripted", ScriptedBrowserLabResult> | RouteOutcome<"terminal", "terminal", TerminalProductLabResult> | RouteOutcome<"shared-world", "concurrent-shared-world", ConcurrentSharedWorldLabResult>;
+export type LabOutcome = RouteOutcome<"preview", PreviewStudyResult> | RouteOutcome<"computer-use", CuaActorLabResult> | RouteOutcome<"scripted", ScriptedBrowserLabResult> | RouteOutcome<"terminal", TerminalProductLabResult> | RouteOutcome<"shared-world", ConcurrentSharedWorldLabResult>;
 /**
  * A plan past its route's local checks that need no scorer: the refusal they returned, or the
  * route's run, which takes a scorer loaded after them.
@@ -101,7 +103,7 @@ export type AdmittedPlan<R extends LabRoute = LabRoute> = {
 };
 /** The result of a run on route `R`, the `result` of that route's `LabOutcome`. */
 export type LabResult<R extends LabRoute = LabRoute> = {
-    preview: RunResult;
+    preview: PreviewStudyResult;
     "computer-use": CuaActorLabResult;
     scripted: ScriptedBrowserLabResult;
     terminal: TerminalProductLabResult;