humanish 0.106.1 → 0.107.0

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

@@ -1,7 +1,6 @@
 import { type CuaActorDescriptor } from "../../actors/registry.js";
 import type { RoutePlanResult, RouteRefusal, SharedWorldPlan } from "../../lab/plan-types.js";
 import type { LabConfig, LabSubjectState } from "../../lab/types.js";
-import type { RunLabProvenance } from "../../run/status.js";
 import type { ConcurrentSharedWorldLabErrorCode } from "./types.js";
 /** The error a shared-world lab returns before a run starts. */
 export interface SharedWorldRefusal extends RouteRefusal<"shared-world", ConcurrentSharedWorldLabErrorCode> {
@@ -17,11 +16,8 @@ export declare function sharedWorldDescriptorOf(actorType: string): CuaActorDesc
  */
 export declare function planSharedWorldLab(config: LabConfig, input: {
     readonly dryRun: boolean;
-    readonly lab?: RunLabProvenance;
-    /** A caller's session runner cannot enforce maxOutputTokens. */
-    readonly hooks?: {
-        readonly runSession?: unknown;
-    };
+    /** Whether deps.runSession is set: a caller's session runner cannot enforce maxOutputTokens. */
+    readonly hasRunSession?: boolean;
 }): SharedWorldPlanResult;
 /** The provisioned plane's declared subject state. The external-public plane declares none. */
 export declare function planeStateOf(plan: SharedWorldPlan): LabSubjectState | undefined;

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

@@ -55,7 +55,7 @@ export function planSharedWorldLab(config, input) {
             : concurrentSharedWorldValidationReason(config));
     if (invalidReason)
         return refuse(invalid, invalidReason, actor);
-    if (config.actors[0]?.maxOutputTokens !== undefined && input.hooks?.runSession)
+    if (config.actors[0]?.maxOutputTokens !== undefined && input.hasRunSession === true)
         return refuse(invalid, "maxOutputTokens cannot be enforced by a custom runSession.", actor);
     const caps = config.execution?.caps;
     if (!input.dryRun && (caps?.maxUsd !== undefined || caps?.maxTotalUsd !== undefined)) {
@@ -88,7 +88,6 @@ export function planSharedWorldLab(config, input) {
         throw new Error("a shared-world participant has no caller brain");
     const base = planBase(config, {
         dryRun: input.dryRun,
-        ...(input.lab === undefined ? {} : { lab: input.lab }),
         analysis,
     });
     return {

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

@@ -2,18 +2,18 @@ import type { RunSubjectProvenance } from "../../run/bundle.js";
 import type { LocalTreeArchive } from "../../subject/local-tree-archive.js";
 /** Extract the in-sandbox port from the (loopback) serve.url so getHost can expose it. */
 export declare function servePort(serveUrl: string): number;
-/** A getHost URL must be TOKENLESS (no userinfo, no query — no authKey; invariant 1). */
+/** A getHost URL must be tokenless (no userinfo and no query, so no authKey; invariant 1). */
 export declare function isTokenlessHost(value: string): boolean;
-/** sha256-16 of a URL's ORIGIN — the publish-safe host identity persisted in the bundle (the raw
+/** sha256-16 of a URL's origin: the publish-safe host identity persisted in the bundle (the raw
  *  getHost URL embeds the live sandbox id + matches the e2b-URL redaction, so it never lands raw). */
 export declare function hostOriginDigest(url: string): string;
 /** A public-safe, human-readable route label for the bundle (host redacted to a placeholder; the
  *  entry path kept). Never contains the raw getHost URL. */
 export declare function publicSafeRouteLabel(entry: string | undefined): string;
 /**
- * Build the ONE subject sandbox's provenance (invariant 5): clone (repo + optional commit) or
+ * Build the one subject sandbox's provenance (invariant 5): clone (repo + optional commit) or
  * local-tree (archiveSha256 + optional commit/dirty from the once-per-run host-packed archive -
- * archiveSha256 IS the pin; there is only ONE archive, so no per-lane unanimity math applies,
+ * archiveSha256 is the pin; there is only one archive, so no per-participant unanimity math applies,
  * unlike the cua fan-out route). Used for both the in-progress and final bundle: the archive
  * never changes mid-run (packed before any sandbox exists).
  */

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

@@ -8,7 +8,7 @@ export function servePort(serveUrl) {
         return Number(url.port);
     return url.protocol === "https:" ? 443 : 80;
 }
-/** A getHost URL must be TOKENLESS (no userinfo, no query — no authKey; invariant 1). */
+/** A getHost URL must be tokenless (no userinfo and no query, so no authKey; invariant 1). */
 export function isTokenlessHost(value) {
     try {
         const url = new URL(value);
@@ -18,7 +18,7 @@ export function isTokenlessHost(value) {
         return false;
     }
 }
-/** sha256-16 of a URL's ORIGIN — the publish-safe host identity persisted in the bundle (the raw
+/** sha256-16 of a URL's origin: the publish-safe host identity persisted in the bundle (the raw
  *  getHost URL embeds the live sandbox id + matches the e2b-URL redaction, so it never lands raw). */
 export function hostOriginDigest(url) {
     try {
@@ -34,9 +34,9 @@ export function publicSafeRouteLabel(entry) {
     return `[provisioned-subject]${entry ?? "/"}`;
 }
 /**
- * Build the ONE subject sandbox's provenance (invariant 5): clone (repo + optional commit) or
+ * Build the one subject sandbox's provenance (invariant 5): clone (repo + optional commit) or
  * local-tree (archiveSha256 + optional commit/dirty from the once-per-run host-packed archive -
- * archiveSha256 IS the pin; there is only ONE archive, so no per-lane unanimity math applies,
+ * archiveSha256 is the pin; there is only one archive, so no per-participant unanimity math applies,
  * unlike the cua fan-out route). Used for both the in-progress and final bundle: the archive
  * never changes mid-run (packed before any sandbox exists).
  */

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

@@ -3,7 +3,7 @@ import type { RunSubjectStateStepRecord } from "../../run/bundle.js";
 import type { SharedWorldStateSnapshot } from "../../run/shared-world-evidence.js";
 import type { LocalTreeArchive } from "../../subject/local-tree-archive.js";
 import type { DetachedTimers } from "../../substrates/detached.js";
-import type { SharedWorldLabHooks } from "./types.js";
+import type { LabDeps } from "../../lab/lab-deps.js";
 import { type ActorRunResult, type SubjectDesktopUsage, type LiveParticipants, type PlaneContext } from "./types.js";
 /** What the provisioned plane needs besides the shared plane context. */
 export interface ProvisionedPlaneSetup {
@@ -35,6 +35,7 @@ export interface ProvisionedPlaneOutcome {
     subjectCommit: string | undefined;
     subjectSandboxId: string | undefined;
     subjectKilled: boolean;
+    subjectReleaseWarning: string | undefined;
     subjectDesktop: SubjectDesktopUsage | undefined;
     getHostUrl: string | undefined;
     /** Set when the teardown drain wrote a comms thread. */
@@ -47,7 +48,7 @@ export declare function runProvisionedPlane(ctx: PlaneContext, live: LivePartici
  */
 export declare function packSubjectTree(cwd: string, config: {
     readonly subject: Pick<LabConfig["subject"], "localTree">;
-}, hooks: SharedWorldLabHooks, scrubKnownValues: (text: string) => string): Promise<{
+}, deps: LabDeps, scrubKnownValues: (text: string) => string): Promise<{
     ok: true;
     archive: LocalTreeArchive;
     buffer: ArrayBuffer;

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

@@ -1,4 +1,4 @@
-// The PROVISIONED-GETHOST plane: the harness provisions ONE subject sandbox (clone or local-tree,
+// The provisioned-getHost plane: the harness provisions one subject sandbox (clone or local-tree,
 // install/build, seed, serve on 0.0.0.0), exposes it through getHost, probes its state on a
 // cadence, and runs every seat against that one shared plane. All sandboxes are torn down by exact
 // id in the plane's finally, never through Sandbox.list.
@@ -10,6 +10,7 @@ import { mapWithConcurrency } from "../../run/concurrency.js";
 import { provisionCloneSubject } from "../../subject/clone.js";
 import { provisionLocalTreeSubject } from "../../subject/local-tree.js";
 import { defaultSharedWorldPhaseSink } from "../../subject/steps.js";
+import { phaseEvent } from "../../lab/run-lab-events.js";
 import { loadE2BDesktopModule } from "../../substrates/e2b/sdk.js";
 import { observeDesktopResources, } from "../../substrates/e2b/desktop-resources.js";
 import { acquireE2BDesktopSandbox, readE2BRelease } from "../../substrates/e2b/sandbox.js";
@@ -19,14 +20,14 @@ import { inboxRecipientFor, participantHasInboxRecipient, } from "../computer-us
 import { resolveSubjectState } from "../computer-use/subject-projection.js";
 import { withInboxMission } from "../computer-use/participant-prompt.js";
 import { planeStateOf } from "./plan.js";
-import { runCuaParticipant } from "../computer-use/lanes.js";
+import { runCuaParticipant } from "../computer-use/participant-execution.js";
 import { buildConcurrentSharedWorldBundle, judgeSharedWorldRun } from "./bundle.js";
 import { runCheckpointSnapshot } from "./checkpoints.js";
 import { drainSubjectComms } from "./comms.js";
 import { buildSubjectProvenance, hostOriginDigest, isTokenlessHost, servePort, } from "./provenance.js";
 import { SANDBOX_TIMEOUT_BUFFER_MS, SUBJECT_PROVISION_BUDGET_MS, } from "../../substrates/e2b/lifetime.js";
 import { DEFAULT_STATE_STEP_TIMEOUT_MS } from "../../subject/state.js";
-import { resolveActorEntryUrl, participantRunDeps, startParticipantFlush } from "./seats.js";
+import { resolveActorEntryUrl, participantRunDeps, startParticipantFlush, } from "./participant-specs.js";
 import { CONCURRENT_SHARED_WORLD_PROVIDER_METADATA, } from "./types.js";
 import { addressedRecipients } from "../../lab/parse/comms.js";
 /**
@@ -41,12 +42,13 @@ class ObserverGateError extends Error {
         this.name = "ObserverGateError";
     }
 }
-/** The ONE subject sandbox and the loops that run against it until teardown. */
+/** The one subject sandbox and the loops that run against it until teardown. */
 class SubjectPlane {
     commsInboxUrl;
     subjectCommit;
     subjectSandboxId;
     subjectKilled = false;
+    subjectReleaseWarning;
     getHostUrl;
     // The subject desktop's host-side span and size, priced in the run's cost estimate.
     subjectCreatedAtMs;
@@ -57,17 +59,17 @@ class SubjectPlane {
     subjectAllocation;
     subjectDesktop;
     subjectShell;
-    // The in-sandbox email catch on the ONE subject sandbox (#297); drained at teardown. Undefined
+    // The in-sandbox email catch on the one subject sandbox (#297); drained at teardown. Undefined
     // unless a comms lab declared it.
     deployedComms;
-    // Background prober dispose signal (FIX-9: cleared in teardown).
+    // Background prober dispose signal, cleared in teardown.
     proberDisposed = false;
     releaseDispose = () => { };
     disposeSignal;
     proberLoop;
     snapshotIndex = 0;
-    // Persona inbox SURFACE (#297 slice B, shared-world): the serve->getHost origin-rewrite map
-    // (REQUIRED here so the app's loopback verify links resolve to a reachable host), and the
+    // Persona inbox surface (#297 slice B, shared-world): the serve->getHost origin-rewrite map
+    // (required here so the app's loopback verify links resolve to a reachable host), and the
     // dedicated surface render loop.
     commsOriginMap = [];
     surfaceRenderedCount = 0;
@@ -98,12 +100,12 @@ class SubjectPlane {
         this.setup.stateSnapshots.push({ timestamp, digest: snapshot.digest });
     }
     async acquire() {
-        const { plan, hooks, env, requestTimeoutMs, timeoutMs } = this.ctx;
+        const { plan, deps, env, requestTimeoutMs, timeoutMs } = this.ctx;
         const { subjectEnvNames, commsEnv } = this.setup;
-        const subjectModule = await (hooks.loadDesktopModule ?? loadE2BDesktopModule)();
-        // The ONE subject sandbox: headless service host (no GUI seat). The SUBJECT env is provisioned
-        // HERE; the actor sandboxes get NONE of it (FIX-10). A custom desktop template (image) is
-        // honored on BOTH the subject sandbox (here) and every actor sandbox (via runCuaParticipant, which
+        const subjectModule = await (deps.desktopModule ?? loadE2BDesktopModule)();
+        // The one subject sandbox: headless service host (no GUI seat). The subject env is provisioned
+        // here; the actor sandboxes get none of it. A custom desktop template (image) is
+        // honored on both the subject sandbox (here) and every actor sandbox (via runCuaParticipant, which
         // reads the same config); absent keeps the byte-stable Sandbox.create(opts) default. The
         // receipt is on disk before any work, so `humanish reclaim` can kill it by exact id.
         const subject = await acquireE2BDesktopSandbox({
@@ -143,18 +145,16 @@ class SubjectPlane {
         this.subjectSandboxId = subject.allocation.resourceId;
         this.subjectCreatedAtMs = this.ctx.now();
         this.subjectResources = await observeDesktopResources(this.subjectDesktop);
-        if (hooks.prepareDesktop) {
-            await hooks.prepareDesktop(this.subjectDesktop);
-        }
+        await this.ctx.input.prepareDesktop?.(this.subjectDesktop, { kind: "subject" });
     }
-    // Start the in-sandbox email catch BEFORE the subject serve, so the app's send-API base URL
+    // Start the in-sandbox email catch before the subject serve, so the app's send-API base URL
     // (injected into its env at create) resolves the moment it boots. Fail closed if the catch can't
     // stand up rather than let a comms-declared app silently send real mail to the internet.
     async deployCatch() {
         const { commsEmail, commsPort } = this.setup;
         if (commsEmail && commsPort !== undefined) {
-            // A SECOND (0.0.0.0) read-only inbox listener on commsPort+1 so the persona — which lives in a
-            // DIFFERENT sandbox here — can reach the inbox surface via getHost; capture stays loopback.
+            // A second (0.0.0.0) read-only inbox listener on commsPort+1 so the persona, which lives in
+            // another sandbox here, can reach the inbox surface via getHost; capture stays loopback.
             this.deployedComms = await deployCommsCatch(this.subjectShell, {
                 port: commsPort,
                 inboxPort: commsPort + 1,
@@ -166,15 +166,19 @@ class SubjectPlane {
             }
         }
     }
-    // Provision the ONE shared plane: clone + install/build + seed + serve on 0.0.0.0 + probe
-    // (clone route), or upload/extract the once-per-run packed archive + the SAME shared serve
+    // Provision the one shared plane: clone + install/build + seed + serve on 0.0.0.0 + probe
+    // (clone route), or upload/extract the once-per-run packed archive + the same shared serve
     // pipeline (local-tree route).
     async provision() {
-        const { plan, hooks, requestTimeoutMs, scrubKnownValues } = this.ctx;
+        const { plan, requestTimeoutMs, scrubKnownValues } = this.ctx;
         const { serve, timers, stateStepRecords } = this.setup;
         const state = planeStateOf(plan);
         const subjectShell = this.subjectShell;
-        const onSubjectPhase = hooks.onPhase ?? defaultSharedWorldPhaseSink;
+        const sink = this.ctx.input.deps?.subjectPhaseSink ?? defaultSharedWorldPhaseSink;
+        const onSubjectPhase = (event) => {
+            sink(event);
+            this.ctx.input.emit?.(phaseEvent(event, { kind: "subject" }));
+        };
         if (this.setup.localTreeRoute) {
             await provisionLocalTreeSubject(subjectShell, {
                 archiveBuffer: this.setup.localTreeArchiveBuffer,
@@ -209,13 +213,13 @@ class SubjectPlane {
             });
         }
     }
-    // Expose the served port via getHost (FIX-2). Fail closed if the SDK lacks it.
+    // Expose the served port via getHost. Fail closed if the SDK lacks it.
     exposeHost() {
         const subjectDesktop = this.subjectDesktop;
         if (typeof subjectDesktop.getHost !== "function") {
             throw new Error("the installed @e2b/desktop SDK does not expose getHost(port); the concurrent shared-world route requires it to reach the subject plane");
         }
-        // getHost returns a BARE host (e.g. "3000-<sandboxId>.e2b.app", no scheme); e2b exposes the
+        // getHost returns a bare host (e.g. "3000-<sandboxId>.e2b.app", no scheme); e2b exposes the
         // port over https. Normalize to a full URL before the tokenless check + before persisting.
         const rawHost = subjectDesktop.getHost(servePort(this.setup.serve.url));
         const hostUrl = /^https?:\/\//i.test(rawHost) ? rawHost : `https://${rawHost}`;
@@ -224,12 +228,12 @@ class SubjectPlane {
         }
         this.getHostUrl = hostUrl;
     }
-    // Persona inbox SURFACE (#297 slice B, shared-world): getHost-expose the read-only inbox listener so
-    // a persona in a DIFFERENT sandbox can open it; build the serve->getHost origin map (REQUIRED here —
+    // Persona inbox surface (#297 slice B, shared-world): getHost-expose the read-only inbox listener so
+    // a persona in another sandbox can open it; build the serve->getHost origin map (required here:
     // the app's loopback verify links must be rewritten to a reachable host); provision the surface
-    // channel; write the EMPTY inbox up front (so /inbox never 404s); and start a render loop that drains
+    // channel; write the empty inbox up front (so /inbox never 404s); and start a render loop that drains
     // + re-renders on a cadence. The loop shares the prober's dispose signal (disposed together, before
-    // the teardown evidence drain), and uses a DEDICATED FakeInbox + cursor (independent of that drain).
+    // the teardown evidence drain), and uses a dedicated FakeInbox + cursor (independent of that drain).
     async startInboxSurface() {
         const { commsEmail } = this.setup;
         const { requestTimeoutMs } = this.ctx;
@@ -303,7 +307,7 @@ class SubjectPlane {
                     this.disposeSignal,
                 ]);
                 if (timer)
-                    clearTimeout(timer); // FIX-9: no dangling prober timer.
+                    clearTimeout(timer); // No dangling prober timer.
                 if (this.proberDisposed)
                     break;
                 await this.snapshot().catch(() => undefined);
@@ -311,8 +315,8 @@ class SubjectPlane {
         })();
     }
     /**
-     * FIX-9: stop the prober, take a final snapshot while the subject is still alive, then tear
-     * down the ONE subject sandbox BY id (the actor sandboxes are torn down inside runCuaParticipant).
+     * Stop the prober, take a final snapshot while the subject is still alive, then tear
+     * down the one subject sandbox by id (the actor sandboxes are torn down inside runCuaParticipant).
      * Returns the comms thread's path when the drain wrote one.
      */
     async teardown() {
@@ -345,6 +349,8 @@ class SubjectPlane {
             this.subjectKilled = reading.released;
             if (reading.warning)
                 warnings.push(reading.warning);
+            if (!reading.released)
+                this.subjectReleaseWarning = reading.warning ?? "Subject sandbox release is unconfirmed.";
             // Without a kill method, or in E2B debug mode, no kill reached E2B, so there is no teardown
             // time to record.
             if (released.status !== "unconfirmed" || released.reason !== "release_unavailable")
@@ -385,11 +391,10 @@ async function publishInProgress(plane, ctx, live, setup) {
     });
     const snapshotArgs = {
         plan,
+        run: ctx.run,
         descriptor: ctx.descriptor,
-        createdAt: ctx.createdAt,
         dryRun: false,
         inProgress: true,
-        runId: ctx.runId,
         source: ctx.source,
         actorSpecs: ctx.actorSpecs,
         actorResults: [],
@@ -417,9 +422,9 @@ async function publishInProgress(plane, ctx, live, setup) {
     }
     startParticipantFlush(ctx, live, inProgressBundle);
 }
-// Launch N actor sandboxes CONCURRENTLY, INDEPENDENT (FIX-11: runCuaParticipant + mapWithConcurrency,
-// NOT runCuaParticipants — no pipeline gate / fail-fast). Each actor's window is measured on the ONE
-// orchestrator clock (FIX-1).
+// Launch N actor sandboxes concurrently and independently (runCuaParticipant + mapWithConcurrency;
+// runCuaParticipants would add a pipeline gate and fail-fast). Each actor's window is measured on the
+// one orchestrator clock.
 function runParticipants(plane, ctx, live, setup) {
     const { now } = ctx;
     const participants = ctx.plan.plane.participants;
@@ -427,7 +432,7 @@ function runParticipants(plane, ctx, live, setup) {
     const baseActorDeps = participantRunDeps(ctx, live, ctx.scrubKnownValues);
     return mapWithConcurrency(ctx.actorSpecs, Math.max(1, ctx.concurrency), async (spec, i) => {
         const route = resolveActorEntryUrl(plane.getHostUrl, participants[i]?.entry);
-        // Tell this persona its (getHost-reachable) inbox URL — but only when comms is live AND this lane
+        // Tell this persona its (getHost-reachable) inbox URL, but only when comms is live and this participant
         // has a declared recipient it can actually receive mail into (else it would stall on an empty
         // inbox). Only the in-sandbox catch exists on this plane; the adopter-hosted catch is the
         // external-public plane's (#387).
@@ -472,6 +477,7 @@ export async function runProvisionedPlane(ctx, live, setup) {
         subjectCommit: plane.subjectCommit,
         subjectSandboxId: plane.subjectSandboxId,
         subjectKilled: plane.subjectKilled,
+        subjectReleaseWarning: plane.subjectReleaseWarning,
         subjectDesktop: plane.desktopUsage(),
         getHostUrl: plane.getHostUrl,
         commsArtifactPath,
@@ -481,8 +487,8 @@ export async function runProvisionedPlane(ctx, live, setup) {
  * Packs the working tree once per run, on the host, for a local-tree subject. Returns the archive,
  * or the message the run fails with.
  */
-export async function packSubjectTree(cwd, config, hooks, scrubKnownValues) {
-    const packLocalTree = hooks.packLocalTree ?? defaultPackLocalTree;
+export async function packSubjectTree(cwd, config, deps, scrubKnownValues) {
+    const packLocalTree = deps.packLocalTree ?? defaultPackLocalTree;
     try {
         const packed = await packLocalTree({
             root: cwd,

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

@@ -1,10 +1,10 @@
 // Finishing a concurrent shared-world run: publishing its bundle, rendering the Observer, and the
 // lab result with each role's outcome and the one error a run that did not pass reports.
 import { redactText } from "../../evidence/redaction.js";
-import { adapterScoreFailureMessage, applyBrowserAdapterHooks, } from "../../lab/adapter-extension.js";
+import { adapterScoreFailureMessage, applyBrowserScorer } from "../../lab/adapter-extension.js";
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
-import { foldScorerFailures, judgeExecution, OUTCOME_POLICIES, participantHarnessFailed, resultOk, sharedWorldShortfall, } from "../../run/judge.js";
-import { participantFactsOf } from "../computer-use/participant-facts.js";
+import { foldScorerFailures, judgeExecution, sandboxCleanupFailure, OUTCOME_POLICIES, participantHarnessFailed, resultOk, sharedWorldShortfall, } from "../../run/judge.js";
+import { participantFactsOf, unreleasedSandboxFailures, } from "../computer-use/participant-facts.js";
 import { resolveSubjectState } from "../computer-use/subject-projection.js";
 import { actorRunPassed, buildConcurrentSharedWorldBundle, judgeSharedWorldRun, maxSimultaneousWindows, } from "./bundle.js";
 import { planeStateOf } from "./plan.js";
@@ -18,6 +18,7 @@ export function emptyPlaneResults() {
         subjectCommit: undefined,
         subjectSandboxId: undefined,
         subjectKilled: false,
+        subjectReleaseWarning: undefined,
         subjectDesktop: undefined,
         getHostUrl: undefined,
         publicOriginDigest: undefined,
@@ -85,8 +86,8 @@ function concurrentLabError(args) {
     if (ok)
         return undefined;
     if (handoffTimedOut) {
-        // Checked BEFORE the observer failure: the host never yielded a /lobby/CODE within the
-        // deadline (followers failed closed without opening), which is the ROOT CAUSE — and it can
+        // Checked before the observer failure: the host never yielded a /lobby/CODE within the
+        // deadline (followers failed closed without opening), which is the root cause, and it can
         // itself make the Observer unable to render a coherent run. Report the distinct, honest
         // handoff-timeout code rather than a generic observer/run failure.
         return {
@@ -159,10 +160,12 @@ export function concurrentLabFailure(envelope) {
 }
 /**
  * The run's execution failures: a run error (the handoff, the plane), each seat whose session
- * failed in the harness, and an Observer that failed.
+ * failed in the harness, each provider whose cleanup is unconfirmed or that reported a disallowed
+ * item after its last request, each sandbox whose release is unconfirmed, and an Observer that
+ * failed.
  */
 function sharedWorldExecutionFailures(args) {
-    const { runError, actorResults, observer } = args;
+    const { runId, runError, actorResults, subject, observer } = args;
     return [
         ...(runError === undefined ? [] : [{ kind: "run", message: runError }]),
         ...actorResults
@@ -179,6 +182,18 @@ function sharedWorldExecutionFailures(args) {
                     message: `${result.spec.planned.id}: ${result.outcome.providerCleanupError}`,
                 },
             ]),
+        ...actorResults.flatMap((result) => result.outcome.providerPolicyError === undefined
+            ? []
+            : [
+                {
+                    kind: "provider-policy",
+                    message: `${result.spec.planned.id}: ${result.outcome.providerPolicyError}`,
+                },
+            ]),
+        ...unreleasedSandboxFailures(actorResults.map((result) => result.outcome), runId),
+        ...(subject.subjectSandboxId === undefined || subject.subjectKilled
+            ? []
+            : [sandboxCleanupFailure("subject", subject.subjectReleaseWarning, runId)]),
         ...(observer.ok
             ? []
             : [
@@ -191,7 +206,7 @@ function sharedWorldExecutionFailures(args) {
 }
 /** Builds and publishes the bundle, renders the Observer and returns the lab result. */
 export async function finishConcurrentRun(ctx, live, results, plane) {
-    const { plan, input, descriptor, hooks, actorSpecs, run, runId, createdAt } = ctx;
+    const { plan, input, descriptor, actorSpecs, run, runId } = ctx;
     const participantCount = plan.plane.participants.length;
     const { cwd, concurrency, source, seedDigest, receiving, warnings, scrubKnownValues } = ctx;
     const { dryRun } = plan;
@@ -218,17 +233,15 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
             }),
         });
     const planeCommit = localTreeRoute ? localTreeArchive?.git?.commit : subjectCommit;
-    // Collect per-actor warnings (each lane's own teardown/raw-screenshot notes).
+    // Collect per-actor warnings (each participant's own teardown/raw-screenshot notes).
     for (const result of actorResults) {
         warnings.push(...result.outcome.warnings);
     }
     const bundleArgs = {
-        ...(plan.lab === undefined ? {} : { lab: plan.lab }),
+        run,
         plan,
         descriptor,
-        createdAt,
         dryRun,
-        runId,
         source,
         actorSpecs,
         actorResults,
@@ -249,8 +262,8 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
     const judgment = judgeSharedWorldRun(bundleArgs);
     const bundle = buildConcurrentSharedWorldBundle({ ...bundleArgs, judgment });
     const adapterWarnings = [];
-    const scorerResult = await applyBrowserAdapterHooks({
-        hooks,
+    const scorerResult = await applyBrowserScorer({
+        scorer: input.scorer,
         bundle,
         context: {
             bundle,
@@ -258,13 +271,12 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
             labId: plan.labId,
             runId,
             actor: descriptor.id,
-            backend: "concurrent-shared-world",
+            route: "shared-world",
             dryRun,
-            laneCount: participantCount,
+            participantCount,
         },
         sanitize: (text) => redactText(scrubKnownValues(text)),
         warnings: adapterWarnings,
-        hookLabel: "sharedWorldHooks",
         ...(input.scorerProvenance === undefined ? {} : { scorerProvenance: input.scorerProvenance }),
     });
     // The one final verdict fold: scoring can only make the judged verdict stricter.
@@ -276,13 +288,13 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
     if (observer.ok && live.observer) {
         attachObserverRuntimeStreamUrls(observer, live.streamUrls);
     }
-    // Concurrent "ok": every actor must produce a terminal, engaged PASSED session, and the seats
+    // Concurrent "ok": every actor must produce a terminal, engaged, passed session, and the seats
     // must show the concurrency verify requires of a pass (judgeSharedWorld). This is a
     // harness/session-credibility gate, not mission-completion proof; a failed actor trace cannot
     // make the route green just because the harness got a terminal.
     const adapterFailure = adapterScoreFailureMessage(bundle);
     const policy = OUTCOME_POLICIES["shared-world"];
-    const execution = judgeExecution(sharedWorldExecutionFailures({ runError, actorResults, observer }), policy);
+    const execution = judgeExecution(sharedWorldExecutionFailures({ runId, runError, actorResults, subject: results, observer }), policy);
     const ok = resultOk({ judgment, execution, scorerFailures: scorerResult.failures, policy });
     const overlapProven = !dryRun && judgment.world.overlap;
     const participantResults = concurrentParticipantResults(actorSpecs, actorResults, dryRun);