humanish 0.111.2 → 0.111.4

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

@@ -116,7 +116,7 @@ export async function drainExternalComms(ctx, comms) {
         email: comms.email,
         env: ctx.env,
         runPaths: ctx.runPaths,
-        knownSecretValues: ctx.knownSecretValues,
+        knownSecretValues: ctx.run.secrets.values(),
     });
     ctx.warnings.push(...warnings);
     return path;
@@ -136,7 +136,7 @@ export function receivingSourceOf(residual, env) {
  * when setup fails.
  */
 export async function prepareEmailReceiving(args) {
-    const { source, knownSecretValues } = args;
+    const { source, secrets } = args;
     if (args.dryRun || source.comms?.email?.kind !== "real")
         return { ok: true, receiving: undefined };
     try {
@@ -147,11 +147,7 @@ export async function prepareEmailReceiving(args) {
             env: args.env,
             participants: args.participants,
             runPaths: args.runPaths,
-            registerSecrets: (values) => {
-                for (const value of values)
-                    if (value.length >= 4 && !knownSecretValues.includes(value))
-                        knownSecretValues.push(value);
-            },
+            registerSecrets: (values) => secrets.add(values),
         });
         return { ok: true, receiving };
     }

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

@@ -1,9 +1,9 @@
 import type { DesktopParticipantRun, ParticipantRunOutcome } from "../computer-use/types.js";
-import { type ParticipantRunDeps } from "./participant-specs.js";
+import type { DesktopParticipantDeps } from "../computer-use/participant-deps.js";
 import type { ActorRunResult, ExternalCommsWiring } from "./types.js";
 /** What the host and follower participants need besides the handoff. */
 export interface HandoffParticipantDeps {
-    runDeps: ParticipantRunDeps;
+    runDeps: DesktopParticipantDeps;
     publicAppUrl: string;
     inbox: ExternalCommsWiring | undefined;
     now: () => number;

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

@@ -14,7 +14,7 @@ import { withInboxMission } from "../computer-use/participant-prompt.js";
 import { runCuaParticipant } from "../computer-use/participant-execution.js";
 import { extractLobbyCode, extractLobbyCodeFromNarration } from "./lobby-code.js";
 import { hostOriginDigest } from "./provenance.js";
-import { makeBlockedFollowerOutcome, withLobbyCodeMission, } from "./participant-specs.js";
+import { makeBlockedFollowerOutcome, withLobbyCodeMission } from "./participant-specs.js";
 // The floor for the host-first handoff barrier deadline (ms). The host must surface a
 // shared-session (/lobby/CODE) URL within the deadline or the run fails closed and no follower
 // opens. The effective deadline scales with the per-participant run budget (execution.timeoutMs): a

package/dist/routes/shared-world/participant-specs.d.ts

@@ -1,7 +1,8 @@
 import type { SharedWorldPlan } from "../../study/plan-types.js";
 import type { Participant, SharedWorldParticipant } from "../../study/plan-participants.js";
 import type { RunBundle } from "../../run/bundle.js";
-import type { CuaParticipantDeps, DesktopParticipantRun, ParticipantRunOutcome } from "../computer-use/types.js";
+import type { DesktopParticipantRun, ParticipantRunOutcome } from "../computer-use/types.js";
+import { type DesktopParticipantDeps } from "../computer-use/participant-deps.js";
 import type { LiveParticipants, PlaneContext } from "./types.js";
 export declare function defaultSessionTimeoutMs(plan: SharedWorldPlan): number;
 /** Resolve an actor's participant URL against the harness-minted getHost base (entry is a
@@ -16,8 +17,6 @@ export declare function withLobbyCodeMission(spec: DesktopParticipantRun, code:
 /** A follower blocked by an expired deadline or an ended host. It never opened a browser;
  * keep the actual reason rather than turning every upstream failure into a timeout. */
 export declare function makeBlockedFollowerOutcome(spec: DesktopParticipantRun, reason: string, timedOut: boolean): ParticipantRunOutcome;
-/** The computer-use runner deps every participant shares, on either plane. */
-export type ParticipantRunDeps = Omit<CuaParticipantDeps, "signalProvisioned" | "appUrl" | "onObservedUrl">;
 /**
  * A live run publishes an in-progress bundle before its participants start, whether or not an
  * Observer is attached, and the participants' live traces rewrite it as they go, as on the
@@ -30,9 +29,9 @@ export declare function startParticipantFlush(ctx: PlaneContext, live: LiveParti
  * 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.
+ * code. A plane calls this once per run, since the deps carry the run's one budget.
  */
-export declare function participantRunDeps(ctx: PlaneContext, live: LiveParticipants, scrubKnownValues: (text: string) => string): ParticipantRunDeps;
+export declare function participantRunDeps(ctx: PlaneContext, live: LiveParticipants, scrubKnownValues: (text: string) => string): DesktopParticipantDeps;
 /**
  * Each participant's actor spec, with committed personas compiled in so each prompt carries real
  * behavioral directives. Evidence copies of the assignment, instructions and persona are

package/dist/routes/shared-world/participant-specs.js

@@ -7,6 +7,7 @@ import { resolveParticipant } from "../../run/participant.js";
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
 import { composeParticipantInstructions } from "../computer-use/participant-prompt.js";
 import { startLiveTraceFlush } from "../computer-use/live-flush.js";
+import { desktopParticipantDeps, } from "../computer-use/participant-deps.js";
 import { resolveCommittedPersonasForCwd } from "../../study/persona-resolve.js";
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { redactText } from "../../evidence/redaction.js";
@@ -143,26 +144,25 @@ function participantStreams(onStream, live) {
  * 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.
+ * code. A plane calls this once per run, since the deps carry the run's one budget.
  */
 export function participantRunDeps(ctx, live, scrubKnownValues) {
-    const { config, env, receiving, runBudget } = ctx;
-    return {
-        onTrace: (participantId, items, usage, metadata) => live.flush?.flush(participantId, items, usage, metadata),
-        residual: ctx.plan.residual,
-        studyId: ctx.plan.studyId,
-        caps: ctx.plan.caps,
+    const { config, plan } = ctx;
+    return desktopParticipantDeps({
+        plan,
+        // A local-agent brain runs each participant on the operator's signed-in agent, as on
+        // computer use.
+        brain: plan.brain,
         subject: {
             kind: "shared-app",
             ...(config.subject.serve?.url === undefined ? {} : { serveUrl: config.subject.serve.url }),
         },
-        env,
+        env: ctx.env,
         openaiApiKey: ctx.openaiApiKey,
         e2bApiKey: ctx.e2bApiKey,
-        requestTimeoutMs: ctx.requestTimeoutMs,
-        sandboxMs: ctx.timeoutMs + SANDBOX_TIMEOUT_BUFFER_MS,
         timeoutMs: ctx.timeoutMs,
-        participantCount: ctx.plan.plane.participants.length,
+        sandboxMs: ctx.timeoutMs + SANDBOX_TIMEOUT_BUFFER_MS,
+        participantCount: plan.plane.participants.length,
         artifactRoot: ctx.runPaths,
         studyCwd: ctx.cwd,
         redactScreenshots: ctx.redactScreenshots,
@@ -172,27 +172,21 @@ export function participantRunDeps(ctx, live, scrubKnownValues) {
             ctx.run.participantStarted();
             return ctx.runSession(options);
         },
-        // A local-agent brain runs each participant on the operator's signed-in agent, as on computer
-        // use.
-        brain: ctx.plan.brain,
-        ...(receiving ? { receiving } : {}),
-        now: ctx.now,
-        // The participant's desktop seams, and the caller's prepareDesktop with the participant 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 }),
+        liveFlush: () => live.flush?.flush,
         onStream: participantStreams(ctx.input.onStream, live),
-        // A participant visits the shared app and provisions no subject, so it reports no phase of its
-        // own.
+        // A participant visits the shared app and provisions no subject, so it reports no phase of
+        // its own.
         reportSubjectPhase: defaultSubjectPhaseSink,
-        ...(runBudget === undefined ? {} : { runBudget }),
+        seams: ctx.deps,
+        prepareDesktop: ctx.input.prepareDesktop,
+    }, {
+        receiving: ctx.receiving,
         // Concurrent participants are independent evidence: a requested-vs-verified screen
         // mismatch is recorded as separate facts + a warning instead of failing the participant's
         // device claim closed, so one participant's window-manager drift cannot abort the whole
         // live multi-actor world (the single-participant/fan-out routes keep fail-closed).
         screenMismatchPolicy: "record-evidence",
-    };
+    });
 }
 /**
  * Each participant's actor spec, with committed personas compiled in so each prompt carries real

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

@@ -11,7 +11,7 @@ import { sharedWorldParticipants } from "../../study/plan-participants.js";
 import { PUBLIC_TARGET_OWNER_PATTERN } from "../../study/parse/subject.js";
 import { REPO_SLUG_PATTERN } from "../../study/parse/values.js";
 import { concurrentSharedWorldValidationReason, desktopMediaValidationReason, externalPublicSharedWorldValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, taskProtocolValidationReason, } from "../../study/validation.js";
-import { MODEL_RATES, unpricedCapMessage } from "../../run/pricing.js";
+import { unpricedCapCheck } from "../../study/requirements.js";
 /** The registered descriptor for a planned actor; planSharedWorldStudy checked the registry. */
 export function sharedWorldDescriptorOf(actorType) {
     const descriptor = actorRegistry[actorType];
@@ -60,12 +60,16 @@ export function planSharedWorldStudy(config, input) {
         return refuse(invalid, invalidReason, actor);
     if (config.actor?.maxOutputTokens !== undefined && input.hasRunSession === true)
         return refuse(invalid, "maxOutputTokens cannot be enforced by a custom runSession.", actor);
-    const caps = config.caps;
-    if (!input.dryRun && (caps?.maxUsd !== undefined || caps?.maxTotalUsd !== undefined)) {
-        const model = (config.actor?.model ?? DEFAULT_OPENAI_CU_MODEL).trim().toLowerCase();
-        if (!MODEL_RATES[model])
-            return refuse("HUMANISH_SHARED_WORLD_UNPRICED_CAP", unpricedCapMessage(model), actor);
-    }
+    // A live cap is priced here, at plan time, so its refusal wins over the route's key checks.
+    const unpriced = input.dryRun
+        ? undefined
+        : unpricedCapCheck({
+            caps: config.caps ?? {},
+            model: (config.actor?.model ?? DEFAULT_OPENAI_CU_MODEL).trim().toLowerCase(),
+            code: "HUMANISH_SHARED_WORLD_UNPRICED_CAP",
+        });
+    if (unpriced)
+        return refuse(unpriced.code, unpriced.message, actor);
     const receivingReason = receivingEmailValidationReason(config);
     if (receivingReason)
         return refuse(invalid, receivingReason, actor);

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

@@ -3,8 +3,9 @@ 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 SubjectDesktopUsage } from "../../substrates/e2b/subject-sandbox.js";
 import type { StudyDeps } from "../../study/study-deps.js";
-import { type ActorRunResult, type SubjectDesktopUsage, type LiveParticipants, type PlaneContext } from "./types.js";
+import { type ActorRunResult, type LiveParticipants, type PlaneContext } from "./types.js";
 /** What the provisioned plane needs besides the shared plane context. */
 export interface ProvisionedPlaneSetup {
     serve: StudySubjectServe;

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

@@ -12,9 +12,9 @@ import { provisionLocalTreeSubject } from "../../subject/local-tree.js";
 import { defaultSharedWorldPhaseSink } from "../../subject/steps.js";
 import { phaseEvent } from "../../study/run-study-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";
+import { E2BSubjectSandbox, } from "../../substrates/e2b/subject-sandbox.js";
 import { e2bShell } from "../../substrates/e2b/shell.js";
+import { validatePreparedRunArtifactPaths } from "../../run/paths.js";
 import { defaultPackLocalTree } from "../computer-use/local-tree-pack.js";
 import { inboxRecipientFor, participantHasInboxRecipient, } from "../computer-use/participant-desktop.js";
 import { resolveSubjectState } from "../computer-use/subject-projection.js";
@@ -25,8 +25,6 @@ import { buildConcurrentSharedWorldBundle, judgeSharedWorldRun } from "./bundle.
 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 "./participant-specs.js";
 import { CONCURRENT_SHARED_WORLD_PROVIDER_METADATA, } from "./types.js";
 import { addressedRecipients } from "../../study/parse/comms.js";
@@ -46,17 +44,10 @@ class ObserverGateError extends Error {
 class SubjectPlane {
     commsInboxUrl;
     subjectCommit;
-    subjectSandboxId;
-    subjectKilled = false;
-    subjectReleaseWarning;
+    subject;
     getHostUrl;
-    // The subject desktop's host-side span and size, priced in the run's cost estimate.
-    subjectCreatedAtMs;
-    subjectTornDownAtMs;
-    subjectResources;
     ctx;
     setup;
-    subjectAllocation;
     subjectDesktop;
     subjectShell;
     // The in-sandbox email catch on the one subject sandbox; drained at teardown. Undefined
@@ -77,6 +68,11 @@ class SubjectPlane {
     constructor(ctx, setup) {
         this.ctx = ctx;
         this.setup = setup;
+        this.subject = new E2BSubjectSandbox({
+            warnings: ctx.warnings,
+            scrub: ctx.scrubKnownValues,
+            now: ctx.now,
+        });
         this.disposeSignal = new Promise((resolve) => {
             this.releaseDispose = resolve;
         });
@@ -106,46 +102,35 @@ class SubjectPlane {
         // 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({
+        // reads the same config); absent keeps the byte-stable Sandbox.create(opts) default.
+        this.subjectDesktop = await this.subject.acquire({
             module: subjectModule,
-            options: {
-                apiKey: this.ctx.e2bApiKey,
-                requestTimeoutMs,
-                timeoutMs: timeoutMs +
-                    SUBJECT_PROVISION_BUDGET_MS +
-                    (planeStateOf(plan)?.seed ?? []).reduce((sum, step) => sum + (step.timeoutMs ?? DEFAULT_STATE_STEP_TIMEOUT_MS), 0) +
-                    SANDBOX_TIMEOUT_BUFFER_MS,
-                metadata: {
-                    ...CONCURRENT_SHARED_WORLD_PROVIDER_METADATA,
-                    labId: plan.studyId,
-                    topology: "shared-world",
-                    topologyMode: "concurrent",
-                    kind: "subject",
-                    participantCount: String(plan.plane.participants.length),
-                },
-                ...(subjectEnvNames.length > 0 || Object.keys(commsEnv).length > 0
-                    ? {
-                        envs: {
-                            ...Object.fromEntries(subjectEnvNames.map((name) => [name, env[name]])),
-                            ...commsEnv,
-                        },
-                    }
-                    : {}),
-                dpi: 96,
-                lifecycle: { onTimeout: "kill" },
+            apiKey: this.ctx.e2bApiKey,
+            requestTimeoutMs,
+            sessionTimeoutMs: timeoutMs,
+            seed: planeStateOf(plan)?.seed ?? [],
+            metadata: {
+                ...CONCURRENT_SHARED_WORLD_PROVIDER_METADATA,
+                labId: plan.studyId,
+                topology: "shared-world",
+                topologyMode: "concurrent",
+                kind: "subject",
+                participantCount: String(plan.plane.participants.length),
+            },
+            envs: {
+                ...Object.fromEntries(subjectEnvNames.map((name) => [name, env[name]])),
+                ...commsEnv,
             },
             template: plan.residual.execution?.desktop?.template,
-            receipt: { root: this.ctx.runPaths, participantId: "subject" },
+            root: this.ctx.runPaths,
         });
-        this.subjectDesktop = subject.sandbox;
         this.subjectShell = e2bShell(this.subjectDesktop);
-        this.subjectAllocation = subject.allocation;
-        this.subjectSandboxId = subject.allocation.resourceId;
-        this.subjectCreatedAtMs = this.ctx.now();
-        this.subjectResources = await observeDesktopResources(this.subjectDesktop);
-        await this.ctx.input.prepareDesktop?.(this.subjectDesktop, { kind: "subject" });
+        if (this.ctx.input.prepareDesktop) {
+            await this.ctx.input.prepareDesktop(this.subjectDesktop, { kind: "subject" });
+            // The caller's hook runs with this process's file access, so the run directory is checked
+            // again before more evidence goes into it.
+            await validatePreparedRunArtifactPaths(this.ctx.runPaths);
+        }
     }
     // 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
@@ -320,7 +305,6 @@ class SubjectPlane {
      * Returns the comms thread's path when the drain wrote one.
      */
     async teardown() {
-        const { warnings, scrubKnownValues } = this.ctx;
         this.proberDisposed = true;
         this.releaseDispose();
         if (this.proberLoop) {
@@ -339,36 +323,9 @@ class SubjectPlane {
         if (commsEmail && this.deployedComms?.ready && this.subjectShell) {
             commsArtifactPath = await drainSubjectComms(this.ctx, commsEmail, this.subjectShell, this.deployedComms);
         }
-        if (this.subjectAllocation !== undefined) {
-            const released = await this.subjectAllocation.close();
-            const reading = readE2BRelease(released, {
-                label: "Subject sandbox",
-                scrub: scrubKnownValues,
-                costSpan: true,
-            });
-            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")
-                this.subjectTornDownAtMs = this.ctx.now();
-        }
+        await this.subject.release();
         return commsArtifactPath;
     }
-    desktopUsage() {
-        if (this.subjectSandboxId === undefined)
-            return undefined;
-        return {
-            durationMs: this.subjectCreatedAtMs === undefined || this.subjectTornDownAtMs === undefined
-                ? undefined
-                : Math.max(0, this.subjectTornDownAtMs - this.subjectCreatedAtMs),
-            observation: this.subjectResources,
-            killed: this.subjectKilled,
-        };
-    }
 }
 /** Writes the in-progress bundle, runs the caller's Observer gate and starts the participants'
  *  flush. */
@@ -476,10 +433,10 @@ export async function runProvisionedPlane(ctx, live, setup) {
         actorResults,
         runError,
         subjectCommit: plane.subjectCommit,
-        subjectSandboxId: plane.subjectSandboxId,
-        subjectKilled: plane.subjectKilled,
-        subjectReleaseWarning: plane.subjectReleaseWarning,
-        subjectDesktop: plane.desktopUsage(),
+        subjectSandboxId: plane.subject.sandboxId,
+        subjectKilled: plane.subject.killed,
+        subjectReleaseWarning: plane.subject.releaseWarning,
+        subjectDesktop: plane.subject.desktopUsage(),
         getHostUrl: plane.getHostUrl,
         commsArtifactPath,
     };

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

@@ -3,14 +3,16 @@
 import { redactText } from "../../evidence/redaction.js";
 import { adapterScoreFailureMessage, applyBrowserScorer } from "../../study/adapter-extension.js";
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
-import { foldScorerFailures, judgeExecution, sandboxCleanupFailure, OUTCOME_POLICIES, participantHarnessFailed, resultOk, sharedWorldShortfall, } from "../../run/judge.js";
-import { participantFactsOf, unreleasedSandboxFailures, } from "../computer-use/participant-facts.js";
+import { foldScorerFailures, judgeExecution, sandboxCleanupFailure, OUTCOME_POLICIES, resultOk, sharedWorldShortfall, } from "../../run/judge.js";
+import { validatePreparedRunArtifactPaths } from "../../run/paths.js";
+import { participantExecutionFailures } from "../computer-use/participant-facts.js";
+import { participantCapWarning } from "../computer-use/participant-model.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 {} from "./types.js";
-import { studyResultIdentity } from "../../run/study-result.js";
+import { refusedResult, studyResultIdentity } from "../../run/study-result.js";
 import { plural } from "../../run/text.js";
 /** The results of a run whose plane did not run (a dry run) or has not reported yet. */
 export function emptyPlaneResults() {
@@ -143,10 +145,7 @@ function concurrentStudyError(args) {
  * and the run id the caller asked for, if any. `actor` is the label when a refusal names none.
  */
 export function concurrentStudyFailure(envelope) {
-    return (code, message, actorLabel) => ({
-        ...studyResultIdentity("shared-world", envelope.studyId),
-        ok: false,
-        cwd: envelope.cwd,
+    return (code, message, actorLabel) => refusedResult("shared-world", { studyId: envelope.studyId, cwd: envelope.cwd, error: { code, message } }, {
         actor: actorLabel ?? envelope.actor,
         topology: "shared-world",
         topologyMode: "concurrent",
@@ -155,43 +154,18 @@ export function concurrentStudyFailure(envelope) {
         dryRun: envelope.dryRun,
         runId: envelope.runId ?? "not-created",
         roles: [],
-        warnings: [],
-        error: { code, message },
     });
 }
 /**
- * The run's execution failures before the Observer renders: 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, and each sandbox whose release is
+ * The run's execution failures before the Observer renders: a run error (the handoff, the plane)
+ * first, then the participants' failures, then the subject sandbox when its release is
  * unconfirmed. FinishedRun.renderObserver adds an Observer that did not render.
  */
 function sharedWorldExecutionFailures(args) {
     const { runId, runError, actorResults, subject } = args;
     return [
         ...(runError === undefined ? [] : [{ kind: "run", message: runError }]),
-        ...actorResults
-            .filter((result) => participantHarnessFailed(participantFactsOf(result.outcome)))
-            .map((result) => ({
-            kind: "harness",
-            message: `${result.spec.planned.id}: ${result.outcome.sessionError ?? result.outcome.session?.reason ?? "harness error"}`,
-        })),
-        ...actorResults.flatMap((result) => result.outcome.providerCleanupError === undefined
-            ? []
-            : [
-                {
-                    kind: "provider-cleanup",
-                    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),
+        ...participantExecutionFailures(actorResults.map((result) => result.outcome), runId),
         ...(subject.subjectSandboxId === undefined || subject.subjectKilled
             ? []
             : [sandboxCleanupFailure("subject", subject.subjectReleaseWarning, runId)]),
@@ -230,6 +204,9 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
     for (const result of actorResults) {
         warnings.push(...result.outcome.warnings);
     }
+    const capWarning = participantCapWarning(plan.caps, participantCount, "each participant's model spend");
+    if (capWarning !== undefined)
+        warnings.push(capWarning);
     const bundleArgs = {
         run,
         plan,
@@ -293,6 +270,11 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
         policy,
     });
     const observer = await finished.renderObserver();
+    // A caller's renderer runs with this process's file access, so after one that reports success
+    // the run directory is checked again before the result points anyone at it. A failed render is
+    // already an evidence failure, and its error code stays the run's diagnosis.
+    if (observer.ok)
+        await validatePreparedRunArtifactPaths(finished.paths);
     if (observer.ok && live.observer) {
         attachObserverRuntimeStreamUrls(observer, live.streamUrls);
     }

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

@@ -33,15 +33,12 @@
 // requires the author attestation subject.exposure: synthetic. This is author-trust + a provenance
 // gate; humanish cannot tell synthetic from real data, so it makes no claim about real data.
 import path from "node:path";
-import { missingKeys, missingSubjectEnv } from "../../study/requirements.js";
-import { scrubLiterals } from "../../evidence/redaction.js";
-import { describeMissingKeys } from "../../keys/key-resolution.js";
+import { firstLiveRefusal, keysCheck, localAgentCheck, subjectEnvCheck, } from "../../study/requirements.js";
 import {} from "../../run/run.js";
+import { RunSecrets } from "../../run/secrets.js";
 import { admitRoute, completeRefusalAnalysis, } from "../../run/route-shell.js";
-import { makeCuaRunBudget } from "../computer-use/participant-model.js";
 import { runExternalPublicPlane } from "./external-public.js";
 import { sharedWorldDescriptorOf } from "./plan.js";
-import { localAgentRefusal } from "../../actors/local-agent/readiness.js";
 import { runProvisionedPlane } from "./provisioned.js";
 import { concurrentStudyFailure, finishConcurrentRun } from "./result.js";
 import { prepareConcurrentRun } from "./setup.js";
@@ -99,29 +96,35 @@ async function admitSharedWorldRun(plan, input) {
     if (plan.dryRun)
         return admitted;
     const env = input.env ?? process.env;
-    const fail = (code, message) => ({
+    const { requirements } = plan;
+    // The plan prices a cap before these, and its refusal wins over theirs.
+    const refusal = await firstLiveRefusal([
+        // The plan lists OPENAI_API_KEY for an openai brain's participants and the external-public
+        // plane's lobby-code reader; a local-agent brain's participants run on the operator's
+        // signed-in agent instead. Only on the provisioned plane does a local agent remove the key,
+        // so only there does the refusal suggest one.
+        () => keysCheck({
+            requirements,
+            env,
+            code: "HUMANISH_SHARED_WORLD_KEYS_MISSING",
+            need: (names) => `Live concurrent shared-world studies need ${names} in the environment (values are never persisted).`,
+            suggestLocalAgent: plan.plane.kind === "provisioned",
+        }),
+        () => localAgentCheck({
+            brain: plan.brain,
+            env,
+            caps: plan.caps,
+            codes: LOCAL_AGENT_REFUSAL_CODES,
+        }),
+        () => subjectEnvCheck({ requirements, env, code: "HUMANISH_SHARED_WORLD_SUBJECT_ENV_MISSING" }),
+    ]);
+    if (refusal === undefined)
+        return admitted;
+    const fail = sharedWorldFailure(plan, input);
+    return {
         ok: false,
-        result: sharedWorldFailure(plan, input)(code, message, sharedWorldDescriptorOf(plan.actor).id),
-    });
-    // The plan lists OPENAI_API_KEY for an openai brain's participants and the external-public
-    // plane's lobby-code reader; a local-agent brain's participants run on the operator's signed-in
-    // agent instead.
-    const missing = missingKeys(plan.requirements, env);
-    if (missing.length > 0) {
-        return fail("HUMANISH_SHARED_WORLD_KEYS_MISSING", `Live concurrent shared-world studies need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}`);
-    }
-    if (plan.brain.kind === "local-agent") {
-        // A missing or signed-out agent found after the participants' desktops are paid for is the same
-        // news at the worst moment.
-        const refusal = await localAgentRefusal({ agent: plan.brain.agent, env, caps: plan.caps });
-        if (refusal)
-            return fail(LOCAL_AGENT_REFUSAL_CODES[refusal.kind], refusal.message);
-    }
-    const unsetSubjectEnv = missingSubjectEnv(plan.requirements, env);
-    if (unsetSubjectEnv.length > 0) {
-        return fail("HUMANISH_SHARED_WORLD_SUBJECT_ENV_MISSING", `subject.env declares ${unsetSubjectEnv.join(", ")} but the environment does not provide ${unsetSubjectEnv.length === 1 ? "it" : "them"} (pass via --dotenv; values are never persisted).`);
-    }
-    return admitted;
+        result: fail(refusal.code, refusal.message, sharedWorldDescriptorOf(plan.actor).id),
+    };
 }
 /** The route's envelope for a run that stops before its bundle. */
 function sharedWorldFailure(plan, input) {
@@ -136,15 +139,12 @@ function sharedWorldFailure(plan, input) {
     });
 }
 async function runPlanInScope(plan, input, config, scope) {
-    const { dryRun } = plan;
     const requestedCwd = path.resolve(input.cwd);
     const deps = input.deps ?? {};
     const env = input.env ?? process.env;
     const fail = sharedWorldFailure(plan, input);
     const descriptor = sharedWorldDescriptorOf(plan.actor);
     const planeClass = plan.plane.kind === "external-public" ? "external-public" : "provisioned-getHost";
-    const { maxTotalUsd } = plan.caps;
-    const runBudget = !dryRun && maxTotalUsd !== undefined ? makeCuaRunBudget(maxTotalUsd) : undefined;
     // The provisioned plane's subject; the external-public plane has none.
     const subject = plan.plane.kind === "provisioned" ? plan.plane.subject : undefined;
     const serve = subject?.serve;
@@ -155,13 +155,12 @@ async function runPlanInScope(plan, input, config, scope) {
     const runSession = deps.runSession ?? descriptor.runSession;
     const openaiApiKey = env.OPENAI_API_KEY?.trim() ?? "";
     const e2bApiKey = env.E2B_API_KEY?.trim() ?? "";
-    const knownSecretValues = [
+    const secrets = new RunSecrets([
         openaiApiKey,
         e2bApiKey,
         ...subjectEnvNames.map((name) => env[name] ?? ""),
         ...checkpoints.flatMap((probe) => probe.redact ?? []),
-    ].filter((value) => value.length >= 4);
-    const scrubKnownValues = scrubLiterals(knownSecretValues);
+    ]);
     const redactRepoLabel = plan.residual.policies?.redactRepos ?? subjectEnvNames.includes("GITHUB_TOKEN");
     const publicRepo = redactRepoLabel ? "repo-01" : subjectRepo;
     const hasGithubToken = subjectEnvNames.includes("GITHUB_TOKEN");
@@ -174,7 +173,6 @@ async function runPlanInScope(plan, input, config, scope) {
         env,
         descriptor,
         planeClass,
-        runBudget,
         runSession,
         serve,
         localTreeRoute,
@@ -183,8 +181,7 @@ async function runPlanInScope(plan, input, config, scope) {
         checkpoints,
         openaiApiKey,
         e2bApiKey,
-        knownSecretValues,
-        scrubKnownValues,
+        secrets,
         publicRepo,
         hasGithubToken,
         fail,