humanish 0.104.3 → 0.106.0

package/dist/lab/run-lab-options.js

@@ -0,0 +1,399 @@
+// The typed homes on RunLabOptions and the one place they meet the route hook bags. runLab calls
+// normalizeRunLabOptions first: it refuses an option the route cannot honor, or a new option set
+// together with the old field it replaces, and otherwise maps each new option into the bag the
+// route reads today. Old fields pass through untouched, so they keep their exact behavior.
+import path from "node:path";
+import { CUA_ACTOR_LAB_SCHEMA } from "../routes/computer-use/types.js";
+import { SCRIPTED_BROWSER_LAB_SCHEMA } from "../routes/scripted/types.js";
+import { CONCURRENT_SHARED_WORLD_LAB_SCHEMA } from "../routes/shared-world/types.js";
+import { TERMINAL_PRODUCT_LAB_SCHEMA, } from "../routes/terminal/types.js";
+import { isLocalBrowserLab } from "../substrates/local/runtime-config.js";
+import { defaultSharedWorldPhaseSink, defaultSubjectPhaseSink } from "../subject/steps.js";
+import { HOOK_MEMBERS, withHookOverrides } from "./bag-overrides.js";
+import { resolveLabDryRun } from "./plan.js";
+import { knownSecretValues, labEventEmitter, participantOf, phaseEvent, planEvent, } from "./run-lab-events.js";
+import { rosterOf } from "./parse/actors.js";
+const conflict = (home, old) => ({
+    ok: false,
+    code: "HUMANISH_LAB_OPTION_CONFLICT",
+    message: `RunLabOptions.${home} and ${old} are both set. ${old} is the older form of ${home}; set only ${home}.`,
+});
+const unsupported = (option, route, reason) => ({
+    ok: false,
+    code: "HUMANISH_LAB_OPTION_UNSUPPORTED",
+    message: `RunLabOptions.${option} is not supported on the ${route} route: ${reason}`,
+});
+/**
+ * Whether a caller's bag sets `key`, from its property descriptors: a data property counts when its
+ * value is defined, an accessor counts without being called. Nothing the caller defined runs.
+ */
+function hasMember(bag, key) {
+    for (let source = bag ?? null; source !== null && source !== Object.prototype; source = Object.getPrototypeOf(source)) {
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor !== undefined)
+            return "value" in descriptor ? descriptor.value !== undefined : true;
+    }
+    return false;
+}
+/**
+ * Every old field the options set that has a new home, and whether its home is set too. Presence
+ * comes from property descriptors (hasMember), so no getter of the caller's runs.
+ */
+function oldFieldsInUse(options) {
+    const pairs = [
+        ["env", "cuaHooks", "env"],
+        ["env", "scriptedHooks", "env"],
+        ["env", "terminalHooks", "env"],
+        ["env", "sharedWorldHooks", "env"],
+        ["scorer", "cuaHooks", "score"],
+        ["scorer", "cuaHooks", "deriveFeedback"],
+        ["scorer", "cuaHooks", "deriveArtifacts"],
+        ["scorer", "sharedWorldHooks", "score"],
+        ["scorer", "sharedWorldHooks", "deriveFeedback"],
+        ["scorer", "sharedWorldHooks", "deriveArtifacts"],
+        ["scorer", "terminalHooks", "score"],
+        ["scorer", "terminalHooks", "deriveFeedback"],
+        ["prepareDesktop", "cuaHooks", "prepareDesktop"],
+        ["prepareDesktop", "scriptedHooks", "prepareDesktop"],
+        ["prepareDesktop", "sharedWorldHooks", "prepareDesktop"],
+        ["onEvent", "cuaHooks", "onPreflight"],
+        ["onEvent", "cuaHooks", "onPhase"],
+        ["onEvent", "sharedWorldHooks", "onPhase"],
+        ["onEvent", "automaticAnalysis", "onStart"],
+        ["onStream", "cuaHooks", "onRuntimeStreamReady"],
+        ["onStream", "cuaHooks", "onRuntimeStreamEnded"],
+        ["onStream", "sharedWorldHooks", "onRuntimeStreamReady"],
+        ["onStream", "sharedWorldHooks", "onRuntimeStreamEnded"],
+        ["analysisSignal", "automaticAnalysis.deps", "signal"],
+        ["createProvider", "cuaHooks", "buildProvider"],
+        ["inProcess", "cuaHooks", "buildExecutor"],
+        ["rerun.participantIds", "rerun", "laneIds"],
+    ];
+    const home = (name) => name === "rerun.participantIds"
+        ? options.rerun?.participantIds !== undefined
+        : options[name] !== undefined;
+    const bagOf = (name) => name === "automaticAnalysis.deps"
+        ? options.automaticAnalysis?.deps
+        : options[name];
+    return pairs
+        .filter(([, bag, member]) => hasMember(bagOf(bag), member))
+        .map(([name, bag, member]) => ({ home: name, old: `${bag}.${member}`, clash: home(name) }));
+}
+/** Old fields removed in the next minor with no replacement. They warn, and they never clash. */
+function retiredFieldsInUse(options) {
+    return hasMember(options.cuaHooks, "createDesktopLane") ? ["cuaHooks.createDesktopLane"] : [];
+}
+const warned = new Set();
+/** One DeprecationWarning per old field per process. The bags' other test seams never warn. */
+function warnDeprecated(home, old) {
+    if (warned.has(old))
+        return;
+    warned.add(old);
+    const replacement = home === undefined ? "It has no replacement." : `Use RunLabOptions.${home}.`;
+    process.emitWarning(`RunLabOptions.${old} is deprecated and is removed in the next minor. ${replacement}`, { type: "DeprecationWarning", code: "HUMANISH_RUN_LAB_OPTION_DEPRECATED" });
+}
+/** Why the route cannot honor an option it was given, or undefined when it can. */
+function unsupportedOption(config, route, options) {
+    const { scorer, createProvider, inProcess, prepareDesktop } = options;
+    if (inProcess !== undefined && createProvider === undefined)
+        return unsupported("inProcess", route, "an in-process executor returns no frame, so it needs createProvider.");
+    const participantRoute = route === "computer-use" || route === "shared-world";
+    if (scorer !== undefined && route !== "terminal" && !participantRoute)
+        return unsupported("scorer", route, "only computer use, shared world and terminal score runs.");
+    if (createProvider !== undefined && route !== "computer-use")
+        return unsupported("createProvider", route, route === "shared-world"
+            ? "shared-world participants run the lab's own brain."
+            : "only computer use takes a caller brain.");
+    if (route === "computer-use") {
+        const source = config.subject.source;
+        if (inProcess !== undefined) {
+            if (source !== "app-url" && source !== "local-app")
+                return unsupported("inProcess", route, "it drives an app-url or local-app subject.");
+        }
+        if (prepareDesktop !== undefined) {
+            if (isLocalBrowserLab(config))
+                return unsupported("prepareDesktop", route, "a local VM study has no E2B desktop.");
+            // The run is in process when either executor home is set: inProcess or the older
+            // cuaHooks.buildExecutor. Either way no desktop exists to prepare.
+            if (inProcess !== undefined ||
+                hasMember(options.cuaHooks, "buildExecutor") ||
+                source === "local-app")
+                return unsupported("prepareDesktop", route, "an in-process run has no desktop.");
+        }
+        return undefined;
+    }
+    if (inProcess !== undefined)
+        return unsupported("inProcess", route, "only computer use drives an app in process.");
+    if (prepareDesktop === undefined || route === "shared-world")
+        return undefined;
+    if (route === "scripted" && config.subject.source === "clone")
+        return undefined;
+    return unsupported("prepareDesktop", route, route === "scripted"
+        ? "only a clone subject runs on an E2B desktop."
+        : "this route has no E2B desktop to prepare.");
+}
+/**
+ * Refuse what the route cannot honor, then map the new options into the old bags. Nothing here
+ * touches the filesystem, so a refusal leaves no run directory, receipt or sandbox.
+ */
+export function normalizeRunLabOptions(config, route, options) {
+    const inUse = oldFieldsInUse(options);
+    const clash = inUse.find((field) => field.clash);
+    if (clash)
+        return conflict(clash.home, clash.old);
+    const refused = unsupportedOption(config, route, options);
+    if (refused)
+        return refused;
+    for (const { home, old } of inUse)
+        warnDeprecated(home, old);
+    for (const old of retiredFieldsInUse(options))
+        warnDeprecated(undefined, old);
+    const warnings = [];
+    const { env, scorer, prepareDesktop, onEvent, onStream, analysisSignal, createProvider, inProcess, ...legacy } = options;
+    // The route gets this copy, so it is the env a warning is scrubbed against, whatever the caller
+    // does to its own object afterwards.
+    const forwardedEnv = env === undefined ? undefined : { ...env };
+    const emit = labEventEmitter(onEvent, warnings, () => knownSecretValues(config, options, forwardedEnv));
+    const normalized = { ...legacy };
+    const participantIds = options.rerun?.participantIds;
+    if (options.rerun !== undefined && participantIds !== undefined) {
+        const { participantIds: _ids, ...rerun } = options.rerun;
+        normalized.rerun = { ...rerun, laneIds: participantIds };
+    }
+    const analysis = withMapped(legacy.automaticAnalysis, HOOK_MEMBERS.analysis, {
+        ...(analysisSignal === undefined
+            ? {}
+            : { deps: { ...legacy.automaticAnalysis?.deps, signal: analysisSignal } }),
+        ...(emit === undefined
+            ? {}
+            : {
+                onStart: () => {
+                    emit({ type: "analysis-started" });
+                    return () => emit({ type: "analysis-finished" });
+                },
+            }),
+    });
+    if (analysis !== undefined)
+        normalized.automaticAnalysis = analysis;
+    const envHome = forwardedEnv === undefined ? {} : { env: forwardedEnv };
+    const scoring = scorer === undefined ? {} : scorerHooks(scorer);
+    switch (route) {
+        case "computer-use": {
+            const hooks = withMapped(legacy.cuaHooks, HOOK_MEMBERS.cua, {
+                ...envHome,
+                ...scoring,
+                ...computerUseHooks(config, {
+                    prepareDesktop,
+                    onStream,
+                    createProvider,
+                    inProcess,
+                    legacyInProcess: hasMember(legacy.cuaHooks, "buildExecutor"),
+                }, emit),
+            });
+            if (hooks !== undefined)
+                normalized.cuaHooks = hooks;
+            break;
+        }
+        case "shared-world": {
+            const hooks = withMapped(legacy.sharedWorldHooks, HOOK_MEMBERS.sharedWorld, {
+                ...envHome,
+                ...scoring,
+                ...sharedWorldHooks({ prepareDesktop, onStream }, emit),
+            });
+            if (hooks !== undefined)
+                normalized.sharedWorldHooks = hooks;
+            break;
+        }
+        case "terminal": {
+            const hooks = withMapped(legacy.terminalHooks, HOOK_MEMBERS.terminal, {
+                ...envHome,
+                ...(scorer?.score === undefined ? {} : { score: scorer.score }),
+                ...(scorer?.deriveFeedback === undefined
+                    ? {}
+                    : { deriveFeedback: scorer.deriveFeedback }),
+            });
+            if (hooks !== undefined)
+                normalized.terminalHooks = hooks;
+            break;
+        }
+        case "scripted": {
+            const hooks = withMapped(legacy.scriptedHooks, HOOK_MEMBERS.scripted, {
+                ...envHome,
+                ...(prepareDesktop === undefined
+                    ? {}
+                    : {
+                        prepareDesktop: (desktop) => prepareDesktop(desktop, { kind: "subject" }),
+                    }),
+            });
+            if (hooks !== undefined)
+                normalized.scriptedHooks = hooks;
+            break;
+        }
+        case "preview":
+            break;
+    }
+    return { ok: true, options: normalized, warnings };
+}
+/** A caller's bag with new options mapped into it. With nothing to map, it is the same object. */
+function withMapped(bag, declared, mapped) {
+    if (Object.keys(mapped).length === 0)
+        return bag;
+    return withHookOverrides(bag, declared, mapped);
+}
+export function scorerHooks(scorer) {
+    return {
+        ...(scorer.score === undefined ? {} : { score: scorer.score }),
+        ...(scorer.deriveFeedback === undefined ? {} : { deriveFeedback: scorer.deriveFeedback }),
+        ...(scorer.deriveArtifacts === undefined ? {} : { deriveArtifacts: scorer.deriveArtifacts }),
+    };
+}
+/** The route awaits what these return, so onStream keeps the old hooks' barrier and errors. */
+function streamHooks(onStream) {
+    return {
+        onRuntimeStreamReady: (stream) => onStream({
+            type: "ready",
+            participantId: stream.laneId,
+            sandboxId: stream.sandboxId,
+            simId: stream.simId,
+            streamId: stream.streamId,
+            url: stream.url,
+        }),
+        onRuntimeStreamEnded: (stream) => onStream({
+            type: "ended",
+            participantId: stream.laneId,
+            simId: stream.simId,
+            streamId: stream.streamId,
+        }),
+    };
+}
+function computerUseHooks(config, homes, emit) {
+    const { prepareDesktop, onStream, createProvider, inProcess, legacyInProcess } = homes;
+    // A local VM study and an in-process run start no E2B stream, and the local study refuses a
+    // stream hook outright, so onStream is left unset there: it is never called.
+    const streams = !isLocalBrowserLab(config) && inProcess === undefined && !legacyInProcess;
+    return {
+        ...(prepareDesktop === undefined
+            ? {}
+            : {
+                prepareDesktop: (desktop, participant) => prepareDesktop(desktop, {
+                    kind: "participant",
+                    participant: participantOf(participant),
+                }),
+            }),
+        ...(createProvider === undefined
+            ? {}
+            : {
+                buildProvider: ({ config: lab, lane: participant, laneCount, executor }) => createProvider({
+                    config: lab,
+                    participant: participantOf({ ...participant, laneCount }),
+                    executor,
+                }),
+            }),
+        ...(inProcess === undefined
+            ? {}
+            : {
+                buildExecutor: ({ config: lab, appUrl }) => inProcess.executor({ config: lab, appUrl }),
+            }),
+        ...(onStream !== undefined && streams ? streamHooks(onStream) : {}),
+        ...(emit === undefined
+            ? {}
+            : {
+                onPreflight: (plan) => emit(planEvent(plan)),
+                onPhase: (event, participant) => {
+                    defaultSubjectPhaseSink(event, participant);
+                    emit(phaseEvent(event, { kind: "participant", participant: participantOf(participant) }));
+                },
+            }),
+    };
+}
+function sharedWorldHooks(homes, emit) {
+    const { prepareDesktop, onStream } = homes;
+    return {
+        ...(prepareDesktop === undefined
+            ? {}
+            : {
+                // The provisioned plane prepares the subject sandbox with no participant, then each one.
+                prepareDesktop: (desktop, participant) => prepareDesktop(desktop, participant === undefined
+                    ? { kind: "subject" }
+                    : { kind: "participant", participant: participantOf(participant) }),
+            }),
+        ...(onStream === undefined ? {} : streamHooks(onStream)),
+        ...(emit === undefined
+            ? {}
+            : {
+                onPhase: (event) => {
+                    defaultSharedWorldPhaseSink(event);
+                    emit(phaseEvent(event, { kind: "subject" }));
+                },
+            }),
+    };
+}
+/** A refusal in the route's own result envelope, before any run exists. */
+export function optionRefusalOutcome(config, route, options, refusal) {
+    const cwd = path.resolve(options.cwd);
+    const error = { code: refusal.code, message: refusal.message };
+    const actor = config.actors[0]?.type ?? "";
+    const dryRun = resolveLabDryRun(config, options.dryRun, true) ?? true;
+    const runId = options.runId ?? "not-created";
+    const common = { ok: false, cwd, labId: config.id, actor, dryRun, runId, warnings: [], error };
+    switch (route) {
+        case "preview":
+            return {
+                route: "preview",
+                backend: "synthetic",
+                result: { schema: "humanish.run-result.v1", ok: false, cwd, warnings: [], error },
+            };
+        case "computer-use":
+            return {
+                route: "computer-use",
+                backend: "cua",
+                result: {
+                    schema: CUA_ACTOR_LAB_SCHEMA,
+                    ...common,
+                    ok: false,
+                    appUrl: config.subject.appUrl ?? config.subject.serve?.url ?? "",
+                    lanes: [],
+                },
+            };
+        case "scripted":
+            return {
+                route: "scripted",
+                backend: "scripted",
+                result: {
+                    schema: SCRIPTED_BROWSER_LAB_SCHEMA,
+                    ...common,
+                    ok: false,
+                    appUrl: config.subject.appUrl ?? "",
+                    sessions: [],
+                },
+            };
+        case "terminal":
+            return {
+                route: "terminal",
+                backend: "terminal",
+                result: {
+                    schema: TERMINAL_PRODUCT_LAB_SCHEMA,
+                    ...common,
+                    ok: false,
+                    product: config.subject.product?.name ?? "",
+                },
+            };
+        case "shared-world": {
+            const participantCount = rosterOf(config.actors[0])?.length ?? 0;
+            return {
+                route: "shared-world",
+                backend: "concurrent-shared-world",
+                result: {
+                    schema: CONCURRENT_SHARED_WORLD_LAB_SCHEMA,
+                    ...common,
+                    ok: false,
+                    topology: "shared-world",
+                    topologyMode: "concurrent",
+                    roleCount: participantCount,
+                    concurrency: config.execution?.concurrency ?? Math.max(1, participantCount),
+                    roles: [],
+                },
+            };
+        }
+    }
+}

