humanish 0.107.0 → 0.108.0

package/dist/routes/computer-use/participant-runs.js

@@ -46,18 +46,18 @@ export function resolveParticipantSandboxMs(config) {
             SANDBOX_TIMEOUT_BUFFER_MS);
 }
 /**
- * The in-flight participant bound a lab declares. Defaults to the participant count — every
+ * The in-flight participant bound a lab declares. Defaults to the participant count: every
  * declared participant runs at once, because a throttle nobody asked for silently turns "N actors
- * live" into waves (#350); total session count and spend are the same either way, only wall-clock
- * and simultaneity differ. A declared execution.concurrency is a CAP, clamped to [1, participants].
+ * live" into waves; total session count and spend are the same either way, only wall-clock
+ * and simultaneity differ. A declared execution.concurrency is a cap, clamped to [1, participants].
  * The planner records it; the route may only lower it from the environment.
  */
 export function boundedConcurrency(declared, participantCount) {
     return Math.max(1, declared === undefined ? participantCount : Math.min(Math.max(1, declared), participantCount));
 }
 /**
- * The planned bound, lowered by the env override. The override may only LOWER it (never raise
- * concurrent paid desktops — invariant 3), and a lowering is reported via envLoweredFrom so the
+ * The planned bound, lowered by the env override. The override may only lower it (never raise
+ * concurrent paid desktops), and a lowering is reported via envLoweredFrom so the
  * plan never silently disagrees with the manifest.
  */
 function envLoweredConcurrency(planned, participantCount, env) {
@@ -81,7 +81,7 @@ function plannedParticipantsOf(config, countOverride) {
         desktopCli: config.subject.source === "desktop-cli",
     };
 }
