humanish 0.110.2 → 0.110.3

package/ARCHITECTURE.md

@@ -9,25 +9,20 @@ longer declares that name. [CONTEXT.md](CONTEXT.md) defines the domain terms, an
 
 The steps follow a live computer-use study on a hosted E2B desktop. Every route shares steps 1, 2, 7
 and 8. Steps 3 to 6 run in the route's admit function and the `run()` it returns, which `runStudyWith`
-reaches through `admitPlan` (`src/run-study.ts`):
+reaches through `admitPlan` (`src/run-study.ts`). Four of the admit functions hand their checks and
+the body they run inside the run scope to `admitRoute` (`src/run/route-shell.ts`). It completes the
+automatic analysis of a refusal, and its `run()` opens the run scope, runs the body and completes
+the analysis of the run:
 
-- computer-use: `admitComputerUsePlan` (`src/routes/computer-use/route.ts`); its `run()` calls
-  `runAdmittedCuaRun` (`src/routes/computer-use/route.ts`).
-- scripted: `admitScriptedPlan` (`src/routes/scripted/route.ts`); its `run()` calls
-  `runScriptedPlan` (`src/routes/scripted/route.ts`).
-- terminal: `admitTerminalPlan` (`src/routes/terminal/route.ts`); its `run()` calls
-  `runAdmittedTerminalRun` (`src/routes/terminal/route.ts`).
-- shared-world: `admitSharedWorldPlan` (`src/routes/shared-world/route.ts`); its `run()` calls
-  `runAdmittedSharedWorldRun` (`src/routes/shared-world/route.ts`).
+- computer-use: `admitComputerUsePlan` (`src/routes/computer-use/route.ts`), with the checks in
+  `admitCuaRun` (`src/routes/computer-use/setup.ts`).
+- scripted: `admitScriptedPlan` (`src/routes/scripted/route.ts`), whose checks run inside the run.
+- terminal: `admitTerminalPlan` (`src/routes/terminal/route.ts`), with a live plan's checks in
+  `checkLiveTerminalMachine` (`src/routes/terminal/session.ts`).
+- shared-world: `admitSharedWorldPlan` (`src/routes/shared-world/route.ts`).
 - preview: `admitPreviewPlan` (`src/routes/preview.ts`); its `run()` calls `runPreviewPlan`
   (`src/routes/preview.ts`), which publishes a fixture bundle.
 
-`runComputerUsePlan` (`src/routes/computer-use/route.ts`), `runTerminalPlan`
-(`src/routes/terminal/route.ts`) and `runSharedWorldPlan` (`src/routes/shared-world/route.ts`)
-admit and run in one call. Only tests call them, directly or through the route modules'
-`runCuaActorStudy`, `runTerminalProductStudy` and `runConcurrentSharedWorld`. `runStudyWith` and the CLI do
-not.
-
 1. **Parse.** `runStudyCommand` (`src/cli/commands/study-run.ts`) calls `resolveStudyManifest`
    (`src/study/discover.ts`), which calls `parseStudy` (`src/study/config.ts`). It rejects unknown
    keys and the compositions the

package/CHANGELOG.md

@@ -8,6 +8,19 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.110.3: Ctrl-C at the watch prompt, review says analysis is off, E2B docs links kept (2026-10-05)
+
+humanish 0.110.3 runs the `watch` and `observe` shutdown, and prints `watch stopped` or `observe
+stopped`, when a Ctrl-C lands right at their prompt. It starts no automatic analysis for a run a
+signal interrupted. `humanish review` says when a study's `review.analysis: false` is why a live
+run has no findings. `humanish verify` no longer blocks a run whose text holds a URL followed by an
+escaped line break and an `E2B_` variable, and redacted output keeps the E2B docs link that E2B's
+401 names. The `--env-file` alias is now removed in 0.112.0. Inside, the computer-use, scripted,
+terminal and shared-world routes run through one shell, `admitRoute` in `src/run/route-shell.ts`;
+the live smoke ran each route on it.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.110.3)
+
 ## 0.110.2: Credential URLs refused, terminal key proxied, watch exits for agents (2026-10-05)
 
 humanish 0.110.2 refuses a study URL that carries a user name, password or credential parameter,

package/CONTEXT.md