package/dist/lab/summary.d.ts

@@ -0,0 +1,60 @@
+import { type LocalRuntimeStatus } from "../substrates/local/runtime.js";
+import { type KeyResolutionDeps } from "../keys/key-resolution.js";
+export declare const LAB_SUMMARY_SCHEMA = "humanish.lab-summary.v1";
+export interface LabCaps {
+    /** Per-lane blast-radius budget. */
+    laneUsd?: number;
+    /** Shared study budget across every lane. */
+    studyUsd?: number;
+}
+export interface LabSummary {
+    runtime?: Pick<LocalRuntimeStatus, "ok" | "installed" | "message">;
+    participantReadiness?: {
+        ok: boolean;
+        message: string;
+    };
+    communications?: string;
+    analysis?: {
+        provider?: "openai" | "codex";
+        billing?: "api-estimate" | "account-unknown";
+        model: string;
+        maxCostUsd: number | null;
+    };
+    schema: typeof LAB_SUMMARY_SCHEMA;
+    labId: string;
+    title?: string;
+    description?: string;
+    /** "clone drawdb-io/drawdb", "app-url http://127.0.0.1:3000/", "this-repo". */
+    subject?: string;
+    /** How many participants and who they are: `1 × synthetic-new-user`. */
+    participants?: string;
+    /** The model that will actually run, override or default. */
+    model?: string;
+    /**
+     * The reasoning effort that will actually run, override or default — and "per-lane" when the
+     * roster declares more than one, because a single value would be a lie about half the lanes.
+     *
+     * Shown because it was a silent constant: unreachable from a lab, so every run took the provider
+     * default. A study variable you cannot see is one nobody chose (#497).
+     */
+    reasoningEffort?: string;
+    caps: LabCaps;
+    /**
+     * Whether the configured route's required keys resolve. Dry runs require none. This checks key
+     * presence, not local CLI authentication or provider validity. Undefined when not checked.
+     */
+    keysReady?: boolean;
+    missingKeys?: string[];
+}
+export interface ReadLabSummaryOptions {
+    /** Skip the key probe (it touches vendor stores); the screen then shows no keys line. */
+    checkKeys?: boolean;
+    env?: NodeJS.ProcessEnv;
+    /** Where the key probe looks for vendor stores; tests point it at a temp home. */
+    keyDeps?: KeyResolutionDeps;
+}
+/**
+ * Describe one lab. Returns null when the manifest cannot be resolved — the caller already knows
+ * the lab exists from the listing, so this failing means the file changed underneath them.
+ */
+export declare function readLabSummary(cwd: string, lab: string, options?: ReadLabSummaryOptions): Promise<LabSummary | null>;

