humanish 0.104.3 → 0.106.0

package/dist/routes/shared-world/seat-records.js

@@ -0,0 +1,213 @@
+// Each participant's records in a concurrent shared-world bundle: its simulation, its stream and
+// its events, projected from the actor's run result (or from the declaration on a dry run or while
+// running).
+import { participantAssignment } from "../../lab/participant-assignment.js";
+import { participantEvent, participantRecord, participantStream, } from "../../run/participant-records.js";
+import { declaredScreenForRender } from "../../substrates/e2b/desktop-geometry.js";
+import { publicSafeRouteLabel } from "./provenance.js";
+import { participantTaxonomyLabel } from "./seats.js";
+function participantView(ctx, spec, index) {
+    const { args, external, inProgress } = ctx;
+    const taxonomy = participantTaxonomyLabel(spec.planned.labels);
+    const result = args.actorResults[index];
+    const outcome = result?.outcome;
+    const session = outcome?.session;
+    const screenshots = outcome?.screenshots ?? [];
+    const lastScreenshot = screenshots[screenshots.length - 1];
+    // public-safe (origin redacted): external-public seats open the public plane; getHost seats a seat path.
+    const route = external
+        ? "[external-public-plane]"
+        : publicSafeRouteLabel(args.plan.plane.participants[index]?.entry);
+    const status = session
+        ? session.status
+        : outcome?.sessionError !== undefined
+            ? "failed"
+            : inProgress
+                ? "running"
+                : "contract_proof_only";
+    const reason = session?.reason ??
+        outcome?.sessionError ??
+        (inProgress
+            ? "Actor desktop is running; the attached Observer hydrates the runtime stream URL without persisting it."
+            : "Contract actor only: dry-run produced the evidence shape without launching a desktop or spending provider tokens.");
+    const traceScreenshotMode = session?.trace.redaction.screenshots;
+    // Include `declared` on the no-outcome fallback too (dry-run, skipped lane): otherwise an
+    // ABSENT declared means either "the preset rendered faithfully" or "there was no live
+    // outcome", and a dry-run bundle keeps the self-confirming shape this field exists to kill.
+    const fallbackDeclared = declaredScreenForRender(spec.planned.device.preset, spec.planned.device.name, spec.planned.device.resolution);
+    const desktopGeometry = outcome?.desktopGeometry ?? {
+        screen: {
+            requested: {
+                width: spec.planned.device.resolution[0],
+                height: spec.planned.device.resolution[1],
+            },
+            ...(fallbackDeclared ? { declared: fallbackDeclared } : {}),
+        },
+    };
+    const screenshotMode = traceScreenshotMode === "raw" || traceScreenshotMode === "blurred"
+        ? traceScreenshotMode
+        : args.plan.residual.policies?.redactScreenshots === true
+            ? "blurred"
+            : "raw";
+    return {
+        taxonomy,
+        outcome,
+        session,
+        screenshots,
+        lastScreenshot,
+        route,
+        status,
+        reason,
+        desktopGeometry,
+        screenshotMode,
+    };
+}
+function sharedWorldSimulation(ctx, spec, index, view) {
+    const { args, inProgress } = ctx;
+    const { taxonomy, outcome, session } = view;
+    return participantRecord(spec, index + 1, {
+        personaId: spec.persona.id,
+        scenarioId: `concurrent-shared-world-${args.plan.labId}`,
+        status: view.status,
+        streamKind: "browser",
+        mode: "browser-sim",
+        progress: inProgress ? 35 : 100,
+        currentStep: view.reason,
+        summary: session
+            ? `Persona ${spec.planned.id}${taxonomy} (${spec.persona.id}): drove the shared plane concurrently; ${session.completionReason}.`
+            : outcome?.sessionError !== undefined
+                ? `Persona ${spec.planned.id}${taxonomy} failed before a terminal session verdict: ${outcome.sessionError}`
+                : inProgress
+                    ? `Persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) is running against the shared plane.`
+                    : `Contract persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) for ${args.descriptor.id} against the shared plane at ${ctx.appUrl}.`,
+        startedAt: args.createdAt,
+        updatedAt: args.createdAt,
+    });
+}
+function sharedWorldStream(ctx, spec, index, view) {
+    const { args } = ctx;
+    const { taxonomy, session, screenshots, lastScreenshot, desktopGeometry, screenshotMode } = view;
+    return participantStream(spec, {
+        ...(spec.evidenceAssignment === undefined
+            ? {}
+            : { assignment: participantAssignment(spec.evidenceAssignment) }),
+        kind: "browser",
+        label: `Concurrent persona ${spec.planned.id}${taxonomy} — ${args.plan.labId}`,
+        status: view.status,
+        transport: "snapshot",
+        updatedAt: args.createdAt,
+        embed: lastScreenshot
+            ? {
+                kind: "screenshot",
+                url: lastScreenshot,
+                title: `Shared plane, persona ${spec.planned.id} (${screenshotMode})`,
+            }
+            : { kind: "placeholder", title: `Shared plane, persona ${spec.planned.id}` },
+        ...(desktopGeometry.viewport === undefined
+            ? {}
+            : {
+                viewport: {
+                    width: desktopGeometry.viewport.width,
+                    height: desktopGeometry.viewport.height,
+                    deviceScaleFactor: desktopGeometry.viewport.deviceScaleFactor,
+                    isMobile: spec.planned.device.preset.isMobile,
+                },
+            }),
+        desktopGeometry,
+        ui: {
+            route: view.route,
+            intent: `Watch persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) drive the SHARED plane concurrently with the other personas.`,
+            state: view.reason,
+            ...(session ? { actorStatus: session.status } : {}),
+            ...(lastScreenshot ? { screenshotUrl: lastScreenshot } : {}),
+        },
+        ...(session ? { actor: session.trace } : {}),
+        artifacts: [
+            { label: "run bundle", path: "run.json", kind: "bundle" },
+            { label: "review", path: "review.md", kind: "review" },
+            { label: "events", path: "events.ndjson", kind: "events" },
+            ...(session
+                ? [
+                    {
+                        label: `persona ${spec.planned.id} actor trace`,
+                        path: spec.traceArtifactPath,
+                        kind: "trace",
+                    },
+                ]
+                : []),
+            // Run-level comms evidence belongs to the ONE shared app, not a persona — register it once, on
+            // the first stream, so the bundle's existence-verify + public-safety scan cover it without
+            // double-counting across seats.
+            ...(index === 0 && args.commsArtifactPath
+                ? [{ label: "comms thread", path: args.commsArtifactPath, kind: "log" }]
+                : []),
+            ...screenshots.map((screenshot, screenshotIndex) => ({
+                label: `persona ${spec.planned.id} screenshot ${String(screenshotIndex + 1).padStart(2, "0")} (${screenshotMode})`,
+                path: screenshot,
+                kind: "screenshot",
+            })),
+        ],
+    });
+}
+function sharedWorldEvents(ctx, spec, view) {
+    const { args, inProgress, nextEventId } = ctx;
+    const createdAt = args.createdAt;
+    const { outcome, session } = view;
+    const events = [];
+    const record = (event) => events.push(participantEvent(spec, event));
+    for (const warning of outcome?.warnings ?? []) {
+        record({
+            id: nextEventId(`warning-${spec.planned.id}`),
+            at: createdAt,
+            level: "warn",
+            type: "concurrent-shared-world.actor.warning",
+            message: `Persona ${spec.planned.id}: ${warning}`,
+        });
+    }
+    if (session) {
+        record({
+            id: nextEventId(`session-${spec.planned.id}`),
+            at: createdAt,
+            level: session.status === "passed" ? "info" : "warn",
+            type: `concurrent-shared-world.session.${session.completionReason}`,
+            message: `Persona ${spec.planned.id}: ${session.status} — ${session.reason}`,
+        });
+    }
+    else if (outcome?.sessionError !== undefined) {
+        record({
+            id: nextEventId(`session-error-${spec.planned.id}`),
+            at: createdAt,
+            level: "error",
+            type: "concurrent-shared-world.session.error",
+            message: `Persona ${spec.planned.id}: ${outcome.sessionError}`,
+        });
+    }
+    else if (inProgress) {
+        record({
+            id: nextEventId(`running-${spec.planned.id}`),
+            at: createdAt,
+            level: "info",
+            type: "actor.running",
+            message: `Persona ${spec.planned.id}: desktop actor is running; live stream URL is runtime-only and not persisted.`,
+        });
+    }
+    else {
+        record({
+            id: nextEventId(`contract-${spec.planned.id}`),
+            at: createdAt,
+            level: "info",
+            type: "concurrent-shared-world.contract.ready",
+            message: `Persona ${spec.planned.id}: dry-run contract actor ready; switch scenario.mode to live for a real concurrent session.`,
+        });
+    }
+    return events;
+}
+/** One participant's simulation, stream and events. */
+export function sharedWorldParticipantRecords(ctx, spec, index) {
+    const view = participantView(ctx, spec, index);
+    return {
+        simulation: sharedWorldSimulation(ctx, spec, index, view),
+        stream: sharedWorldStream(ctx, spec, index, view),
+        events: sharedWorldEvents(ctx, spec, view),
+    };
+}