@@ -28,7 +28,7 @@ bundle and output fields keep older spellings; the second table maps them.
 | computer use        | A model drives a participant by reading screenshots of a desktop and acting with mouse and keyboard. `openai-computer-use` and `local-agent` are the computer-use actors. CUA is the short form in code names such as `CuaExecutor` and in the older spellings listed under `cua` below.                                                                                                                                                                                                                                              | `src/routes/computer-use/`, `src/actors/computer-use/`                                                                                                                                                                                                                                                                                                                                                      |
 | fan-out             | A computer-use run with more than one participant, each on its own desktop, or any rerun. It writes the fan-out bundle shape and passes only when every expected participant passes. One participant without a rerun keeps the single-participant shape.                                                                                                                                                                                                                                                                              | `buildCuaFanoutBundle` in `src/routes/computer-use/fanout-bundle.ts`; `judgeComputerUseRun` in `src/routes/computer-use/bundle.ts`                                                                                                                                                                                                                                                                          |
 | route               | The execution path for a study: `computer-use`, `shared-world`, `scripted`, `terminal` or `preview`. `preview` writes a dry-run bundle for `this-repo` subjects with no live participant.                                                                                                                                                                                                                                                                                                                                             | `routeOf` and `StudyRoute` in `src/study/plan.ts`; predicates in `src/study/routing.ts`; one folder or file per route in `src/routes/`                                                                                                                                                                                                                                                                      |
-| plan                | What `planStudy` decides about a study before anything runs: the study id, whether it is a dry run, the analysis settings and the keys, connections and env vars the run needs, plus the route's participants, caps and own fields. There is one variant per route. `planStudy` returns a plan, or a refusal with the route's error code, and the route's run function (`runComputerUsePlan` and the others) takes the plan.                                                                                                          | `StudyPlan` in `src/study/plan-types.ts`; `planStudy` in `src/study/plan.ts`; each route's planner in its `plan.ts`                                                                                                                                                                                                                                                                                         |
+| plan                | What `planStudy` decides about a study before anything runs: the study id, whether it is a dry run, the analysis settings and the keys, connections and env vars the run needs, plus the route's participants, caps and own fields. There is one variant per route. `planStudy` returns a plan, or a refusal with the route's error code, and the route's admit function (`admitComputerUsePlan` and the others) takes the plan.                                                                                                      | `StudyPlan` in `src/study/plan-types.ts`; `planStudy` in `src/study/plan.ts`; each route's planner in its `plan.ts`                                                                                                                                                                                                                                                                                         |
 | substrate           | Where a participant's desktop or shell runs: a hosted E2B sandbox, or a local Firecracker VM (inside Lima on macOS).                                                                                                                                                                                                                                                                                                                                                                                                                  | `src/substrates/e2b/`, `src/substrates/local/`                                                                                                                                                                                                                                                                                                                                                              |
 | participant desktop | The desktop one computer-use or shared-world participant drives: a substrate plus the route's concerns, such as subject provisioning, comms and the participant's plan. It lives in the route, so `src/substrates/` holds only provider primitives ([ADR 0004](docs/decisions/0004-participant-desktops-stay-in-the-route.md)).                                                                                                                                                                                                       | `ParticipantDesktop` in `src/routes/computer-use/participant-desktop.ts`; `createE2BParticipantDesktop` in `src/routes/computer-use/e2b-desktop/desktop.ts`; the local VM's in `src/routes/computer-use/local-vm.ts`                                                                                                                                                                                        |
 | receipt             | A line in a run's `sandbox-receipts.ndjson` that records a sandbox's id, provider, the participant or subject it belongs to (`laneId`), and its time limit as soon as the sandbox is created, before any work runs in it. `humanish reclaim` kills sandboxes by these ids after an interrupted run.                                                                                                                                                                                                                                   | `SandboxReceipt` in `src/run/sandbox-receipts.ts`; `reclaimRunSandboxes` in `src/run/reclaim.ts`                                                                                                                                                                                                                                                                                                            |

package/dist/actors/computer-use/actor.js