-/** Build the participant runs AND the public plan from the planned participants (pure). */
+/** Build the participant runs and the public plan from the planned participants (pure). */
 function participantRunsAndPlan(planned, opts = {}) {
     const env = opts.env ?? {};
     // Who each participant is (id, persona, focus, device, limits) comes from the plan; this adds
@@ -162,17 +162,17 @@ function participantRunsAndPlan(planned, opts = {}) {
     return { runs, participantPlan };
 }
 /**
- * Pure pre-flight plan resolver (runs in dry-run AND live). Returns the participant table, the
+ * Pure pre-flight plan resolver (runs in dry-run and live). Returns the participant table, the
  * effective concurrency, the wave count, the per-participant session budget, and the worst-case total
- * sandbox-minutes — BEFORE any sandbox or provider call. The same plan appears in dry-run,
+ * sandbox-minutes, before any sandbox or provider call. The same plan appears in dry-run,
  * marked $0 (dryRun: true).
  */
 export function resolveCuaParticipantPlan(config, opts = {}) {
     const { countOverride, ...rest } = opts;
     return participantRunsAndPlan(plannedParticipantsOf(config, countOverride), rest).participantPlan;
 }
-/** Print the participant plan to stderr BEFORE any sandbox/provider call (public-safe: ids, devices,
- *  digests, and budgets only — no prompt text, no secrets). */
+/** Print the participant plan to stderr before any sandbox/provider call (public-safe: ids, devices,
+ *  digests, and budgets only; no prompt text, no secrets). */
 export function emitPreflightPlan(participantPlan, labId) {
     const lines = [];
     lines.push(`humanish computer-use fan-out plan (${labId}): ${participantPlan.laneCount} participant(s), strategy ${participantPlan.strategy}, concurrency ${participantPlan.concurrency}${participantPlan.envLoweredConcurrencyFrom === undefined ? "" : ` (lowered from ${participantPlan.envLoweredConcurrencyFrom} by ${CUA_MAX_CONCURRENCY_ENV})`}, ${participantPlan.waves} wave(s).`);
@@ -212,8 +212,8 @@ export async function compileParticipantPersonas(projectRoot, personaIds) {
 export async function loadCuaParticipants(args) {
     const { plan } = args;
     const { participants } = plan.runner;
-    // Compile any committed personas BEFORE planning, so the plan builder stays pure and each participant's
-    // prompt carries real behavioral directives rather than a bare `Persona: <id>.` label (#381).
+    // Compile any committed personas before planning, so the plan builder stays pure and each participant's
+    // prompt carries real behavioral directives rather than a bare `Persona: <id>.` label.
     const personas = await compileParticipantPersonas(args.projectRoot, participants.map((participant) => participant.personaId));
     const { runs: participantRuns, participantPlan } = participantRunsAndPlan({
         participants,
@@ -235,7 +235,7 @@ export async function loadCuaParticipants(args) {
         participantPlan,
     });
     if (!selected.ok) {
-        return { ok: false, code: "HUMANISH_CUA_LAB_RERUN_INVALID", message: selected.message };
+        return { ok: false, code: "HUMANISH_COMPUTER_USE_RERUN_INVALID", message: selected.message };
     }
     return {
         ok: true,

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

@@ -8,8 +8,8 @@ import { isHttpUrl, isLoopbackUrl } from "../../lab/parse/subject.js";
 import { subjectStateInvalidReason } from "../../lab/parse/subject-state.js";
 import { brainOf, callerBrainOf, capsOf, desktopRequirements, planBase, provisionedSubject, } from "../../lab/plan-base.js";
 import { computerUseParticipants, declaredTargets } from "../../lab/plan-participants.js";
-import { MAX_CUA_LANES } from "../../lab/routing.js";
-import { cloneTargetValidationReason, cuaLaneValidationReason, desktopMediaValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, scenarioCapsValidationReason, taskProtocolValidationReason, } from "../../lab/validation.js";
+import { MAX_COMPUTER_USE_PARTICIPANTS } from "../../lab/routing.js";
+import { cloneTargetValidationReason, computerUseValidationReason, desktopMediaValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, scenarioCapsValidationReason, taskProtocolValidationReason, } from "../../lab/validation.js";
 import { desktopCliProductReason } from "../../lab/composition-rules.js";
 import { isLocalBrowserLab } from "../../substrates/local/runtime-config.js";
 import { boundedConcurrency, defaultSessionTimeoutMs, resolveParticipantSandboxMs, } from "./participant-runs.js";
@@ -65,7 +65,7 @@ export function plannedAppUrl(subject) {
     return "appUrl" in subject ? subject.appUrl : "";
 }
 const invalid = (message) => ({
-    code: "HUMANISH_CUA_LAB_SUBJECT_INVALID",
+    code: "HUMANISH_COMPUTER_USE_SUBJECT_INVALID",
     message,
 });
 /**
@@ -110,7 +110,7 @@ function subjectStructureReason(config, subjectRoute) {
     if (cloneRoute &&
         (!serve || !subjectRepo || !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(subjectRepo)))
         return invalid(!serve
-            ? "clone subjects on the computer-use route require `subject.serve` (start + url) — the lab serves the app in-sandbox."
+            ? "A clone subject on the computer-use route needs `subject.serve` (start and url): humanish starts the app in the sandbox before the participant opens it."
             : `subject.repos[0] must be an owner/repo slug (got "${subjectRepo ?? ""}").`);
     // A library caller that skips parseLabConfig gets the same fail-closed shape the parser
     // enforces, naming which requirement is missing.
@@ -146,7 +146,7 @@ function entryTargetReason(config, subjectRoute) {
     if (entryTargetSafe)
         return undefined;
     return {
-        code: "HUMANISH_CUA_LAB_SUBJECT_UNSAFE",
+        code: "HUMANISH_COMPUTER_USE_SUBJECT_UNSAFE",
         message: provisionedRoute || localAppSubject || !allowPublicTargets
             ? "subject.appUrl and any actors[0].lanes[].target entries must be loopback (127.0.0.1 or localhost) unless policies.allowPublicTargets is set for an app-url subject."
             : "subject.appUrl and actors[0].lanes[].target entries must be valid http(s) URLs.",
@@ -158,13 +158,13 @@ function driverReason(driving, { localAppSubject, inProcessRoute }) {
     // and would fail closed against an executor that returns no screenshot.
     if (driving.inProcess && !driving.createProvider)
         return {
-            code: "HUMANISH_CUA_LAB_EXECUTOR_NO_PROVIDER",
-            message: "RunLabOptions.inProcess requires RunLabOptions.createProvider — a state-driven executor returns no screenshot, so it must be paired with a NON-vision provider (the default OpenAI computer-use provider is vision-based and would fail closed).",
+            code: "HUMANISH_COMPUTER_USE_EXECUTOR_NO_PROVIDER",
+            message: "RunLabOptions.inProcess needs RunLabOptions.createProvider: an in-process executor returns no screenshot, so it needs a provider that does not read images. The default OpenAI computer-use provider reads screenshots and would stop the session.",
         };
     // There is no built-in in-process driver for a local app.
     if (localAppSubject && !inProcessRoute)
         return {
-            code: "HUMANISH_CUA_LAB_LOCAL_APP_NO_EXECUTOR",
+            code: "HUMANISH_COMPUTER_USE_LOCAL_APP_NO_EXECUTOR",
             message: "subject.source: local-app has no built-in driver. Supply one through runLab(config, { inProcess: { executor }, createProvider }); a state-driven executor needs a non-vision provider.",
         };
     return undefined;
@@ -173,9 +173,9 @@ function driverReason(driving, { localAppSubject, inProcessRoute }) {
 function rosterShapeReason(config) {
     // `lanes` XOR `count`/`laneFocus`, device XOR raw resolution, cap, unique ids,
     // allowPublicTargets with more than one participant, clone.fanout.
-    const fanoutReason = cuaLaneValidationReason(config);
+    const fanoutReason = computerUseValidationReason(config);
     if (fanoutReason)
-        return { code: "HUMANISH_CUA_LAB_FANOUT_INVALID", message: fanoutReason };
+        return { code: "HUMANISH_COMPUTER_USE_FANOUT_INVALID", message: fanoutReason };
     // The sandbox deadline is derived from the session budget, so a lab can ask for a session that
     // cannot legally be provisioned. Show the arithmetic: the provider's own error names a limit
     // but not which knob produced it.
@@ -210,40 +210,40 @@ export function planComputerUseLab(config, input) {
     });
     const analysis = resolveAutomaticAnalysis(config.review?.analysis);
     if (!analysis.ok)
-        return refuse("before-scope", "HUMANISH_LAB_ANALYSIS_INVALID", analysis.message);
+        return refuse("before-scope", "HUMANISH_STUDY_ANALYSIS_INVALID", analysis.message);
     const tasksReason = taskProtocolValidationReason(config, true);
     if (tasksReason)
-        return refuse("before-scope", "HUMANISH_LAB_TASKS_UNSUPPORTED", tasksReason);
+        return refuse("before-scope", "HUMANISH_STUDY_TASKS_UNSUPPORTED", tasksReason);
     // The parser checks the actor too; a library caller skips the parser.
     const actorType = config.actors[0]?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isCuaActorDescriptor(descriptor))
-        return refuse("in-scope", "HUMANISH_CUA_LAB_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered computer-use actor.`);
+        return refuse("in-scope", "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered computer-use actor.`);
     const actor = descriptor.id;
     const rejection = cuaLabRejection(config, hasRunSession, driving, declaredSubjectRoute(config, driving));
     if (rejection)
         return refuse("in-scope", rejection.code, rejection.message, actor);
-    // A shared world runs every seat against one app; this route would run them as separate participants.
-    // It comes after the rules above, so a shared-world config that breaks one of them, which runLab
-    // sends here, still gets that rule's message.
+    // A shared world runs every participant against one app; this route would run them as separate
+    // participants. It comes after the rules above, so a shared-world config that breaks one of them,
+    // which runLab sends here, still gets that rule's message.
     if (config.subject.topology === "shared-world")
-        return refuse("in-scope", "HUMANISH_CUA_LAB_SUBJECT_INVALID", "subject.topology: shared-world labs run every participant against one shared app on the shared-world route; runCuaActorLab runs independent participants. Run the lab with runLab or runConcurrentSharedWorld.", actor);
+        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "subject.topology: shared-world labs run every participant against one shared app on the shared-world route; runCuaActorLab runs independent participants. Run the lab with runLab or runConcurrentSharedWorld.", actor);
     // The in-process route drives subject.appUrl on this machine and creates no desktop, so it would
     // skip the subject a clone, local-tree or desktop-cli lab declares.
     const source = config.subject.source;
     if (driving.inProcess &&
         (source === "clone" || source === "local-tree" || source === "desktop-cli"))
-        return refuse("in-scope", "HUMANISH_CUA_LAB_SUBJECT_INVALID", `RunLabOptions.inProcess drives subject.appUrl in this process, and a ${source} subject needs the hosted desktop the in-process route never creates. Use an app-url or local-app subject with inProcess, or remove inProcess to run on a hosted desktop.`, actor);
+        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", `RunLabOptions.inProcess drives subject.appUrl in this process, and a ${source} subject needs the hosted desktop the in-process route never creates. Use an app-url or local-app subject with inProcess, or remove inProcess to run on a hosted desktop.`, actor);
     // The parser's rule; without a product the desktop study fails later.
     const productReason = desktopCliProductReason(config);
     if (productReason)
-        return refuse("in-scope", "HUMANISH_CUA_LAB_SUBJECT_INVALID", productReason, actor);
+        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", productReason, actor);
     const participants = computerUseParticipants(config, input.countOverride);
-    if (participants.length > MAX_CUA_LANES)
-        return refuse("after-personas", "HUMANISH_CUA_LAB_FANOUT_INVALID", `Computer-use fan-out is capped at ${MAX_CUA_LANES} participants (resolved ${participants.length}); N concurrent paid desktops is real spend.`, actor);
+    if (participants.length > MAX_COMPUTER_USE_PARTICIPANTS)
+        return refuse("after-personas", "HUMANISH_COMPUTER_USE_FANOUT_INVALID", `Computer-use fan-out is capped at ${MAX_COMPUTER_USE_PARTICIPANTS} participants (resolved ${participants.length}); N concurrent paid desktops is real spend.`, actor);
     const [first, ...rest] = participants;
     if (driving.inProcess && rest.length > 0)
-        return refuse("after-personas", "HUMANISH_CUA_LAB_FANOUT_INVALID", "Fan-out to more than one participant is not supported on the in-process route (RunLabOptions.inProcess): fan-out provisions one independent E2B desktop per participant, which the in-process route deliberately skips. Run a single in-process participant, or fan out on the E2B route.", actor);
+        return refuse("after-personas", "HUMANISH_COMPUTER_USE_FANOUT_INVALID", "Fan-out to more than one participant is not supported on the in-process route (RunLabOptions.inProcess): fan-out provisions one independent E2B desktop per participant, which the in-process route deliberately skips. Run a single in-process participant, or fan out on the E2B route.", actor);
     if (first === undefined)
         throw new Error("computerUseParticipants returned no participant");
     const appUrl = config.subject.appUrl ?? "";

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

@@ -5,13 +5,13 @@ 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 { 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
@@ -27,7 +27,7 @@ export async function liveCuaRejection(args) {
     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 = missing.includes("OPENAI_API_KEY")
             ? await (async () => {
@@ -35,17 +35,17 @@ export async function liveCuaRejection(args) {
                 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",
+            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}`,
         };
     }
     // 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
+        // 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)
@@ -54,38 +54,38 @@ export async function liveCuaRejection(args) {
     const unsetSubjectEnv = missingSubjectEnv(requirements, env);
     if (unsetSubjectEnv.length > 0) {
         return {
-            code: "HUMANISH_CUA_LAB_SUBJECT_ENV_MISSING",
+            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
+    // 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
-    // OUR service marker in /health, so an adopter's proxy answering 200 for everything cannot
+    // 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_CUA_LAB_COMMS_TOKEN_INVALID", message: tokenRefusal };
+        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));

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

@@ -7,8 +7,9 @@ import { summarizeCuaDiagnostics } from "./diagnostics.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, participantSubjectEnv, } 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) {
@@ -83,19 +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 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.
+                            // "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,
@@ -214,7 +214,7 @@ function participantCapWarning(caps, participantCount) {
         return 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) {
@@ -227,7 +227,7 @@ export async function finishCuaRun(setup, finish, ran) {
     const { runId } = run;
     const participantCount = participantRuns.length;
     const { outcomes, failFastReason, receiving, receivingWarnings, externalCommsWarnings } = ran;
-    // Per-participant 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;

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

@@ -4,7 +4,8 @@ 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.
  */

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,19 +8,19 @@
 // - 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";
@@ -32,9 +32,11 @@ import { callerDrivingOf, planComputerUseLab } from "./plan.js";
 import { finishCuaRun } from "./result.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.
  */
@@ -61,10 +63,9 @@ 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",

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 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 (#453). Returns the offending reason, or undefined
+ * 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;