package/dist/routes/shared-world/seats.d.ts

@@ -0,0 +1,38 @@
+import type { SharedWorldPlan } from "../../lab/plan-types.js";
+import type { Participant, SharedWorldParticipant } from "../../lab/plan-participants.js";
+import type { RunBundle } from "../../run/bundle.js";
+import type { CuaParticipantDeps, DesktopParticipantRun, ParticipantRunOutcome } from "../computer-use/types.js";
+import type { LiveParticipants, PlaneContext } from "./types.js";
+export declare function defaultSessionTimeoutMs(plan: SharedWorldPlan): number;
+/** Resolve an actor's seat URL against the harness-minted getHost base (entry is a same-origin
+ *  relative path, validated at parse against serve.url). */
+export declare function resolveActorEntryUrl(baseUrl: string, entry: string | undefined): string;
+export declare function participantTaxonomyLabel(labels: Participant["labels"]): string;
+/** Thread the host-yielded lobby CODE into a follower's mission at runtime (external-public route).
+ *  The CODE flows into the follower's join instruction; it is persisted only as the composed prompt
+ *  the model reads (never a raw bundle field), and the lab scrubs the CODE from all narration. The
+ *  follower joins through the real UI (a direct /lobby/CODE visit does not auto-join a non-member). */
+export declare function withLobbyCodeMission(spec: DesktopParticipantRun, code: string): DesktopParticipantRun;
+/** A follower blocked by an expired deadline or an ended host. It never opened a browser;
+ * keep the actual reason rather than turning every upstream failure into a timeout. */
+export declare function makeBlockedFollowerOutcome(spec: DesktopParticipantRun, reason: string, timedOut: boolean): ParticipantRunOutcome;
+/** The computer-use runner deps every participant shares, on either plane. */
+export type ParticipantRunDeps = Omit<CuaParticipantDeps, "signalProvisioned" | "appUrl" | "onObservedUrl">;
+/**
+ * A live run publishes an in-progress bundle before its seats start, whether or not an Observer
+ * is attached, and the seats' live traces rewrite it as they go, as on the computer-use route. A
+ * run killed mid-way leaves that evidence on disk. The flush starts with the first snapshot.
+ */
+export declare function startParticipantFlush(ctx: PlaneContext, live: LiveParticipants, bundle: RunBundle): void;
+/**
+ * The runner deps both planes give every participant. cloneRoute=false + subjectEnvNames=[] keep subject
+ * creds out of every actor sandbox (FIX-10). `scrubKnownValues` is the plane's scrub: the
+ * external-public plane also scrubs the latched lobby code.
+ */
+export declare function participantRunDeps(ctx: PlaneContext, live: LiveParticipants, scrubKnownValues: (text: string) => string): ParticipantRunDeps;
+/**
+ * Each participant's actor spec, with committed personas compiled in so each prompt carries real
+ * behavioral directives (#381). Evidence copies of the assignment, instructions and persona are
+ * scrubbed of the run's known secret values.
+ */
+export declare function buildParticipantSpecs(participants: readonly SharedWorldParticipant[], cwd: string, scrubKnownValues: (text: string) => string): Promise<DesktopParticipantRun[]>;

