humanish 0.106.0 → 0.107.0

package/dist/routes/shared-world/{seats.js → participant-specs.js}

@@ -1,6 +1,7 @@
 // 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 { defaultSubjectPhaseSink } from "../../subject/steps.js";
+import { pricedModel } from "../../lab/plan-base.js";
 import { scrubPersonaBrief } from "../../lab/persona.js";
 import { resolveParticipant } from "../../run/participant.js";
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
@@ -11,11 +12,11 @@ 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 +
+// The default per-seat session budget is derived from the route. 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
+// 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;
@@ -74,9 +75,9 @@ function buildActorSpec(participant, personas) {
         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
+/** 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 {
@@ -111,58 +112,46 @@ export function startParticipantFlush(ctx, live, bundle) {
     live.flush = startLiveTraceFlush({
         bundle,
         participantRuns: ctx.actorSpecs,
-        model: ctx.config.actors[0]?.model ?? DEFAULT_OPENAI_CU_MODEL,
+        model: pricedModel(ctx.plan.brain),
         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.
+ * The runtime stream URLs each seat reports to the live Observer. The Observer learns of a stream
+ * before the caller's onStream 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)
+function participantStreams(onStream, live) {
+    return (event) => {
+        if (event.type === "ready")
+            live.streamUrls.push({ streamId: event.streamId, url: event.url });
+        // Mark, never remove (#357): the tile falls back to recorded evidence and says why.
+        else
+            for (const entry of live.streamUrls)
+                if (entry.streamId === event.streamId)
                     entry.ended = true;
-            }
-            if (live.observer) {
-                attachObserverRuntimeStreamUrls(live.observer, live.streamUrls);
-            }
-            return hooks.onRuntimeStreamEnded?.(stream);
-        },
+        if (live.observer)
+            attachObserverRuntimeStreamUrls(live.observer, live.streamUrls);
+        return onStream?.(event);
     };
 }
 /**
- * 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.
+ * The runner deps both planes give every participant. The `shared-app` subject keeps three things
+ * out of every actor sandbox: the subject env names' values, the GitHub token, and clone
+ * or local-tree provisioning. The committed subject.envValues still reach it, non-secret by parse.
+ * `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;
+    const { config, env, receiving, runBudget } = ctx;
     return {
         onTrace: (participantId, items, usage, metadata) => live.flush?.flush(participantId, items, usage, metadata),
-        config,
-        descriptor,
-        cloneRoute: false,
-        subjectEnvNames: [],
-        hasGithubToken: false,
+        residual: ctx.plan.residual,
+        labId: ctx.plan.labId,
+        caps: ctx.plan.caps,
+        subject: {
+            kind: "shared-app",
+            ...(config.subject.serve?.url === undefined ? {} : { serveUrl: config.subject.serve.url }),
+        },
         env,
         openaiApiKey: ctx.openaiApiKey,
         e2bApiKey: ctx.e2bApiKey,
@@ -176,15 +165,21 @@ export function participantRunDeps(ctx, live, scrubKnownValues) {
         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 } : {}),
+        brain: ctx.plan.brain,
         ...(receiving ? { receiving } : {}),
         now: ctx.now,
-        hooks: runtimeStreamHooks(ctx.hooks, live),
+        // The seat's desktop seams, and the caller's prepareDesktop with the seat as its target.
+        ...(ctx.deps.desktopModule === undefined ? {} : { desktopModule: ctx.deps.desktopModule }),
+        ...(ctx.deps.detachedTimers === undefined ? {} : { detachedTimers: ctx.deps.detachedTimers }),
+        ...(ctx.input.prepareDesktop === undefined ? {} : { prepareDesktop: ctx.input.prepareDesktop }),
+        onStream: participantStreams(ctx.input.onStream, live),
+        // A seat visits the shared app and provisions no subject, so it reports no phase of its own.
+        reportSubjectPhase: defaultSubjectPhaseSink,
         ...(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
+        // Concurrent participants are independent evidence seats: a requested-vs-verified screen
+        // mismatch is recorded as separate facts + a warning instead of failing the participant'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).
+        // live multi-actor world (the single-participant/fan-out routes keep fail-closed).
         screenMismatchPolicy: "record-evidence",
     };
 }

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,7 +349,10 @@ class SubjectPlane {
             this.subjectKilled = reading.released;
             if (reading.warning)
                 warnings.push(reading.warning);
-            // Without a kill method nothing ran, so there is no teardown time to record.
+            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")
                 this.subjectTornDownAtMs = this.ctx.now();
         }
@@ -384,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: [],
@@ -416,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;
@@ -426,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).
@@ -471,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,
@@ -480,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,