package/dist/lab/summary.js

@@ -0,0 +1,168 @@
+import { isLocalBrowserLab } from "../substrates/local/runtime-config.js";
+import { localRuntimeStatus } from "../substrates/local/runtime.js";
+// What a lab IS, for the surface that has to describe it before you spend money (#455).
+//
+// The run index and run detail answer questions about runs. This answers a question about the LAB
+// itself — what it drives, who is in it, which model, and what it is allowed to spend — which is
+// what a stakeholder reads on the screen where they decide whether to press Start.
+//
+// Resolved analysis defaults are shown independently of declared participant caps. A cap that is not
+// declared is not "unlimited" and not "$0"; it is a line the screen does not draw.
+import { resolveLabDryRun } from "./plan.js";
+import { routeOf } from "./plan.js";
+import { labKeyRequirements, localCodexParticipantCheck } from "./doctor.js";
+import { automaticAnalysisBudget } from "../analysis/automatic-config.js";
+import { DEFAULT_OPENAI_CU_MODEL, DEFAULT_OPENAI_CU_REASONING_EFFORT, } from "../actors/computer-use/openai-provider.js";
+import { inspectLabManifest } from "./discover.js";
+import { isComputerUseComposition } from "./routing.js";
+import { probeKeySources } from "../keys/key-resolution.js";
+import { receivingRequiredKey } from "../comms/setup.js";
+import { rosterOf } from "./parse/actors.js";
+export const LAB_SUMMARY_SCHEMA = "humanish.lab-summary.v1";
+/**
+ * The effort every lane will run at, or "per-lane" when they differ. A lane that declares nothing
+ * inherits the actor's, and an actor that declares nothing gets the provider default — which is
+ * reported as the resolved value, exactly as `model` reports its default rather than hiding it.
+ */
+function reasoningEffortOf(config) {
+    const actors = config.actors;
+    const actor = actors?.[0];
+    const fallback = actor?.reasoningEffort ?? DEFAULT_OPENAI_CU_REASONING_EFFORT;
+    const roster = rosterOf(actor) ?? [];
+    const resolved = new Set(roster.map((entry) => entry.reasoningEffort ?? fallback));
+    if (resolved.size > 1)
+        return "per-lane";
+    return resolved.size === 1 ? [...resolved][0] : fallback;
+}
+/** One short phrase for what the lab drives. */
+function subjectOf(config) {
+    const subject = config.subject;
+    if (subject?.source === undefined)
+        return undefined;
+    const repo = subject.repos?.[0];
+    if (repo !== undefined)
+        return `${subject.source} ${repo}`;
+    if (subject.appUrl !== undefined)
+        return `${subject.source} ${subject.appUrl}`;
+    return subject.source;
+}
+/** How many participants, and who — collapsed when they are all the same persona. */
+function participantsOf(config) {
+    const actors = config.actors;
+    const actor = actors?.[0];
+    if (actor === undefined)
+        return undefined;
+    const rosterPersonas = (rosterOf(actor) ?? [])
+        .map((entry) => entry.persona)
+        .filter((persona) => typeof persona === "string");
+    const personas = rosterPersonas.length > 0 ? rosterPersonas : actor.persona === undefined ? [] : [actor.persona];
+    const count = actor.count ?? rosterOf(actor)?.length ?? personas.length ?? 1;
+    const unique = [...new Set(personas)];
+    if (unique.length === 0)
+        return `${count} participant${count === 1 ? "" : "s"}`;
+    // Several lanes of ONE persona reads as "3 × skeptical-power-user"; genuinely different people
+    // are named, because which personas are in a study is the study's design.
+    return unique.length === 1 ? `${count} × ${unique[0]}` : unique.join(" · ");
+}
+/** The computer-use caps; `execution.caps` is inert on other routes, so none is drawn there. */
+function capsOf(config) {
+    if (!isComputerUseComposition(config))
+        return {};
+    const caps = config.execution?.caps;
+    return {
+        ...(typeof caps?.maxUsd === "number" ? { laneUsd: caps.maxUsd } : {}),
+        ...(typeof caps?.maxTotalUsd === "number" ? { studyUsd: caps.maxTotalUsd } : {}),
+    };
+}
+/**
+ * Describe one lab. Returns null when the manifest cannot be resolved — the caller already knows
+ * the lab exists from the listing, so this failing means the file changed underneath them.
+ */
+export async function readLabSummary(cwd, lab, options = {}) {
+    const inspected = await inspectLabManifest(cwd, lab).catch(() => null);
+    if (inspected === null || !inspected.ok || inspected.config === undefined)
+        return null;
+    const config = inspected.config;
+    const actors = config.actors;
+    const route = routeOf(inspected.config);
+    let keysReady;
+    let missingKeys;
+    if (options.checkKeys === true) {
+        const dryRun = resolveLabDryRun(inspected.config, undefined, true) === true;
+        const subjectKeys = dryRun ? [] : (inspected.config.subject.env ?? []);
+        const email = inspected.config.comms?.email;
+        const receivingKey = !dryRun && email?.kind === "real"
+            ? await receivingRequiredKey(cwd, email.connection)
+            : undefined;
+        const candidates = [
+            "OPENAI_API_KEY",
+            "CODEX_API_KEY",
+            "E2B_API_KEY",
+            ...subjectKeys,
+            ...(receivingKey ? [receivingKey] : []),
+        ];
+        const probes = dryRun
+            ? []
+            : await probeKeySources(candidates, {
+                cwd,
+                env: options.env ?? process.env,
+                ...(options.keyDeps === undefined ? {} : { deps: options.keyDeps }),
+            }).catch(() => []);
+        const present = new Set(probes.filter((probe) => probe.source !== null).map((probe) => probe.name));
+        const required = labKeyRequirements(inspected.config, route, dryRun, (name) => present.has(name));
+        const missing = [
+            ...new Set([...required.keys, ...subjectKeys, ...(receivingKey ? [receivingKey] : [])]),
+        ].filter((name) => !present.has(name));
+        if (receivingKey === null)
+            missing.push("email connection");
+        keysReady = missing.length === 0;
+        if (missing.length > 0)
+            missingKeys = missing;
+    }
+    // Computed once: a test-then-use pair reads as though the two calls could differ.
+    const analysis = automaticAnalysisBudget(inspected.config.review?.analysis, route);
+    const subject = subjectOf(config);
+    const participants = participantsOf(config);
+    const runtime = options.checkKeys === true && isLocalBrowserLab(inspected.config)
+        ? await localRuntimeStatus({
+            ...(options.env ? { env: options.env } : {}),
+            media: inspected.config.execution?.desktop?.media !== undefined ||
+                inspected.config.execution?.desktop?.recording !== undefined,
+        })
+        : undefined;
+    const participantReadiness = options.checkKeys === true &&
+        isLocalBrowserLab(inspected.config) &&
+        inspected.config.actors[0]?.type === "local-agent"
+        ? await localCodexParticipantCheck({ env: options.env ?? process.env })
+        : undefined;
+    return {
+        ...(analysis ? { analysis } : {}),
+        ...(runtime
+            ? { runtime: { ok: runtime.ok, installed: runtime.installed, message: runtime.message } }
+            : {}),
+        ...(participantReadiness
+            ? {
+                participantReadiness: {
+                    ok: participantReadiness.ok,
+                    message: participantReadiness.message,
+                },
+            }
+            : {}),
+        schema: LAB_SUMMARY_SCHEMA,
+        ...(inspected.config.comms?.email?.kind === "real"
+            ? {
+                communications: `Real email · ${inspected.config.comms.email.connection} · fresh inbox per participant · hosted processing · local review only`,
+            }
+            : {}),
+        labId: String(config.id ?? lab),
+        ...(typeof config.title === "string" ? { title: config.title } : {}),
+        ...(typeof config.description === "string" ? { description: config.description.trim() } : {}),
+        ...(subject === undefined ? {} : { subject }),
+        ...(participants === undefined ? {} : { participants }),
+        model: actors?.[0]?.model ?? DEFAULT_OPENAI_CU_MODEL,
+        reasoningEffort: reasoningEffortOf(config),
+        caps: capsOf(inspected.config),
+        ...(keysReady === undefined ? {} : { keysReady }),
+        ...(missingKeys === undefined ? {} : { missingKeys }),
+    };
+}