package/dist/routes/shared-world/seats.js

@@ -0,0 +1,208 @@
+// Builds each participant's actor spec and mission, resolves its entry URL, derives the session
+// and sandbox time budgets, and records a follower that never received the host's lobby code.
+import { DEFAULT_OPENAI_CU_MODEL } from "../../actors/computer-use/openai-provider.js";
+import { scrubPersonaBrief } from "../../lab/persona.js";
+import { resolveParticipant } from "../../run/participant.js";
+import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
+import { composeParticipantInstructions } from "../computer-use/participant-prompt.js";
+import { startLiveTraceFlush } from "../computer-use/live-flush.js";
+import { resolveCommittedPersonasForCwd } from "../../lab/persona-resolve.js";
+import { participantAssignment } from "../../lab/participant-assignment.js";
+import { redactText } from "../../evidence/redaction.js";
+import { MAX_SANDBOX_MS, SANDBOX_TIMEOUT_BUFFER_MS, SUBJECT_PROVISION_BUDGET_MS, } from "../../substrates/e2b/lifetime.js";
+import { DEFAULT_STATE_STEP_TIMEOUT_MS } from "../../subject/state.js";
+// The DEFAULT per-seat session budget is DERIVED, not flat. On a provisioned route the binding
+// constraint is the SUBJECT sandbox (it must outlive every seat: timeoutMs + provisioning +
+// seeding + teardown buffer, and E2B refuses a sandbox over one hour), so the derivation hands
+// each seat the most that cap allows — capped at 15 minutes, floored at the historical 300s so a
+// seed-heavy lab never gets LESS room than it always had. App-url seats have no subject sandbox
+// and default to 30 minutes (seat sandbox: 30m + 10m buffer stays well under the hour). An
+// explicit execution.timeoutMs is never adjusted. The handoff latch scales off this (40%).
+const MAX_DERIVED_SESSION_MS = 15 * 60_000;
+const MIN_DERIVED_SESSION_MS = 300_000;
+const DEFAULT_APP_URL_SESSION_MS = 30 * 60_000;
+export function defaultSessionTimeoutMs(plan) {
+    if (plan.plane.kind !== "provisioned")
+        return DEFAULT_APP_URL_SESSION_MS;
+    const stateBudgetMs = (plan.plane.subject.state.seed ?? []).reduce((sum, step) => sum + (step.timeoutMs ?? DEFAULT_STATE_STEP_TIMEOUT_MS), 0);
+    const room = MAX_SANDBOX_MS - SUBJECT_PROVISION_BUDGET_MS - stateBudgetMs - SANDBOX_TIMEOUT_BUFFER_MS;
+    return Math.max(MIN_DERIVED_SESSION_MS, Math.min(MAX_DERIVED_SESSION_MS, room));
+}
+const DEFAULT_MISSION = "You are one of MANY users hitting a shared web application at the same time. The browser is already open at the app. Accomplish your role's task, then stop.";
+/** Resolve an actor's seat URL against the harness-minted getHost base (entry is a same-origin
+ *  relative path, validated at parse against serve.url). */
+export function resolveActorEntryUrl(baseUrl, entry) {
+    if (!entry)
+        return baseUrl;
+    try {
+        return new URL(entry, baseUrl).toString();
+    }
+    catch {
+        return baseUrl;
+    }
+}
+export function participantTaxonomyLabel(labels) {
+    const parts = [
+        labels.actorType ? `type:${labels.actorType}` : undefined,
+        labels.surface ? `surface:${labels.surface}` : undefined,
+        labels.caseGroup ? `case:${labels.caseGroup}` : undefined,
+    ].filter((part) => part !== undefined);
+    return parts.length > 0 ? ` (${parts.join(" / ")})` : "";
+}
+/** Build one participant's DesktopParticipantRun from its plan (each participant has its own
+ *  desktop, so its own device). */
+function buildActorSpec(participant, personas) {
+    const mission = participant.assignment.mission ?? DEFAULT_MISSION;
+    const focus = participant.assignment.focus;
+    const { device, personaId } = participant;
+    const resolvedPersona = personaId === undefined ? undefined : personas.get(personaId);
+    const composed = composeParticipantInstructions({
+        mission,
+        ...(personaId === undefined ? {} : { persona: personaId }),
+        ...(resolvedPersona === undefined ? {} : { resolvedPersona }),
+        ...(focus === undefined ? {} : { instruction: focus }),
+        device: { name: device.name, preset: device.preset },
+    });
+    const run = resolveParticipant(participant, {
+        persona: composed.persona,
+        instructions: composed.instructions,
+        evidenceAssignment: { mission, ...(focus === undefined ? {} : { focus }) },
+    });
+    return {
+        ...run,
+        screenshotDir: participant.id,
+        traceArtifactPath: `actors/${run.streamId}.json`,
+    };
+}
+/** Thread the host-yielded lobby CODE into a follower's mission at runtime (external-public route).
+ *  The CODE flows into the follower's join instruction; it is persisted only as the composed prompt
+ *  the model reads (never a raw bundle field), and the lab scrubs the CODE from all narration. The
+ *  follower joins through the real UI (a direct /lobby/CODE visit does not auto-join a non-member). */
+export function withLobbyCodeMission(spec, code) {
+    return {
+        ...spec,
+        instructions: `${spec.instructions}\n\nThe multiplayer lobby code is ${code}. On the home screen choose Join, enter this lobby code, enter your name, and submit to join the shared game (do not open a lobby URL directly — go through the Join flow).`,
+    };
+}
+/** A follower blocked by an expired deadline or an ended host. It never opened a browser;
+ * keep the actual reason rather than turning every upstream failure into a timeout. */
+export function makeBlockedFollowerOutcome(spec, reason, timedOut) {
+    return {
+        spec,
+        sessionError: `handoff barrier: ${reason}; this follower failed closed WITHOUT opening (no wasted turns).`,
+        killed: false,
+        streamUrlPresent: false,
+        screenshots: [],
+        stateStepRecords: [],
+        phaseRecords: [],
+        warnings: [],
+        noEngagement: true,
+        selfReportedBlocker: false,
+        harnessError: false,
+        skippedReason: timedOut ? "handoff-timeout" : "host-ended-before-handoff",
+    };
+}
+/**
+ * A live run publishes an in-progress bundle before its seats start, whether or not an Observer
+ * is attached, and the seats' live traces rewrite it as they go, as on the computer-use route. A
+ * run killed mid-way leaves that evidence on disk. The flush starts with the first snapshot.
+ */
+export function startParticipantFlush(ctx, live, bundle) {
+    live.flush = startLiveTraceFlush({
+        bundle,
+        participantRuns: ctx.actorSpecs,
+        model: ctx.config.actors[0]?.model ?? DEFAULT_OPENAI_CU_MODEL,
+        write: (snapshot) => ctx.run.writeSnapshot(snapshot),
+    });
+}
+/**
+ * The caller's desktop hooks, plus the runtime stream URLs each seat reports to the live Observer.
+ * The Observer learns of a stream before the caller's stream hook runs.
+ */
+function runtimeStreamHooks(hooks, live) {
+    return {
+        ...(hooks.loadDesktopModule ? { loadDesktopModule: hooks.loadDesktopModule } : {}),
+        ...(hooks.detachedTimers ? { detachedTimers: hooks.detachedTimers } : {}),
+        ...(hooks.env ? { env: hooks.env } : {}),
+        ...(hooks.prepareDesktop
+            ? {
+                prepareDesktop: (desktop, participant) => hooks.prepareDesktop(desktop, participant),
+            }
+            : {}),
+        onRuntimeStreamReady: (stream) => {
+            live.streamUrls.push({ streamId: stream.streamId, url: stream.url });
+            if (live.observer) {
+                attachObserverRuntimeStreamUrls(live.observer, live.streamUrls);
+            }
+            return hooks.onRuntimeStreamReady?.(stream);
+        },
+        onRuntimeStreamEnded: (stream) => {
+            // Mark, never remove (#357): the tile falls back to recorded evidence and says why.
+            for (const entry of live.streamUrls) {
+                if (entry.streamId === stream.streamId)
+                    entry.ended = true;
+            }
+            if (live.observer) {
+                attachObserverRuntimeStreamUrls(live.observer, live.streamUrls);
+            }
+            return hooks.onRuntimeStreamEnded?.(stream);
+        },
+    };
+}
+/**
+ * The runner deps both planes give every participant. cloneRoute=false + subjectEnvNames=[] keep subject
+ * creds out of every actor sandbox (FIX-10). `scrubKnownValues` is the plane's scrub: the
+ * external-public plane also scrubs the latched lobby code.
+ */
+export function participantRunDeps(ctx, live, scrubKnownValues) {
+    const { config, descriptor, env, receiving, runBudget } = ctx;
+    return {
+        onTrace: (participantId, items, usage, metadata) => live.flush?.flush(participantId, items, usage, metadata),
+        config,
+        descriptor,
+        cloneRoute: false,
+        subjectEnvNames: [],
+        hasGithubToken: false,
+        env,
+        openaiApiKey: ctx.openaiApiKey,
+        e2bApiKey: ctx.e2bApiKey,
+        requestTimeoutMs: ctx.requestTimeoutMs,
+        sandboxMs: ctx.timeoutMs + SANDBOX_TIMEOUT_BUFFER_MS,
+        timeoutMs: ctx.timeoutMs,
+        participantCount: ctx.plan.plane.participants.length,
+        artifactRoot: ctx.runPaths,
+        labCwd: ctx.cwd,
+        redactScreenshots: ctx.redactScreenshots,
+        scrubKnownValues,
+        runSession: ctx.runSession,
+        // A local-agent brain runs each seat on the operator's signed-in agent, as on computer use.
+        ...(ctx.plan.brain.kind === "local-agent" ? { localAgent: ctx.plan.brain.agent } : {}),
+        ...(receiving ? { receiving } : {}),
+        now: ctx.now,
+        hooks: runtimeStreamHooks(ctx.hooks, live),
+        ...(runBudget === undefined ? {} : { runBudget }),
+        // Concurrent lanes are independent evidence seats: a requested-vs-verified screen
+        // mismatch is recorded as separate facts + a warning instead of failing the lane's
+        // device claim closed, so one seat's window-manager drift cannot abort the whole
+        // live multi-actor world (the single-lane/fan-out routes keep fail-closed).
+        screenMismatchPolicy: "record-evidence",
+    };
+}
+/**
+ * Each participant's actor spec, with committed personas compiled in so each prompt carries real
+ * behavioral directives (#381). Evidence copies of the assignment, instructions and persona are
+ * scrubbed of the run's known secret values.
+ */
+export async function buildParticipantSpecs(participants, cwd, scrubKnownValues) {
+    // Only the personas the participants use: an actors[0].persona that every seat overrides is
+    // never applied, so it is not read.
+    const personaResolution = await resolveCommittedPersonasForCwd(cwd, participants.map((participant) => participant.personaId));
+    const actorSpecs = participants.map((participant) => buildActorSpec(participant, personaResolution.personas));
+    for (const spec of actorSpecs) {
+        if (spec.evidenceAssignment)
+            spec.evidenceAssignment = participantAssignment(spec.evidenceAssignment, scrubKnownValues);
+        spec.evidenceInstructions = redactText(scrubKnownValues(spec.instructions));
+        spec.persona = scrubPersonaBrief(spec.persona, scrubKnownValues);
+    }
+    return actorSpecs;
+}

