humanish 0.106.1 → 0.108.0

package/dist/routes/computer-use/preflight.js

@@ -1,16 +1,17 @@
 import { pricedModel } from "../../lab/plan-base.js";
+import { missingKeys, missingSubjectEnv } from "../../lab/requirements.js";
 import { detectLocalAgents } from "../../actors/local-agent/cli.js";
 import { localAgentRefusal } from "../../actors/local-agent/readiness.js";
 import { describeMissingKeys } from "../../keys/key-resolution.js";
+import { catchTokenOf, catchTokenRefusal } from "../../comms/external-evidence.js";
 import { externalCatchHealthy } from "../../comms/sandbox-catch.js";
-import { MODEL_RATES } from "../../run/pricing.js";
-import { participantDesktopOf } from "./participant-desktop.js";
+import { MODEL_RATES, unpricedCapMessage } from "../../run/pricing.js";
 /** The computer-use code for each local-agent refusal; shared-world keeps the same kinds. */
 const LOCAL_AGENT_REFUSAL_CODES = {
-    "agent-missing": "HUMANISH_CUA_LAB_AGENT_MISSING",
-    "signin-required": "HUMANISH_CUA_LAB_AGENT_SIGNIN_REQUIRED",
-    unsupported: "HUMANISH_CUA_LAB_ACTOR_UNSUPPORTED",
-    "unpriced-cap": "HUMANISH_CUA_LAB_UNPRICED_CAP",
+    "agent-missing": "HUMANISH_COMPUTER_USE_AGENT_MISSING",
+    "signin-required": "HUMANISH_COMPUTER_USE_AGENT_SIGNIN_REQUIRED",
+    unsupported: "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED",
+    "unpriced-cap": "HUMANISH_COMPUTER_USE_UNPRICED_CAP",
 };
 /**
  * The first reason a live computer-use run cannot start on this machine: missing keys, a missing
@@ -19,69 +20,72 @@ const LOCAL_AGENT_REFUSAL_CODES = {
  * already paid for a desktop.
  */
 export async function liveCuaRejection(args) {
-    const { caps, brain, hooks, env, openaiApiKey, e2bApiKey, subjectEnvNames, externalCommsConfig } = args;
-    // The operator's own signed-in coding agent is the brain, so there is no provider key to ask
-    // for. E2B is still required: the persona needs a machine.
+    const { caps, brain, env, requirements, externalCommsConfig } = args;
+    // The plan lists OPENAI_API_KEY only for an openai brain (a signed-in local agent or the
+    // caller's provider needs none) and E2B_API_KEY only when this run creates hosted desktops.
     const localAgent = brain.kind === "local-agent" ? brain.agent : undefined;
-    const missingKeys = [
-        ...(openaiApiKey || localAgent || hooks.buildProvider ? [] : ["OPENAI_API_KEY"]),
-        ...(e2bApiKey || participantDesktopOf(hooks) !== undefined ? [] : ["E2B_API_KEY"]),
-    ];
-    if (missingKeys.length > 0) {
+    const missing = missingKeys(requirements, env);
+    if (missing.length > 0) {
         // The moment someone new actually hits the wall. If a signed-in coding agent is sitting
-        // right there, say so HERE rather than making them go and find an API key — that detour is
+        // right there, say so here rather than making them go and find an API key; that detour is
         // where most people trying humanish stop.
-        const suggestion = missingKeys.includes("OPENAI_API_KEY")
+        const suggestion = missing.includes("OPENAI_API_KEY")
             ? await (async () => {
                 const ready = (await detectLocalAgents({ env })).filter((agent) => agent.authStatus === "authenticated");
                 return ready.length === 0
                     ? ""
                     : ` ${ready.map((agent) => agent.label).join(" and ")} reports authenticated on this machine` +
-                        ` — set actors[0].type: local-agent to use ${ready.length === 1 ? "it" : "one"} instead of a key.`;
+                        `. Set actors[0].type: local-agent to use ${ready.length === 1 ? "it" : "one"} instead of a key.`;
             })()
             : "";
         return {
-            code: "HUMANISH_CUA_LAB_KEYS_MISSING",
-            message: `Live computer-use labs need ${missingKeys.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missingKeys, env)}${suggestion}`,
+            code: "HUMANISH_COMPUTER_USE_KEYS_MISSING",
+            message: `Live computer-use labs need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}${suggestion}`,
         };
     }
-    if (localAgent && !hooks.buildProvider) {
-        // Refuse HERE, before a sandbox exists. "codex is not installed" discovered after the
+    // A caller's createProvider makes the brain `caller`, so only the lab's own local agent is checked.
+    if (localAgent) {
+        // Refuse here, before a sandbox exists. "codex is not installed" discovered after the
         // machine is paid for is the same information delivered at the worst possible moment.
         const refusal = await localAgentRefusal({ agent: localAgent, env, caps });
         if (refusal)
             return { code: LOCAL_AGENT_REFUSAL_CODES[refusal.kind], message: refusal.message };
     }
-    const missingSubjectEnv = subjectEnvNames.filter((name) => !env[name]?.trim());
-    if (missingSubjectEnv.length > 0) {
+    const unsetSubjectEnv = missingSubjectEnv(requirements, env);
+    if (unsetSubjectEnv.length > 0) {
         return {
-            code: "HUMANISH_CUA_LAB_SUBJECT_ENV_MISSING",
-            message: `subject.env declares ${missingSubjectEnv.join(", ")} but the environment does not provide ${missingSubjectEnv.length === 1 ? "it" : "them"} (pass via --env-file; values are never persisted).`,
+            code: "HUMANISH_COMPUTER_USE_SUBJECT_ENV_MISSING",
+            message: `subject.env declares ${unsetSubjectEnv.join(", ")} but the environment does not provide ${unsetSubjectEnv.length === 1 ? "it" : "them"} (pass via --env-file; values are never persisted).`,
         };
     }
-    // FAIL-CLOSED CAP TENSION (discipline #3): a maxUsd cap needs a MEASURABLE per-turn estimate.
+    // Fail-closed cap: a maxUsd cap needs a measurable per-turn estimate.
     // If the operator set execution.caps.maxUsd but src/run/pricing.ts has no rate for the resolved
-    // model, the loop could not enforce the cap — and silently running uncapped would break the
-    // runaway-retry protection. Refuse at PREFLIGHT (before any sandbox/spend) rather than run
-    // uncapped: an unenforceable cap is more dangerous than none. The operator adds a rate to
-    // src/run/pricing.ts (the honest place) or removes the cap.
+    // model, the loop could not enforce the cap, and silently running uncapped would break the
+    // runaway-retry protection. Refuse at preflight (before any sandbox/spend) rather than run
+    // uncapped: an unenforceable cap is more dangerous than none. The operator picks a priced model
+    // or removes the cap; a source checkout can also add a rate to src/run/pricing.ts.
     if (caps.maxUsd !== undefined || caps.maxTotalUsd !== undefined) {
         const model = pricedModel(brain);
         const capModelId = model.trim().toLowerCase();
         if (!MODEL_RATES[capModelId]) {
             return {
-                code: "HUMANISH_CUA_LAB_UNPRICED_CAP",
-                message: `execution.caps declares a spend cap (maxUsd/maxTotalUsd) but src/run/pricing.ts has no rate for model "${model}"; add a rate or remove the cap — an unenforceable cap is refused rather than run uncapped.`,
+                code: "HUMANISH_COMPUTER_USE_UNPRICED_CAP",
+                message: unpricedCapMessage(model),
             };
         }
     }
-    // Adopter-hosted comms catch (#380): fail closed BEFORE any sandbox is created — a comms lab
-    // whose catch is unreachable collects nothing while every lane still spends. The probe asserts
-    // OUR service marker in /health, so an adopter's proxy answering 200 for everything cannot
+    // Adopter-hosted comms catch: fail closed before any sandbox is created, because a comms lab
+    // whose catch is unreachable collects nothing while every participant still spends. The probe asserts
+    // humanish's own service marker in /health, so an adopter's proxy answering 200 for everything cannot
     // pass for a catch.
+    const tokenRefusal = externalCommsConfig === undefined
+        ? undefined
+        : catchTokenRefusal(catchTokenOf(externalCommsConfig, env));
+    if (tokenRefusal !== undefined)
+        return { code: "HUMANISH_COMPUTER_USE_COMMS_TOKEN_INVALID", message: tokenRefusal };
     if (externalCommsConfig && !(await externalCatchHealthy(externalCommsConfig))) {
         return {
-            code: "HUMANISH_CUA_LAB_COMMS_CATCH_UNREACHABLE",
+            code: "HUMANISH_COMPUTER_USE_COMMS_CATCH_UNREACHABLE",
             message: "The external comms catch or inbox is unreachable or incompatible (GET /health must identify humanish-comms-catch and advertise recipient-inbox-v1). Update humanish on the catch host and restart it with `humanish comms catch` on that host, or drop comms.email to run without the inbox funnel.",
         };
     }

package/dist/routes/computer-use/rerun-selection.js

@@ -36,7 +36,7 @@ export async function resolveCuaRerunSelection(args) {
     if (selectedIds.length === 0) {
         return {
             ok: false,
-            message: `source run ${bundle.runId} has no failed, blocked, timed-out, or hollow participants to rerun.`,
+            message: `source run ${bundle.runId} has no participant to rerun: none failed, was blocked, timed out or ended without engaging.`,
         };
     }
     const missingPrior = selectedIds.filter((id) => !priorById.has(id));
@@ -99,13 +99,17 @@ function snapshotPriorParticipant(stream) {
     const reason = stream.ui?.state ?? stream.actor?.reason;
     const actions = stream.actor?.counts.actions ?? 0;
     const messages = stream.actor?.counts.messages ?? 0;
+    // The judge's status decides, so a participant the review counts as blocked is rerunnable. A
+    // bundle written before streams carried it falls back to the trace status and counts.
     const hollow = completionReason === "goal_satisfied" && actions === 0 && messages === 0;
-    const rerunnable = stream.status !== "passed" ||
-        actorStatus === "failed" ||
-        actorStatus === "blocked" ||
-        actorStatus === "timed_out" ||
-        completionReason === "harness_error" ||
-        hollow;
+    const rerunnable = stream.judgedStatus !== undefined
+        ? stream.judgedStatus !== "passed"
+        : stream.status !== "passed" ||
+            actorStatus === "failed" ||
+            actorStatus === "blocked" ||
+            actorStatus === "timed_out" ||
+            completionReason === "harness_error" ||
+            hollow;
     return {
         participantId: stream.laneId,
         previous: {

package/dist/routes/computer-use/result.d.ts

@@ -1,4 +1,4 @@
-import type { runLabParticipants } from "./run-lanes.js";
+import type { runLabParticipants } from "./live-phase.js";
 import type { CuaFinishFacts, CuaRunSetup } from "./setup.js";
 import { type CuaActorLabResult } from "./types.js";
 /** Builds and publishes the final bundle, runs the adapter hooks, renders the Observer and returns the result. */

package/dist/routes/computer-use/result.js

@@ -1,13 +1,15 @@
-import { adapterScoreFailureMessage, applyBrowserAdapterHooks, } from "../../lab/adapter-extension.js";
+import { adapterScoreFailureMessage, applyBrowserScorer } from "../../lab/adapter-extension.js";
 import { redactText } from "../../evidence/redaction.js";
 import { round6 } from "../../run/pricing.js";
 import { foldScorerFailures, judgeExecution, OUTCOME_POLICIES, participantHarnessFailed, resultOk, } from "../../run/judge.js";
-import { participantFactsOf, participantOutcomeOk } from "./participant-facts.js";
+import { participantFactsOf, participantOutcomeOk, unreleasedSandboxFailures, } from "./participant-facts.js";
 import { summarizeCuaDiagnostics } from "./diagnostics.js";
-import { toParticipantResult } from "./lanes.js";
+import { toParticipantResult } from "./participant-execution.js";
 import { buildCuaRunBundle, judgeComputerUseRun } from "./bundle.js";
 import { aggregateCuaSubject, projectParticipantSubjects, subjectProvenanceArg, } from "./subject-projection.js";
-import { CUA_ACTOR_LAB_SCHEMA, CUA_FANOUT_STRATEGY, } from "./types.js";
+import { CUA_FANOUT_STRATEGY, participantSubjectEnv, } from "./types.js";
+import { plannedAppUrl } from "./plan.js";
+import { studyResultIdentity } from "../../run/study-result.js";
 /** Aggregate participant counts for the result projection. */
 function buildParticipantSummary(outcomes, participantCount, participantPlan, dryRun) {
     if (dryRun || !outcomes) {
@@ -51,13 +53,14 @@ function buildParticipantSummary(outcomes, participantCount, participantPlan, dr
 }
 /**
  * The computer-use lab result for a finished run. The run passes only when the Observer rendered,
- * every lane passed (dry-run lanes pass as contracts), and no adapter score or declared scorer
+ * every participant passed (dry-run participants pass as contracts), and no adapter score or declared scorer
  * verdict failed; otherwise the error names the first reason.
  */
 function cuaLabResult(args) {
     const { labId, cwd, runId, appUrl, dryRun, participantRuns, outcomes, subjects, aggregateSubject, participantPlan, rerunLineage, bundle, observer, receivingWarnings, aggregateWarnings, adapterWarnings, } = args;
     const participantCount = participantRuns.length;
-    // Lane-level pass: dry-run lanes are contract-ok; live lanes need a passed, engaged session.
+    // Participant-level pass: dry-run participants are contract-ok; live ones need a passed,
+    // engaged session.
     const participantOk = (outcome) => participantOutcomeOk(outcome, dryRun);
     const adapterFailure = adapterScoreFailureMessage(bundle);
     const ok = resultOk({
@@ -81,21 +84,19 @@ function cuaLabResult(args) {
         if (ok)
             return undefined;
         if (adapterFailure !== undefined) {
-            return {
-                code: "HUMANISH_CUA_LAB_FAILED",
-                message: adapterFailure,
-            };
+            return { code: "HUMANISH_COMPUTER_USE_FAILED", message: adapterFailure };
         }
         if (participantCount === 1) {
             const outcome = firstOutcome;
             return {
-                code: outcome?.failureCode ?? "HUMANISH_CUA_LAB_FAILED",
+                code: outcome?.failureCode ?? "HUMANISH_COMPUTER_USE_FAILED",
                 message: outcome?.sessionError ??
                     outcome?.providerCleanupError ??
+                    outcome?.providerPolicyError ??
                     (outcome?.noEngagement
                         ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
-                        : // The lane result (toParticipantResult) named this refusal; the N=1 envelope fell through to
-                            // "did not produce a terminal session", which is false — it produced one and refused it.
+                        : // The participant result (toParticipantResult) named this refusal; the N=1 envelope fell through to
+                            // "did not produce a terminal session", which is false: it produced one and refused it.
                             outcome?.selfReportedBlocker
                                 ? "Actor reported goal_satisfied while its final message described a blocker or asked for missing instructions; not a credible pass."
                                 : observer.ok
@@ -108,20 +109,19 @@ function cuaLabResult(args) {
             };
         }
         const failing = (outcomes ?? []).find((outcome) => !participantOk(outcome));
-        const geometryFailure = (outcomes ?? []).find((outcome) => outcome.failureCode === "HUMANISH_CUA_LAB_DEVICE_GEOMETRY");
-        const code = geometryFailure?.failureCode ?? "HUMANISH_CUA_LAB_FAILED";
+        const geometryFailure = (outcomes ?? []).find((outcome) => outcome.failureCode === "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY");
+        const code = geometryFailure?.failureCode ?? "HUMANISH_COMPUTER_USE_FAILED";
         return {
             code,
             message: observer.ok
-                ? `Fan-out run failed: ${summary.passed}/${participantCount} participant(s) passed (${summary.skipped} skipped, ${summary.harnessErrors} harness error(s), ${summary.hollow} hollow)${failing?.sessionError !== undefined ? `; first failure: ${failing.sessionError}` : failing === undefined && args.execution.failures[0] !== undefined ? `; ${args.execution.failures[0].message}` : ""}.`
+                ? `Fan-out run failed: ${summary.passed}/${participantCount} participant(s) passed (${summary.skipped} skipped, ${summary.harnessErrors} harness error(s), ${summary.hollow} without engagement)${failing?.sessionError !== undefined ? `; first failure: ${failing.sessionError}` : failing === undefined && args.execution.failures[0] !== undefined ? `; ${args.execution.failures[0].message}` : ""}.`
                 : (observer.error?.message ?? "Observer failed for the computer-use fan-out run."),
         };
     })();
     return {
-        schema: CUA_ACTOR_LAB_SCHEMA,
+        ...studyResultIdentity("computer-use", labId),
         ok,
         cwd,
-        labId,
         actor: args.actorId,
         appUrl,
         dryRun,
@@ -164,10 +164,11 @@ function cuaLabResult(args) {
     };
 }
 /**
- * The run's execution failures: each lane whose session failed in the harness, and an Observer
- * that failed.
+ * The run's execution failures: 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 computerUseExecutionFailures(outcomes, observer) {
+function computerUseExecutionFailures(outcomes, observer, runId) {
     return [
         ...(outcomes ?? [])
             .filter((outcome) => participantHarnessFailed(participantFactsOf(outcome)))
@@ -183,6 +184,15 @@ function computerUseExecutionFailures(outcomes, observer) {
                     message: `${outcome.spec.planned.id}: ${outcome.providerCleanupError}`,
                 },
             ]),
+        ...(outcomes ?? []).flatMap((outcome) => outcome.providerPolicyError === undefined
+            ? []
+            : [
+                {
+                    kind: "provider-policy",
+                    message: `${outcome.spec.planned.id}: ${outcome.providerPolicyError}`,
+                },
+            ]),
+        ...unreleasedSandboxFailures(outcomes, runId),
         ...(observer.ok
             ? []
             : [
@@ -194,33 +204,34 @@ function computerUseExecutionFailures(outcomes, observer) {
     ];
 }
 /**
- * execution.caps.maxUsd is enforced inside each lane's loop independently, so an N-lane fan-out can
- * spend up to N × maxUsd before any lane aborts, while the run cost summary reports the larger
+ * execution.caps.maxUsd is enforced inside each participant's loop independently, so an
+ * N-participant fan-out can spend up to N × maxUsd before any participant aborts, while the run cost summary reports the larger
  * aggregate. The warning names that ceiling, unless the study declared a shared maxTotalUsd budget.
  */
-function participantCapWarning(config, participantCount) {
-    const capUsd = config.execution?.caps?.maxUsd;
+function participantCapWarning(caps, participantCount) {
+    const capUsd = caps.maxUsd;
     if (capUsd === undefined || participantCount <= 1)
         return undefined;
-    if (config.execution?.caps?.maxTotalUsd !== undefined)
+    if (caps.maxTotalUsd !== undefined)
         return undefined;
-    return `execution.caps.maxUsd ($${capUsd}) is a PER-PARTICIPANT cap; ${participantCount} participants may spend up to ${participantCount} × $${capUsd} (~$${round6(capUsd * participantCount)} total) before any participant aborts. Set execution.caps.maxTotalUsd for a shared study budget.`;
+    return `execution.caps.maxUsd ($${capUsd}) caps each participant, so ${participantCount} participants may spend up to ${participantCount} × $${capUsd} (about $${round6(capUsd * participantCount)}) before any of them stops. Set execution.caps.maxTotalUsd for one budget across the study.`;
 }
 /** Builds and publishes the final bundle, runs the adapter hooks, renders the Observer and returns the result. */
 export async function finishCuaRun(setup, finish, ran) {
-    const { plan, input, config, cwd, streams, descriptor, subjectRoute, run } = setup;
+    const { plan, input, cwd, streams, descriptor, run } = setup;
     const { participantRuns, participantPlan, scrubKnownValues, bundleBase } = setup;
-    const { hooks, rerunLineage, publicRepo, subjectArgs } = finish;
+    const { rerunLineage, publicRepo, subjectArgs } = finish;
     const { dryRun } = plan;
-    const { appUrl, subjectEnvNames } = subjectRoute;
+    const appUrl = plannedAppUrl(plan.runner.subject);
+    const subjectEnvNames = [...participantSubjectEnv(plan.runner.subject)];
     const { runId } = run;
     const participantCount = participantRuns.length;
     const { outcomes, failFastReason, receiving, receivingWarnings, externalCommsWarnings } = ran;
-    // Per-lane subject projections (invariant 5).
+    // Per-participant subject projections.
     const subjects = projectParticipantSubjects({ ...subjectArgs, outcomes, dryRun });
     const aggregate = aggregateCuaSubject({ subjects, outcomes, participantCount, dryRun });
     const aggregateSubject = aggregate.subject;
-    const capWarning = participantCapWarning(config, participantCount);
+    const capWarning = participantCapWarning(plan.caps, participantCount);
     const aggregateWarnings = [
         ...externalCommsWarnings,
         ...(capWarning === undefined ? [] : [capWarning]),
@@ -239,8 +250,8 @@ export async function finishCuaRun(setup, finish, ran) {
         ...(failFastReason === undefined ? {} : { failFastReason }),
     });
     const adapterWarnings = [];
-    const scorerResult = await applyBrowserAdapterHooks({
-        hooks,
+    const scorerResult = await applyBrowserScorer({
+        scorer: input.scorer,
         bundle,
         context: {
             bundle,
@@ -248,13 +259,12 @@ export async function finishCuaRun(setup, finish, ran) {
             labId: plan.labId,
             runId,
             actor: descriptor.id,
-            backend: "cua",
+            route: "computer-use",
             dryRun,
-            laneCount: participantCount,
+            participantCount,
         },
         sanitize: (text) => redactText(scrubKnownValues(text)),
         warnings: adapterWarnings,
-        hookLabel: "cuaHooks",
         ...(input.scorerProvenance === undefined ? {} : { scorerProvenance: input.scorerProvenance }),
     });
     // The one final verdict fold: scoring can only make the judged verdict stricter.
@@ -264,7 +274,7 @@ export async function finishCuaRun(setup, finish, ran) {
     const finished = await run.finish(bundle);
     const observer = await finished.renderObserver();
     streams.attachFinal(observer);
-    const execution = judgeExecution(computerUseExecutionFailures(outcomes, observer), OUTCOME_POLICIES["computer-use"]);
+    const execution = judgeExecution(computerUseExecutionFailures(outcomes, observer, runId), OUTCOME_POLICIES["computer-use"]);
     const result = cuaLabResult({
         labId: plan.labId,
         cwd,

package/dist/routes/computer-use/route.d.ts

@@ -4,14 +4,15 @@ import type { LabConfig } from "../../lab/types.js";
 import { type ComputerUseRefusal } from "./plan.js";
 import { type ComputerUseRunInput, type CuaActorLabResult, type RunCuaActorLabOptions } from "./types.js";
 /**
- * The library entry for a computer-use lab. It plans the config with planComputerUseLab and runs
+ * Plans and runs a computer-use lab in one call. It is not exported from src/index.ts; tests call
+ * it. It plans the config with planComputerUseLab and runs
  * the plan with runComputerUsePlan, whose run scope and withTransientCommsSecrets wrapper cover the
  * run and its analysis.
  */
 export declare function runCuaActorLab(options: RunCuaActorLabOptions): Promise<CuaActorLabResult>;
 /**
  * A refused computer-use lab's result, at the refusal's stage: a before-scope refusal has its own
- * envelope and no analysis record; the others come after the cwd checks, and the lane cap after
+ * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
  * the personas are read.
  */
 export declare function computerUseLabRefusal(options: RunCuaActorLabOptions, refusal: ComputerUseRefusal): Promise<CuaActorLabResult>;
@@ -26,8 +27,7 @@ export declare function admitComputerUsePlan(plan: ComputerUsePlan, input: Compu
  * Run a computer-use plan: its local checks, then the run. The run scope in runAdmittedCuaRun
  * finalizes any status record the run opened, on every exit, so a test or library caller does not
  * leave the 5 s status cadence writing into a directory something else is deleting (an unrelated
- * ENOTEMPTY). Participants and the brain (model and local agent) come from the plan. `config` is
- * still read for values the plan does not carry yet (persona ids, comms settings, the
- * per-participant cap) and by the compatibility hooks, which take the whole config.
+ * ENOTEMPTY). Participants, the brain, the subject, the caps and the residual config come from the
+ * plan. `config` is what the caller's createProvider and inProcess executor receive.
  */
 export declare function runComputerUsePlan(plan: ComputerUsePlan, input: ComputerUseRunInput, config: LabConfig): Promise<CuaActorLabResult>;

package/dist/routes/computer-use/route.js

@@ -1,6 +1,6 @@
 // The computer-use lab backend: a subject (an app-url the caller provisioned, or a repo the
-// lab clones AND serves in-sandbox) driven by a REGISTRY-RESOLVED computer-use actor inside a
-// hosted E2B desktop. This is the path that makes `actors[].type` load-bearing — the
+// lab clones and serves in-sandbox) driven by a registry-resolved computer-use actor inside a
+// hosted E2B desktop. On this path `actors[].type` selects the actor: the
 // descriptor returned by the registry runs the session; the lab provisions the desktop and
 // subject, composes the prompt from config, persists the evidence bundle, and tears down.
 //
@@ -8,42 +8,45 @@
 // - The desktop is created via the shared loader in src/substrates/e2b/sdk.ts with
 //   kill-on-timeout lifecycle, so a dead host process can never orphan a sandbox past its
 //   server-side deadline.
-// - Env placement follows the doctrine (docs/principles/invariants-and-defaults.md): the
-//   ACTOR's key never enters the sandbox (the model drives from outside via the provider API);
-//   the SUBJECT's declared env NAMES are provisioned in on the clone route — values come from
+// - Env placement follows the placement rule (docs/principles/invariants-and-defaults.md): the
+//   actor's key never enters the sandbox (the model drives from outside via the provider API);
+//   the subject's declared env names are provisioned in on the clone route; values come from
 //   the caller's environment and are never logged or persisted.
 // - The live stream URL is runtime-only (carries an auth key) and is never persisted into run
-//   artifacts — only its presence is recorded.
+//   artifacts; only its presence is recorded.
 // - Evidence redaction is mode-aware (docs/principles/invariants-and-defaults.md, the
-//   capture-vs-publish rule): screenshots persist RAW (full fidelity) by default into gitignored
+//   capture-vs-publish rule): screenshots persist raw (full fidelity) by default into gitignored
 //   .humanish/; `policies.redactScreenshots: true` opts into blur-at-capture for a share-as-is
-//   bundle. Length-only typed text and text redaction of reasoning/messages are UNCONDITIONAL;
-//   harness errors are redacted at THIS boundary; the bundle's `stream.actor` carries the
+//   bundle. Length-only typed text and text redaction of reasoning/messages are unconditional;
+//   harness errors are redacted at this boundary; the bundle's `stream.actor` carries the
 //   conformant humanish.actor-trace.v1 projection, whose `redaction.screenshots` records the
-//   run's actual mode ("raw" | "blurred" | "n/a") — every label downstream derives from it.
+//   run's actual mode ("raw" | "blurred" | "n/a"), and every label downstream derives from it.
 import { withTransientCommsSecrets } from "../../run/transient-comms-secrets.js";
 import path from "node:path";
 import { completeAutomaticAnalysis } from "../../analysis/automatic-completion.js";
 import { runScope } from "../../run/run.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
-import { computerUseInputWithScorer } from "../../lab/route-inputs.js";
-import { planComputerUseLab } from "./plan.js";
+import { browserRouteScorer } from "../../lab/adapter-scorer-loader.js";
+import { withLateScorer } from "../../lab/route-inputs.js";
+import { callerDrivingOf, planComputerUseLab } from "./plan.js";
 import { finishCuaRun } from "./result.js";
-import { runLabParticipants } from "./run-lanes.js";
+import { runLabParticipants } from "./live-phase.js";
 import { admitCuaRun, refuseCuaLab, startCuaRun } from "./setup.js";
-import { CUA_ACTOR_LAB_SCHEMA, } from "./types.js";
+import {} from "./types.js";
+import { studyResultIdentity } from "../../run/study-result.js";
 /**
- * The library entry for a computer-use lab. It plans the config with planComputerUseLab and runs
+ * Plans and runs a computer-use lab in one call. It is not exported from src/index.ts; tests call
+ * it. It plans the config with planComputerUseLab and runs
  * the plan with runComputerUsePlan, whose run scope and withTransientCommsSecrets wrapper cover the
  * run and its analysis.
  */
 export async function runCuaActorLab(options) {
-    const { config, dryRun, lab, ...input } = options;
+    const { config, dryRun, ...input } = options;
     // planComputerUseLab makes every configuration refusal, in the order this route always has.
     const planned = planComputerUseLab(config, {
         dryRun,
-        ...(lab === undefined ? {} : { lab }),
-        ...(input.hooks === undefined ? {} : { hooks: input.hooks }),
+        hasRunSession: input.deps?.runSession !== undefined,
+        driving: callerDrivingOf(input),
         ...(input.countOverride === undefined ? {} : { countOverride: input.countOverride }),
         ...(input.rerun === undefined ? {} : { rerun: input.rerun }),
     });
@@ -53,17 +56,16 @@ export async function runCuaActorLab(options) {
 }
 /**
  * A refused computer-use lab's result, at the refusal's stage: a before-scope refusal has its own
- * envelope and no analysis record; the others come after the cwd checks, and the lane cap after
+ * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
  * the personas are read.
  */
 export async function computerUseLabRefusal(options, refusal) {
     const { config, dryRun } = options;
     if (refusal.stage === "before-scope")
         return {
-            schema: CUA_ACTOR_LAB_SCHEMA,
+            ...studyResultIdentity("computer-use", config.id),
             ok: false,
             cwd: path.resolve(options.cwd),
-            labId: config.id,
             actor: config.actors[0]?.type ?? "",
             dryRun,
             runId: options.runId ?? "not-created",
@@ -72,9 +74,9 @@ export async function computerUseLabRefusal(options, refusal) {
             warnings: [],
             error: { code: refusal.code, message: refusal.message },
         };
-    // The other refusals come after the cwd checks, and the lane cap after the personas are read.
+    // The other refusals come after the cwd checks, and the participant cap after the personas are read.
     const analysis = resolveAutomaticAnalysis(config.review?.analysis);
-    return completeAutomaticAnalysis(await refuseCuaLab(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options.automaticAnalysis, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
+    return completeAutomaticAnalysis(await refuseCuaLab(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
 }
 /**
  * runLab's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
@@ -92,24 +94,22 @@ export async function admitComputerUsePlan(plan, input, config) {
     return {
         ok: true,
         run: async (scorer) => {
-            const running = computerUseInputWithScorer(input, scorer);
-            // The scorer's hooks wrap the admitted bag, so the runSession, provider and desktop the
-            // checks admitted stay the ones the run uses.
-            const admitted = { ...admission.admitted, hooks: running.hooks ?? admission.admitted.hooks };
-            return cuaOutcome(await runAdmittedCuaRun(plan, running, admitted));
+            // The scorer joins the input only; the runSession, provider and desktop the checks admitted
+            // stay the ones the run uses.
+            const running = withLateScorer(input, scorer, browserRouteScorer);
+            return cuaOutcome(await runAdmittedCuaRun(plan, running, admission.admitted));
         },
     };
 }
 function cuaOutcome(result) {
-    return { route: "computer-use", backend: "cua", result };
+    return { route: "computer-use", result };
 }
 /**
  * Run a computer-use plan: its local checks, then the run. The run scope in runAdmittedCuaRun
  * finalizes any status record the run opened, on every exit, so a test or library caller does not
  * leave the 5 s status cadence writing into a directory something else is deleting (an unrelated
- * ENOTEMPTY). Participants and the brain (model and local agent) come from the plan. `config` is
- * still read for values the plan does not carry yet (persona ids, comms settings, the
- * per-participant cap) and by the compatibility hooks, which take the whole config.
+ * ENOTEMPTY). Participants, the brain, the subject, the caps and the residual config come from the
+ * plan. `config` is what the caller's createProvider and inProcess executor receive.
  */
 export async function runComputerUsePlan(plan, input, config) {
     const admission = await admitCuaRun(plan, input, config);
@@ -129,9 +129,12 @@ function runAdmittedCuaRun(plan, input, admitted) {
     });
 }
 function completeCuaAnalysis(plan, input, result, finished) {
-    return completeAutomaticAnalysis(result, finished, plan.analysis?.config, input.automaticAnalysis, {
+    // A local VM study whose cleanup is unconfirmed records a skip instead of analyzing.
+    const refusal = input.localVm?.analysisRefusal;
+    return completeAutomaticAnalysis(result, finished, plan.analysis?.config, input, {
         ...(plan.analysis === undefined ? {} : { trigger: plan.analysis.trigger }),
         preferLargerOutput: plan.analysis?.preferLargerOutput === true,
+        ...(refusal === undefined ? {} : { refusal }),
     });
 }
 async function runPlanInScope(plan, input, admitted, scope) {

package/dist/routes/computer-use/self-report.d.ts

@@ -1,21 +1,21 @@
 import type { CuaLoopResult } from "../../actors/computer-use/loop.js";
 import { type SessionEnding } from "../../run/judge.js";
 /**
- * A goal_satisfied lane counts as a self-reported blocker ONLY when its final narrative contradicts
- * the goal AND the run's own stop predicate did NOT fire. A matched stopWhen is independent,
- * structured completion evidence, so it overrides a text scan of the free-form narrative — which can
- * otherwise trip on the subject app's OWN quoted copy (e.g. a relayed "cannot be undone" banner).
- * Resolved-arc segments never block the verdict (#453). Returns the offending reason, or undefined
- * when the lane is a clean pass. Exported for testing.
+ * A goal_satisfied participant counts as a self-reported blocker only when its final narrative contradicts
+ * the goal and the run's own stop predicate did not fire. A matched stopWhen is independent,
+ * structured completion evidence, so it overrides a text scan of the free-form narrative, which can
+ * otherwise trip on the subject app's own quoted copy (e.g. a relayed "cannot be undone" banner).
+ * Resolved-arc segments never block the verdict. Returns the offending reason, or undefined
+ * when the participant is a clean pass. Exported for testing.
  */
 export declare function resolveSelfReportedBlocker(session: CuaLoopResult | undefined): string | undefined;
 /** A session's ending, reduced to what the judge's engagement and blocker rules read. */
 export declare function sessionEnding(session: CuaLoopResult): SessionEnding;
 /**
- * Friction is independent of how a completed session ended (#657). Read the participant's
+ * Friction is independent of how a completed session ended. Read the participant's
  * redacted messages, including earlier reports, rather than the harness-owned reason that
  * stopWhen/dwell writes. Reasoning, observations, and notices are not participant reports.
- * Resolved arcs still count (#453); quoted copy and negated reports still do not. This read
+ * Resolved arcs still count; quoted copy and negated reports still do not. This read
  * never changes the verdict. Exported for testing.
  */
 export declare function resolveSelfReportedFriction(session: CuaLoopResult | undefined): string | undefined;