@@ -63,7 +63,7 @@ export async function runCuaActorSession(options) {
 }
 function defaultProvider(openai, strictSpend = false) {
     if (!openai) {
-        throw new Error("runCuaActorSession requires either `provider` (injected) or `openai` provider options.");
+        throw new Error("A computer-use session requires either `provider` (injected) or `openai` provider options.");
     }
     return createOpenAiResponsesProvider({
         ...openai,
@@ -72,7 +72,7 @@ function defaultProvider(openai, strictSpend = false) {
 }
 function defaultExecutor(desktop, executorOptions) {
     if (!desktop) {
-        throw new Error("runCuaActorSession requires either `executor` (injected) or `desktop` to build one.");
+        throw new Error("A computer-use session requires either `executor` (injected) or `desktop` to build one.");
     }
     return createE2BDesktopExecutor(desktop, executorOptions ?? {});
 }

package/dist/actors/computer-use/loop/ending.js

@@ -96,7 +96,7 @@ export function spendLimit(session, estimate, maxUsd) {
 // trip.
 export const nonFiniteEstimate = {
     completionReason: "harness_error",
-    reason: "the injected estimateTurnCostUsd returned a non-finite estimate while caps.maxUsd is set; the estimator receives one ActorTokenUsage object. Failing closed instead of running uncapped.",
+    reason: "the injected estimateTurnCostUsd returned a non-finite estimate while caps.maxUsd is set; the estimator receives one object with the running token totals. Failing closed instead of running uncapped.",
 };
 /** A study-level stop is a recruiting decision hitting its limit, not this participant's runaway. */
 export function runSpendLimit(reason) {

package/dist/actors/registry.js

@@ -74,7 +74,7 @@ export const actorRegistry = {
     },
     // The ActorId names the terminal-product dispatch slot; the live route records the concrete
     // provider as "codex". keyPlacement "in-sandbox-command-scoped" is registry-declared and
-    // enforced by runTerminalProductStudy before it creates a sandbox, which is where this actor runs.
+    // enforced by the terminal route before it creates a sandbox, which is where this actor runs.
     "codex-exec": {
         id: "codex-exec",
         label: "Codex Exec (autonomous terminal agent, in-sandbox)",

package/dist/analysis/automatic-completion.js

@@ -25,6 +25,14 @@ export async function completeAutomaticAnalysis(result, finished, config, input,
             automaticAnalysis: { state: "skipped", reason: "AUTOMATIC_ANALYSIS_SOURCE_UNAVAILABLE" },
         };
     }
+    // A signal is stopping this process: the run is recorded interrupted, and the process exits
+    // once its sandboxes are reclaimed, so no analysis starts.
+    if (finished.interrupted)
+        return {
+            ...result,
+            ...origin,
+            automaticAnalysis: { state: "skipped", reason: "AUTOMATIC_ANALYSIS_ACTOR_CANCELLED" },
+        };
     const prepared = finished.paths;
     const seams = input?.deps?.analysis;
     const signal = input?.analysisSignal;

package/dist/cli/commands/observe.js

@@ -164,8 +164,6 @@ async function serveObserveUntilSignal(io, server, options) {
     // Keep the JSON envelope on stdout clean: route attach/stop chatter to stderr
     // for machine output, and to stdout for humans.
     const note = options.json ? io.writeErr : io.writeOut;
-    note(`serving: ${server.url}\n`);
-    note("serving: press Ctrl-C to stop\n");
     await new Promise((resolveWait) => {
         const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
         const handlers = new Map();
@@ -195,6 +193,9 @@ async function serveObserveUntilSignal(io, server, options) {
             handlers.set(signal, handler);
             process.once(signal, handler);
         }
+        // The prompt follows the handlers, as in followObserver.
+        note(`serving: ${server.url}\n`);
+        note("serving: press Ctrl-C to stop\n");
     });
 }
 async function handleServe(io, options, command) {

package/dist/cli/commands/study-run.js

@@ -94,7 +94,7 @@ export async function runStudyCommand(args) {
     // checks (keys, runtime auth, subject env, the local agent, caps) refuse this machine, all before
     // the scorer loads, so none imports the scorer's host code. The scripted route's checks and the
     // run-id claim still come after it; the scripted route takes no scorer.
-    const routeRun = routeRunFor(route, { ...args, config });
+    const routeRun = ROUTE_RUNS[route]({ ...args, config });
     if (routeRun === undefined)
         return;
     // Every route's runStudyWith options carry the study's provenance, from here only.
@@ -155,24 +155,14 @@ function announcedKeyNames(config, options) {
     const planned = planStudy(config, { cwd: options.cwd, dryRun: false });
     return planned.ok ? keyNamesOf(planned.planned.plan) : undefined;
 }
-/** The route's CLI setup. Undefined when the setup has already written its own result. */
-function routeRunFor(route, args) {
-    switch (route) {
-        case "preview":
-            return previewRouteRun(args);
-        case "computer-use":
-            return computerUseRouteRun(args);
-        case "scripted":
-            return scriptedRouteRun(args);
-        case "terminal":
-            return terminalRouteRun(args);
-        case "shared-world":
-            return sharedWorldRouteRun(args);
-        default:
-            // Compile-time exhaustiveness: a future route must be handled here, not silently no-op.
-            throw new Error(`Unhandled study route: ${String(route)}`);
-    }
-}
+/** Each route's CLI setup. It returns undefined when it has already written its own result. */
+const ROUTE_RUNS = {
+    preview: previewRouteRun,
+    "computer-use": computerUseRouteRun,
+    scripted: scriptedRouteRun,
+    terminal: terminalRouteRun,
+    "shared-world": sharedWorldRouteRun,
+};
 function studyRerunFlagsRequested(options) {
     return options.rerunFailedFrom !== undefined || options.participants !== undefined;
 }

package/dist/cli/findings.d.ts

@@ -75,6 +75,11 @@ interface FindingsSource {
     loaded: LoadedAnalysis;
     /** ` --cwd <dir>` when the commands this view names need it, or "". */
     cwdFlag: string;
+    /**
+     * The project-relative path of the run's study file when that file sets `review.analysis:
+     * false`, read when the view is built. Undefined when it does not, or cannot be read.
+     */
+    analysisOffIn?: string;
 }
 /** The findings view of a run's selected analysis, or why it has none. */
 export declare function analysisFindings(source: FindingsSource): AnalysisFindings;

package/dist/cli/findings.js

@@ -7,6 +7,8 @@ import { loadAnalysis } from "../analysis/load.js";
 import { projectShareCheckedAnalysis } from "../analysis/sharing.js";
 import { loadRunBundlePrepared, resolveRunPath } from "../run/locate.js";
 import { resolvePhysicalCwd, runIdOf } from "../run/paths.js";
+import { studyProvenanceOf } from "../run/study-provenance.js";
+import { resolveStudyManifest } from "../study/discover.js";
 import { plural } from "../run/text.js";
 import { shellQuote } from "../substrates/shell.js";
 import { analysisOutcomeText, wantsJson } from "./io.js";
@@ -151,8 +153,23 @@ export function analysisFindings(source) {
     }
     if (job !== undefined || loaded.state === "invalid")
         return withoutFindings(source, "unavailable", job?.reason ?? loaded.warnings[0] ?? null, "This run's analysis records could not be read or checked, so no findings are shown.", cli(`analyze list --run ${source.runId}${source.cwdFlag}`));
+    if (source.analysisOffIn !== undefined)
+        return withoutFindings(source, "skipped", "AUTOMATIC_ANALYSIS_DISABLED", `Analysis is turned off in this run's study (review.analysis: false in ${source.analysisOffIn}), so none ran after the run. To analyze this run anyway, run the next command.`, analyzeCommand(source, undefined));
     return withoutFindings(source, "none", null, "No analysis has run for this run.", analyzeCommand(source, undefined));
 }
+/**
+ * The run's study file, project-relative, when it still names the same study and sets
+ * `review.analysis: false`. A study that turns analysis off leaves no analysis record, so the file
+ * is the only place that says why a live run has none.
+ */
+async function studyAnalysisOff(cwd, study) {
+    if (study?.path === undefined)
+        return undefined;
+    const resolved = await resolveStudyManifest(cwd, study.path).catch(() => null);
+    if (!resolved?.ok || resolved.config.id !== study.id)
+        return undefined;
+    return resolved.config.review?.analysis === false ? study.path : undefined;
+}
 /**
  * The run's bundle mode and its selected analysis: `analysisId`, or the version `analyze show`
  * defaults to. Null when the run is missing or its storage is unsafe.
@@ -163,12 +180,16 @@ export async function readRunAnalysis(cwd, run, analysisId) {
     if (!prepared)
         return null;
     const bundle = await loadRunBundlePrepared(physical, prepared).catch(() => null);
+    const analysisOffIn = bundle?.bundle.mode === "live"
+        ? await studyAnalysisOff(physical, studyProvenanceOf(bundle.bundle))
+        : undefined;
     return {
         runId: runIdOf(prepared),
         mode: bundle?.bundle.mode,
         runRoot: prepared.relativeRunRoot,
         loaded: await loadAnalysis(prepared, analysisId),
         cwdFlag: cwdFlag(cwd),
+        ...(analysisOffIn === undefined ? {} : { analysisOffIn }),
     };
 }
 /** The view of a run that could not be found. */

package/dist/cli/io.d.ts

@@ -17,7 +17,8 @@ export declare const DOTENV_OPTION_DESCRIPTION = "Load unset variables from this
 /**
  * The hidden `--env-file <path>` that `--dotenv` replaced. Node scans the whole argv for
  * `--env-file` before a script runs, and stops only at `--` (src/node_dotenv.cc), so a missing file
- * exits 9 through Node and never reaches humanish. `--dotenv` does not collide. Removed in 0.111.0.
+ * exits 9 through Node and never reaches humanish. `--dotenv` does not collide.
+ * Removed in 0.112.0: deprecated in 0.110.0 on 2026-10-03, it stays 30 days and one minor release.
  */
 export declare function envFileAliasOption(): Option;
 /** The dotenv path a command was given: `--dotenv`, or the `--env-file` alias with its warning. */

package/dist/cli/io.js

@@ -15,11 +15,12 @@ export const JSON_OPTION_DESCRIPTION = "Print a machine-readable JSON response."
 export const CWD_OPTION_DESCRIPTION = "Project directory.";
 export const RUN_OPTION_DESCRIPTION = "Run id, or latest.";
 export const DOTENV_OPTION_DESCRIPTION = "Load unset variables from this dotenv file. Values are never printed or saved.";
-const ENV_FILE_RENAMED = "`--env-file` is now `--dotenv`; `--env-file` is removed in 0.111.0.";
+const ENV_FILE_RENAMED = "`--env-file` is now `--dotenv`; `--env-file` is removed in 0.112.0.";
 /**
  * The hidden `--env-file <path>` that `--dotenv` replaced. Node scans the whole argv for
  * `--env-file` before a script runs, and stops only at `--` (src/node_dotenv.cc), so a missing file
- * exits 9 through Node and never reaches humanish. `--dotenv` does not collide. Removed in 0.111.0.
+ * exits 9 through Node and never reaches humanish. `--dotenv` does not collide.
+ * Removed in 0.112.0: deprecated in 0.110.0 on 2026-10-03, it stays 30 days and one minor release.
  */
 export function envFileAliasOption() {
     return new Option("--env-file <path>").hideHelp().conflicts("dotenv");

package/dist/cli/observer-follow.d.ts

@@ -26,8 +26,12 @@ export declare function followDecision(args: {
     follow: boolean;
     unattended: boolean;
 };
-/** The warning a command adds when it printed the Observer and exited because nobody was attached. */
-export declare function unattendedObserverWarning(command: "watch" | "observe"): string;
+/**
+ * The warning a command adds when it printed the Observer and exited because nobody was attached.
+ * It names the reason personAtTerminal found: an agent runner's marker, which can sit beside a real
+ * terminal, or no terminal at all.
+ */
+export declare function unattendedObserverWarning(command: "watch" | "observe", env?: NodeJS.ProcessEnv): string;
 /**
  * Parse --port and decide open and follow. On an invalid port it writes the failure, sets exit
  * code 2 and returns null, so a caller refuses before starting a run.

package/dist/cli/observer-follow.js

@@ -23,9 +23,17 @@ export function followDecision(args) {
     const attended = personAtTerminal();
     return { follow: attended, unattended: !attended };
 }
-/** The warning a command adds when it printed the Observer and exited because nobody was attached. */
-export function unattendedObserverWarning(command) {
-    return `No interactive terminal, so ${command} printed the Observer path and exited instead of serving it until Ctrl-C. Open the file, or pass --serve to keep serving.`;
+/**
+ * The warning a command adds when it printed the Observer and exited because nobody was attached.
+ * It names the reason personAtTerminal found: an agent runner's marker, which can sit beside a real
+ * terminal, or no terminal at all.
+ */
+export function unattendedObserverWarning(command, env = process.env) {
+    const agent = detectAgentSession(env);
+    const reason = agent === undefined
+        ? "No interactive terminal"
+        : `An agent environment was detected (${agent.marker} is set, which ${agent.runner} sets)`;
+    return `${reason}, so ${command} printed the Observer path and exited instead of serving it until Ctrl-C. Pass --serve to keep serving, or open the file.`;
 }
 /**
  * Parse --port and decide open and follow. On an invalid port it writes the failure, sets exit
@@ -112,8 +120,6 @@ export function formatObserverHuman(result) {
     ].join("\n") + "\n");
 }
 export async function followObserver(io, result, server, options = {}) {
-    io.writeOut(`watching: ${result.serverUrl ?? result.observerUrl ?? result.observerPath}\n`);
-    io.writeOut("watching: press Ctrl-C to stop\n");
     await new Promise((resolve) => {
         const signalTarget = options.signalTarget ?? process;
         const signals = options.signals ?? ["SIGINT", "SIGTERM", "SIGHUP"];
@@ -155,6 +161,10 @@ export async function followObserver(io, result, server, options = {}) {
             handlers.set(signal, handler);
             signalTarget.once(signal, handler);
         }
+        // Print the prompt only once the handlers are in place: a Ctrl-C that arrives sooner would
+        // take Node's default action and end the process without closing the server.
+        io.writeOut(`watching: ${result.serverUrl ?? result.observerUrl ?? result.observerPath}\n`);
+        io.writeOut("watching: press Ctrl-C to stop\n");
     });
 }
 export function exitCodeForSignal(signal) {

package/dist/evidence/redaction.js

@@ -58,6 +58,16 @@ const CREDENTIAL_PARAMETER = [
 // Upper-case variable names that hold a credential, as an env file, a shell or a JSON dump writes
 // them: GITHUB_TOKEN, VERCEL_TOKEN, AWS_SECRET_ACCESS_KEY, DATABASE_PASSWORD.
 const CREDENTIAL_VARIABLE = String.raw `\b(?:[A-Z][A-Z0-9_]{0,48}_)?(?:TOKEN|SECRET|SECRET_KEY|PASSWORD|PASSWD|API_KEY|APIKEY|ACCESS_KEY|PRIVATE_KEY)`;
+// The public E2B pages its errors link to, which name no sandbox and carry no credential: the
+// dashboard as the SDK's missing-key error names it (https://e2b.dev/dashboard?tab=keys), with no
+// path below /dashboard and no query but one short `tab`, and a docs page as the API's 401 names
+// it (https://docs.e2b.dev/api-key), whose path segments hold only letters and hyphens and which
+// has no query. Neither has user info, and only closing punctuation, ")" included, may follow
+// before the next space or the end of the text.
+const E2B_PUBLIC_PAGE = [
+    String.raw `(?:www\.)?e2b\.dev\/dashboard\/?(?:\?tab=[a-z]{1,16})?`,
+    String.raw `(?:docs\.e2b\.dev|(?:www\.)?e2b\.dev\/docs)(?:\/[a-z][a-z-]{0,39}){0,8}\/?`,
+].join("|");
 // A pattern that matches a credential by its context puts the context in a `keep` group, which
 // redaction leaves in place: `?token=[REDACTED_SECRET]`. Context goes in a group and not in a
 // lookbehind, because a pattern that starts with a lookbehind is tried at every position of the
@@ -106,10 +116,11 @@ const SECRET_PATTERNS = [
     // bounded, so a long run of `TOKEN=` costs linear time.
     new RegExp(String.raw `(?<keep>${CREDENTIAL_VARIABLE}${QUOTE}[ \t]{0,4}[:=][ \t]{0,4}${QUOTE})${notAPlaceholder(VARIABLE_END)}${NOT_A_NUMBER}(?=[^\s"'\\,;&]{0,255}[0-9])(?=[^\s"'\\,;&]{0,255}[A-Za-z])[^\s"'\\,;&]{16}[^\s"'\\,;&]*`, "g"),
     // Any URL on an E2B host: a sandbox host names its sandbox, and a stream URL carries its auth
-    // key. One URL is exempt: E2B's dashboard, as the SDK's missing-key error names it
-    // (https://e2b.dev/dashboard?tab=keys), with no userinfo, no path below /dashboard, no query but
-    // one short `tab`, and only closing punctuation before the next space or ")".
-    /(?!https:\/\/(?:www\.)?e2b\.dev\/dashboard\/?(?:\?tab=[a-z]{1,16})?[.,;:!?'"]*(?:[)\s]|$))https?:\/\/[^/\s]*e2b[^)\s]+/gi,
+    // key. The slashes may be JSON-escaped (`https:\/\/`). User info runs to its last `@`, as a URL
+    // parser reads it, and may hold any character but a slash or space. The host part stops at a
+    // backslash, quote or angle bracket, so a URL followed by an escaped line break and an `E2B_...`
+    // variable in JSON text is not read as an E2B host. A public page followed by `)@` is user info.
+    new RegExp(String.raw `(?!https:\/\/(?:${E2B_PUBLIC_PAGE})[.,;:!?'")]*(?:\s|$))https?:\\?\/\\?\/(?:[^/\s@]*@)*[^/\s\\"'<>@]*e2b[^)\s]+`, "gi"),
     /BEGIN (RSA|OPENSSH|PRIVATE) KEY/gi,
 ];
 const LOCAL_PATH_PATTERNS = [

package/dist/routes/computer-use/participant-runs.d.ts

@@ -3,7 +3,7 @@ import { type StudyConfig } from "../../study/types.js";
 import { type ResolvedPersona } from "../../study/persona.js";
 import { type RunRerunLineage } from "../../run/bundle.js";
 import type { PreparedSelectedOutputDirectory } from "../../run/contained-output.js";
-import { type CuaActorStudyErrorCode, type CuaParticipantPlan, type CuaParticipantPlanEntry, type DesktopParticipantRun } from "./types.js";
+import { type CuaActorStudyErrorCode, type CuaParticipantPlan, type CuaParticipantPlanEntry, type DesktopParticipantRun, type ParticipantRunsAndPlan } from "./types.js";
 export declare function defaultSessionTimeoutMs(config: StudyConfig): number;
 /** Per-participant sandbox deadline (each one owns its own desktop). Mirrors the
  *  single-participant formula verbatim so N=1 stays byte-stable: explicit sandboxTimeoutMs, else session budget + (clone
@@ -21,17 +21,14 @@ export declare function resolveParticipantSandboxMs(config: StudyConfig): number
  */
 export declare function boundedConcurrency(declared: number | undefined, participantCount: number): number;
 /**
- * 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,
- * marked $0 (dryRun: true).
+ * Build the participant runs and the public plan from a computer-use plan (pure). The same plan
+ * appears in dry-run and live, marked $0 for a dry run. `env` may lower the planned concurrency;
+ * `personas` are the compiled committed personas the prompts carry.
  */
-export declare function resolveCuaParticipantPlan(config: StudyConfig, opts?: {
-    countOverride?: number;
+export declare function participantRunsAndPlan(plan: ComputerUsePlan, opts?: {
     env?: Record<string, string | undefined>;
-    dryRun?: boolean;
     personas?: Map<string, ResolvedPersona>;
-}): CuaParticipantPlan;
+}): ParticipantRunsAndPlan;
 /** 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 declare function emitPreflightPlan(participantPlan: CuaParticipantPlan, studyId: string): void;

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

@@ -4,7 +4,6 @@
 // compiles the committed personas first and narrows a rerun to its selected participants.
 import { isLocalBrowserStudy, LOCAL_BROWSER_LIFETIME_MS, } from "../../substrates/local/runtime-config.js";
 import { DEFAULT_STATE_STEP_TIMEOUT_MS } from "../../subject/state.js";
-import { computerUseParticipants, } from "../../study/plan-participants.js";
 import { resolveParticipant } from "../../run/participant.js";
 import {} from "../../study/types.js";
 import { scrubPersonaBrief } from "../../study/persona.js";
@@ -71,23 +70,17 @@ function envLoweredConcurrency(planned, participantCount, env) {
     }
     return { bound: planned };
 }
-/** The same inputs from a config, for callers that have no plan. */
-function plannedParticipantsOf(config, countOverride) {
-    const participants = computerUseParticipants(config, countOverride);
-    return {
-        participants,
-        concurrency: boundedConcurrency(config.execution?.concurrency, participants.length),
-        sessionBudgetMs: config.execution?.timeoutMs ?? defaultSessionTimeoutMs(config),
-        sandboxMs: resolveParticipantSandboxMs(config),
-        desktopCli: config.subject.source === "desktop-cli",
-    };
-}
-/** Build the participant runs and the public plan from the planned participants (pure). */
-function participantRunsAndPlan(planned, opts = {}) {
+/**
+ * Build the participant runs and the public plan from a computer-use plan (pure). The same plan
+ * appears in dry-run and live, marked $0 for a dry run. `env` may lower the planned concurrency;
+ * `personas` are the compiled committed personas the prompts carry.
+ */
+export function participantRunsAndPlan(plan, opts = {}) {
     const env = opts.env ?? {};
     // Who each participant is (id, persona, focus, device, limits) comes from the plan; this adds
     // what the route derives from it: the prompt, bundle ids and artifact paths.
-    const { participants } = planned;
+    const { participants } = plan.runner;
+    const desktopCli = plan.runner.subject.kind === "desktop-cli";
     const participantCount = participants.length;
     const runs = participants.map((participant) => {
         const mission = participant.assignment.mission ?? DEFAULT_MISSION;
@@ -102,7 +95,7 @@ function participantRunsAndPlan(planned, opts = {}) {
             ...(resolvedPersona === undefined ? {} : { resolvedPersona }),
             ...(focus === undefined ? {} : { instruction: focus }),
             device: { name: device.name, preset: device.preset },
-            ...(planned.desktopCli ? { surface: "desktop-cli" } : {}),
+            ...(desktopCli ? { surface: "desktop-cli" } : {}),
         });
         const run = resolveParticipant(participant, {
             persona: composed.persona,
@@ -119,9 +112,9 @@ function participantRunsAndPlan(planned, opts = {}) {
             traceArtifactPath: participantCount === 1 ? "actor.json" : `actors/${run.streamId}.json`,
         };
     });
-    const resolved = envLoweredConcurrency(planned.concurrency, participantCount, env);
+    const resolved = envLoweredConcurrency(plan.concurrency, participantCount, env);
     const concurrency = resolved.bound;
-    const { sessionBudgetMs, sandboxMs } = planned;
+    const { sessionBudgetMs, sandboxMs } = plan;
     const participantPlan = {
         strategy: CUA_FANOUT_STRATEGY,
         laneCount: participantCount,
@@ -132,7 +125,7 @@ function participantRunsAndPlan(planned, opts = {}) {
         waves: Math.ceil(participantCount / concurrency),
         perLaneSessionBudgetMs: sessionBudgetMs,
         worstCaseSandboxMinutes: Math.round((participantCount * sandboxMs) / 60_000),
-        dryRun: opts.dryRun === true,
+        dryRun: plan.dryRun,
         lanes: runs.map((spec) => ({
             id: spec.planned.id,
             ...(spec.planned.labels.actorType === undefined
@@ -162,16 +155,6 @@ function participantRunsAndPlan(planned, opts = {}) {
     };
     return { runs, participantPlan };
 }
-/**
- * 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,
- * 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). */
 export function emitPreflightPlan(participantPlan, studyId) {
@@ -216,13 +199,10 @@ export async function loadCuaParticipants(args) {
     // 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,
-        concurrency: plan.concurrency,
-        sessionBudgetMs: plan.sessionBudgetMs,
-        sandboxMs: plan.sandboxMs,
-        desktopCli: plan.runner.subject.kind === "desktop-cli",
-    }, { env: args.env, dryRun: plan.dryRun, personas });
+    const { runs: participantRuns, participantPlan } = participantRunsAndPlan(plan, {
+        env: args.env,
+        personas,
+    });
     const rerun = plan.rerun;
     if (!rerun)
         return { ok: true, participantRuns, participantPlan };

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

@@ -1,7 +1,7 @@
 import { type CuaActorDescriptor } from "../../actors/registry.js";
 import type { ComputerUsePlan, ComputerUseRunner, RoutePlanResult, RouteRefusal } from "../../study/plan-types.js";
 import type { StudyConfig, StudySubjectState } from "../../study/types.js";
-import { type CuaActorStudyErrorCode, type RunCuaActorStudyOptions } from "./types.js";
+import { type ComputerUseRunInput, type CuaActorStudyErrorCode } from "./types.js";
 /** The error a computer-use study returns before a run starts. */
 export interface ComputerUseRefusal extends RouteRefusal<"computer-use", CuaActorStudyErrorCode> {
     /**
@@ -44,5 +44,5 @@ export declare function planComputerUseStudy(config: StudyConfig, input: {
     /** Which of the caller's driving homes are set; neither when absent. */
     readonly driving?: CallerDriving;
     readonly countOverride?: number;
-    readonly rerun?: RunCuaActorStudyOptions["rerun"];
+    readonly rerun?: ComputerUseRunInput["rerun"];
 }): ComputerUsePlanResult;

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

@@ -232,7 +232,7 @@ export function planComputerUseStudy(config, input) {
     // participants. It comes after the rules above, so a shared-world config that breaks one of them,
     // which runStudyWith sends here, still gets that rule's message.
     if (config.subject.topology === "shared-world")
-        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "route: shared-world studies run every participant against one shared app on the shared-world route; this route runs independent participants. Run the study with runStudy or runConcurrentSharedWorld.", actor);
+        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "route: shared-world studies run every participant against one shared app on the shared-world route; this route runs independent participants. The shared-world route takes subject.source clone or local-tree, or app-url with policies.allowPublicTargets: true, on execution.target e2b-desktop.", 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 study declares.
     const source = config.subject.source;

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

@@ -1,33 +1,20 @@
+import { type RefusedStudy } from "../../run/route-shell.js";
 import type { ComputerUsePlan } from "../../study/plan-types.js";
 import type { AdmittedPlan } from "../../run-study.js";
 import type { StudyConfig } from "../../study/types.js";
 import { type ComputerUseRefusal } from "./plan.js";
-import { type ComputerUseRunInput, type CuaActorStudyResult, type RunCuaActorStudyOptions } from "./types.js";
-/**
- * Plans and runs a computer-use study in one call. It is not exported from src/index.ts; tests call
- * it. It plans the config with planComputerUseStudy and runs
- * the plan with runComputerUsePlan, whose run scope and withTransientCommsSecrets wrapper cover the
- * run and its analysis.
- */
-export declare function runCuaActorStudy(options: RunCuaActorStudyOptions): Promise<CuaActorStudyResult>;
+import { type ComputerUseRunInput, type CuaActorStudyResult } from "./types.js";
 /**
  * A refused computer-use study'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 participant cap after
  * the personas are read.
  */
-export declare function computerUseStudyRefusal(options: RunCuaActorStudyOptions, refusal: ComputerUseRefusal): Promise<CuaActorStudyResult>;
+export declare function computerUseStudyRefusal(options: ComputerUseRunInput & RefusedStudy, refusal: ComputerUseRefusal): Promise<CuaActorStudyResult>;
 /**
  * runStudyWith's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
  * participants, the preflight plan, the keys, the local agent, subject env and caps, and the
  * local-tree archive) before any run scope opens, so the CLI can present their refusal before it
- * loads a declared scorer, and returns the run that continues from them with that scorer.
+ * loads a declared scorer, and returns the run that continues from them with that scorer. The
+ * run and its analysis share one scope for the email secrets it registers.
  */
 export declare function admitComputerUsePlan(plan: ComputerUsePlan, input: ComputerUseRunInput, config: StudyConfig): Promise<AdmittedPlan<"computer-use">>;
-/**
- * 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, 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: StudyConfig): Promise<CuaActorStudyResult>;