package/dist/routes/shared-world/setup.d.ts

@@ -0,0 +1,48 @@
+import type { CuaActorDescriptor } from "../../actors/registry.js";
+import type { LabConfig, LabSubjectServe, LabSubjectStateCheckpoint } from "../../lab/types.js";
+import type { RunScope } from "../../run/run.js";
+import type { ConcurrentSharedWorldLabErrorCode, ConcurrentSharedWorldLabResult, ConcurrentSharedWorldPlaneClass, FinishFacts, LiveParticipants, PlaneContext, PlaneResults, PlaneSelection, SharedWorldLabHooks, SharedWorldRunInput } from "./types.js";
+import type { SharedWorldPlan } from "../../lab/plan-types.js";
+/** What validation derived from the lab, which setup reads. */
+interface AdmittedLab {
+    plan: SharedWorldPlan;
+    input: SharedWorldRunInput;
+    /** Read by the computer-use lane runner, whose hooks and desktop setup take the whole config.
+     *  Seats, their count and their host and entry come from the plan's participants. */
+    config: LabConfig;
+    requestedCwd: string;
+    hooks: SharedWorldLabHooks;
+    env: Record<string, string | undefined>;
+    descriptor: CuaActorDescriptor;
+    planeClass: ConcurrentSharedWorldPlaneClass;
+    runBudget: PlaneContext["runBudget"];
+    runSession: PlaneContext["runSession"];
+    serve: LabSubjectServe | undefined;
+    localTreeRoute: boolean;
+    subjectRepo: string;
+    subjectEnvNames: string[];
+    checkpoints: LabSubjectStateCheckpoint[];
+    openaiApiKey: string;
+    e2bApiKey: string;
+    knownSecretValues: string[];
+    scrubKnownValues: (text: string) => string;
+    publicRepo: string;
+    hasGithubToken: boolean;
+    fail: (code: ConcurrentSharedWorldLabErrorCode, message: string, actorLabel?: string) => ConcurrentSharedWorldLabResult;
+}
+/**
+ * Starts the run and prepares what the planes read: the physical project, the run, the seat
+ * specs, comms, the packed tree and email receiving. Returns the refusal when one of them fails.
+ */
+export declare function prepareConcurrentRun(lab: AdmittedLab, scope: RunScope): Promise<{
+    ok: false;
+    result: ConcurrentSharedWorldLabResult;
+} | {
+    ok: true;
+    ctx: PlaneContext;
+    live: LiveParticipants;
+    results: PlaneResults;
+    plane: PlaneSelection;
+    finish: FinishFacts;
+}>;
+export {};