humanish 0.106.1 → 0.108.0

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

@@ -1,7 +1,7 @@
-// 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.
+// cadence, and runs every participant against that one shared plane. All sandboxes are torn down by
+// exact id in the plane's finally, never through Sandbox.list.
 import { buildOriginMap } from "../../comms/capture-surface.js";
 import { deployCommsCatch, refreshInboxSurface, writeInboxSurface, } from "../../comms/sandbox-catch.js";
 import { redactText, toErrorMessage } from "../../evidence/redaction.js";
@@ -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; 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: 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 participant). 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({
@@ -120,8 +122,8 @@ class SubjectPlane {
                     labId: plan.labId,
                     topology: "shared-world",
                     topologyMode: "concurrent",
-                    role: "subject",
-                    roleCount: String(plan.plane.participants.length),
+                    kind: "subject",
+                    participantCount: String(plan.plane.participants.length),
                 },
                 ...(subjectEnvNames.length > 0 || Object.keys(commsEnv).length > 0
                     ? {
@@ -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: 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;
@@ -259,7 +263,7 @@ class SubjectPlane {
         const surfaceCadenceMs = 2500;
         this.surfaceLoop = (async () => {
             // Full, idempotent rebuild each tick; surfaceRenderedCount advances only on a successful render,
-            // so a transient failure retries cleanly. Real timer (dispose-interruptible + cleared) — an
+            // so a transient failure retries cleanly. Real timer (dispose-interruptible + cleared): an
             // unbounded loop must not busy-spin on the injected instant clock.
             for (;;) {
                 try {
@@ -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() {
@@ -323,7 +327,7 @@ class SubjectPlane {
             await this.proberLoop.catch(() => undefined);
         }
         // Stop the inbox-surface render loop too (shares the prober's dispose signal), before the teardown
-        // evidence drain below — so the two in-sandbox reads never overlap and the surface state is final.
+        // evidence drain below, so the two in-sandbox reads never overlap and the surface state is final.
         if (this.surfaceLoop) {
             await this.surfaceLoop.catch(() => undefined);
         }
@@ -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")
@@ -364,7 +370,8 @@ class SubjectPlane {
         };
     }
 }
-/** Writes the in-progress bundle, runs the caller's Observer gate and starts the seat flush. */
+/** Writes the in-progress bundle, runs the caller's Observer gate and starts the participants'
+ *  flush. */
 async function publishInProgress(plane, ctx, live, setup) {
     const { plan, input } = ctx;
     const { localTreeRoute, localTreeArchive } = setup;
@@ -385,11 +392,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 +423,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,10 +433,10 @@ 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).
+        // external-public plane's.
         const actorSpec = commsEmail && plane.commsInboxUrl && participantHasInboxRecipient(commsEmail, spec.planned.id)
             ? withInboxMission(spec, plane.commsInboxUrl, inboxRecipientFor(commsEmail, spec.planned.id)?.address)
             : spec;
@@ -472,6 +478,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 +488,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,15 +1,16 @@
 // 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";
 import { buildSubjectProvenance, hostOriginDigest } from "./provenance.js";
-import { CONCURRENT_SHARED_WORLD_LAB_SCHEMA, } from "./types.js";
+import {} from "./types.js";
+import { studyResultIdentity } from "../../run/study-result.js";
 /** The results of a run whose plane did not run (a dry run) or has not reported yet. */
 export function emptyPlaneResults() {
     return {
@@ -18,6 +19,7 @@ export function emptyPlaneResults() {
         subjectCommit: undefined,
         subjectSandboxId: undefined,
         subjectKilled: false,
+        subjectReleaseWarning: undefined,
         subjectDesktop: undefined,
         getHostUrl: undefined,
         publicOriginDigest: undefined,
@@ -64,7 +66,7 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
                 ? {}
                 : {
                     error: {
-                        code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+                        code: "HUMANISH_SHARED_WORLD_FAILED",
                         message: result.outcome.sessionError ??
                             (result.outcome.noEngagement
                                 ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
@@ -85,18 +87,18 @@ 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
-        // itself make the Observer unable to render a coherent run. Report the distinct, honest
+        // 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
         // handoff-timeout code rather than a generic observer/run failure.
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_HANDOFF_TIMEOUT",
+            code: "HUMANISH_SHARED_WORLD_HANDOFF_TIMEOUT",
             message: runError ??
                 "The host participant never produced a /lobby/CODE URL within the handoff deadline.",
         };
     }
     if (hostHandoffFailure !== undefined) {
-        return { code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED", message: hostHandoffFailure };
+        return { code: "HUMANISH_SHARED_WORLD_FAILED", message: hostHandoffFailure };
     }
     // The run's own failure before the Observer's: a run that stopped early (a desktop module that
     // failed to load, a plane that failed to start) leaves a bundle verify then refuses, and naming
@@ -104,34 +106,34 @@ function concurrentLabError(args) {
     // evidence).
     if (runError) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: observer.ok ? runError : `${runError} The run bundle it left failed verification.`,
         };
     }
     if (!observer.ok) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: observer.error?.message ?? "Observer failed for the concurrent shared-world run.",
         };
     }
     if (adapterFailure !== undefined) {
-        return { code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED", message: adapterFailure };
+        return { code: "HUMANISH_SHARED_WORLD_FAILED", message: adapterFailure };
     }
     const passed = participantResults.filter((result) => result.ok).length;
     if (passed === participantCount && args.shortfall !== undefined) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: `Concurrent shared-world run did not run coherently. ${args.shortfall}`,
         };
     }
     if (passed === participantCount && args.executionFailure !== undefined) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: `Concurrent shared-world run failed as an execution. ${args.executionFailure}`,
         };
     }
     return {
-        code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+        code: "HUMANISH_SHARED_WORLD_FAILED",
         message: `Concurrent shared-world run did not run coherently: ${passed}/${participantCount} actor(s) reached a terminal, engaged passed session.`,
     };
 }
@@ -141,10 +143,9 @@ function concurrentLabError(args) {
  */
 export function concurrentLabFailure(envelope) {
     return (code, message, actorLabel) => ({
-        schema: CONCURRENT_SHARED_WORLD_LAB_SCHEMA,
+        ...studyResultIdentity("shared-world", envelope.labId),
         ok: false,
         cwd: envelope.cwd,
-        labId: envelope.labId,
         actor: actorLabel ?? envelope.actor,
         topology: "shared-world",
         topologyMode: "concurrent",
@@ -158,11 +159,13 @@ 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.
+ * The run's execution failures: a run error (the handoff, the plane), each participant whose
+ * session 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
-    // must show the concurrency verify requires of a pass (judgeSharedWorld). This is a
+    // Concurrent "ok": every actor must produce a terminal, engaged, passed session, and the
+    // participants 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);
@@ -299,10 +311,9 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
         executionFailure: execution.failures[0]?.message,
     });
     const result = {
-        schema: CONCURRENT_SHARED_WORLD_LAB_SCHEMA,
+        ...studyResultIdentity("shared-world", plan.labId),
         ok,
         cwd,
-        labId: plan.labId,
         actor: descriptor.id,
         topology: "shared-world",
         topologyMode: "concurrent",