humanish 0.111.2 → 0.111.3

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

@@ -1,19 +1,18 @@
 // The computer-use run's setup: resolve the project and route, plan the participants, make the
 // live checks that need no sandbox, pack a local tree, then start the run and build the
 // participant deps and bundle base that the participants and the finish share.
-import { randomBytes } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import path from "node:path";
 import {} from "../../run/run.js";
 import { externalInboxUrl } from "../../comms/sandbox-catch.js";
-import { redactText, scrubLiterals, toErrorMessage } from "../../evidence/redaction.js";
-import { buildRunSource } from "../../run/bundle.js";
+import { redactText, toErrorMessage } from "../../evidence/redaction.js";
+import { RunSecrets } from "../../run/secrets.js";
+import {} from "../../run/bundle.js";
 import { assertPreparedSelectedOutputDirectory, prepareContainedOutputDirectory, prepareSelectedOutputDirectory, } from "../../run/contained-output.js";
 import {} from "../../subject/local-tree-archive.js";
 import { renderCuaReviewMarkdown } from "./bundle.js";
 import { emitPreflightPlan, compileParticipantPersonas, loadCuaParticipants, sanitizeParticipantRuns, } from "./participant-runs.js";
-import { makeCuaRunBudget } from "./participant-model.js";
-import { e2bRequestTimeoutMs } from "../../substrates/e2b/lifetime.js";
+import { desktopParticipantDeps } from "./participant-deps.js";
 import { liveCuaRejection } from "./preflight.js";
 import { cuaDescriptorOf, declaredAppUrl, plannedAppUrl } from "./plan.js";
 import { trackRuntimeStreams } from "./live-flush.js";
@@ -24,7 +23,7 @@ import { packRunLocalTree } from "./local-tree-pack.js";
 import { projectParticipantSubjects, subjectProvenanceArg } from "./subject-projection.js";
 import { participantSubjectEnv, } from "./types.js";
 import { studyPersonaIds } from "../../study/persona-resolve.js";
-import { studyResultIdentity } from "../../run/study-result.js";
+import { refusedResult } from "../../run/study-result.js";
 /** The physical project, bound before any caller hook runs. */
 async function bindProject(cwd) {
     // Capture the physical project before reading or invoking any caller hook. A supported
@@ -43,18 +42,17 @@ export async function refuseCuaStudy(options, refusal) {
     // The committed personas are read before the refusal returns, so a persona-file error wins.
     if (refusal.stage === "after-personas")
         await compileParticipantPersonas(projectRoot, studyPersonaIds(config));
-    return {
-        ...studyResultIdentity("computer-use", config.id),
-        ok: false,
+    return refusedResult("computer-use", {
+        studyId: config.id,
         cwd: projectRoot.physicalPath,
+        error: { code: refusal.code, message: refusal.message },
+    }, {
         actor: refusal.actor ?? config.actor?.type ?? "",
         appUrl: declaredAppUrl(config),
         dryRun,
         runId: options.runId ?? "not-created",
         lanes: [],
-        warnings: [],
-        error: { code: refusal.code, message: refusal.message },
-    };
+    });
 }
 /**
  * Everything before the run starts: the physical project, the route, the participant plan and
@@ -73,17 +71,12 @@ export async function admitCuaRun(plan, input, config) {
     const inProcess = desktop === "in-process";
     const appUrl = plannedAppUrl(subject);
     const subjectEnvNames = [...participantSubjectEnv(subject)];
-    const fail = (code, message, actorLabel) => ({
-        ...studyResultIdentity("computer-use", plan.studyId),
-        ok: false,
-        cwd,
+    const fail = (code, message, actorLabel) => refusedResult("computer-use", { studyId: plan.studyId, cwd, error: { code, message } }, {
         actor: actorLabel ?? plan.actor,
         appUrl,
         dryRun,
         runId: input.runId ?? "not-created",
         lanes: [],
-        warnings: [],
-        error: { code, message },
     });
     const refuse = (...args) => ({
         ok: false,
@@ -131,13 +124,13 @@ export async function admitCuaRun(plan, input, config) {
     const openaiApiKey = env.OPENAI_API_KEY?.trim() ?? "";
     const e2bApiKey = env.E2B_API_KEY?.trim() ?? "";
     // Literal scrubber for every known provisioned value (no secret "shape" to pattern-match).
-    const knownSecretValues = [
+    // Dry and in-process runs scrub both keys too: a mission or persona can still quote them.
+    const secrets = new RunSecrets([
         openaiApiKey,
         e2bApiKey,
         ...subjectEnvNames.map((name) => env[name] ?? ""),
-    ].filter((value) => value.length >= 4);
-    const scrubKnownValues = scrubLiterals(knownSecretValues);
-    sanitizeParticipantRuns(participantRuns, scrubKnownValues);
+    ]);
+    sanitizeParticipantRuns(participantRuns, secrets.scrub);
     const redactRepoLabel = plan.residual.policies?.redactRepos ?? subjectEnvNames.includes("GITHUB_TOKEN");
     const publicRepo = subject.kind === "clone" ? (redactRepoLabel ? "repo-01" : subject.repo) : undefined;
     // Key-gating is route-aware: the in-process route uses the caller's own model + executor, and
@@ -167,7 +160,7 @@ export async function admitCuaRun(plan, input, config) {
             localTreeArchiveBuffer = packed.buffer;
         }
         catch (error) {
-            return refuse("HUMANISH_COMPUTER_USE_SUBJECT_INVALID", `local-tree packing failed: ${redactText(scrubKnownValues(toErrorMessage(error)))}`, descriptor.id);
+            return refuse("HUMANISH_COMPUTER_USE_SUBJECT_INVALID", `local-tree packing failed: ${redactText(secrets.scrub(toErrorMessage(error)))}`, descriptor.id);
         }
     }
     return {
@@ -192,8 +185,7 @@ export async function admitCuaRun(plan, input, config) {
             participantCount,
             openaiApiKey,
             e2bApiKey,
-            knownSecretValues,
-            scrubKnownValues,
+            secrets,
             publicRepo,
             localTreeArchive,
             localTreeArchiveBuffer,
@@ -202,33 +194,23 @@ export async function admitCuaRun(plan, input, config) {
 }
 /** Starts the run and builds what the participants and the finish read: the deps and the bundle base. */
 export async function startCuaRun(plan, input, admitted, scope) {
-    const { dryRun, cwd, seams, descriptor, participantRuns, participantPlan, publicRepo } = admitted;
+    const { cwd, descriptor, participantRuns, participantPlan, publicRepo } = admitted;
     const { appUrl } = admitted;
     // The run's status record exists from here on, so anything watching the runs directory can
     // tell which study this is and that it is alive. The fail-closed returns below leave it finished
     // with no outcome when the scope closes; a crash leaves it stale, which reads as interrupted.
-    const started = await scope.startRun({
+    const started = await scope.startRun(plan, input, {
         cwd,
-        runId: input.runId,
-        mintRunId: makeCuaRunId,
-        mode: dryRun ? "dry-run" : "live",
-        study: plan.study,
-        warnings: plan.warnings,
+        prefix: "cua",
         renderReview: renderCuaReviewMarkdown,
-        observer: { open: input.open === true, render: seams.renderObserver },
+        secrets: admitted.secrets,
     });
     if (!started.ok)
         return admitted.refuse(started.code, started.message, descriptor.id);
     const { run } = started;
-    const { createdAt, paths: runPaths } = run;
+    const { paths: runPaths, source } = run;
     const redactScreenshots = plan.residual.policies?.redactScreenshots === true;
     await prepareContainedOutputDirectory(runPaths, "screenshots");
-    const source = await buildRunSource({
-        capturedAt: createdAt,
-        cwd,
-        humanishSource: "present",
-        packageName: "humanish",
-    });
     // Live-trace flush seam: runStudyParticipants fills it when a live run has an in-progress bundle
     // to grow; participants call it through deps.onTrace. It exists before deps so deps can reference it as
     // a stable indirection.
@@ -279,12 +261,10 @@ export async function startCuaRun(plan, input, admitted, scope) {
             streams: admitted.streams,
             participantRuns,
             participantPlan,
-            scrubKnownValues: admitted.scrubKnownValues,
             bundleBase,
         },
         participants: {
             env: admitted.env,
-            knownSecretValues: admitted.knownSecretValues,
             deps,
             liveTrace,
             externalComms: externalCommsConfig === undefined || externalCommsEmail === undefined
@@ -300,60 +280,38 @@ export async function startCuaRun(plan, input, admitted, scope) {
         finish: { rerunLineage: admitted.rerunLineage, publicRepo, subjectArgs },
     };
 }
-/** The participant deps every participant reads: the route, keys, timeouts, scrubber, budget and seams. */
+/** The participant deps every participant reads, with computer use's own overrides. */
 function cuaParticipantDeps(plan, input, admitted, run) {
-    const { config, dryRun, seams, streams, env, runSession, participantCount } = admitted;
-    const { localTreeArchiveBuffer } = admitted;
-    const { openaiApiKey, e2bApiKey, scrubKnownValues } = admitted;
-    const { externalCommsConfig, externalCommsEmail } = admitted;
-    const { appUrl } = admitted;
-    const { runPaths, redactScreenshots, liveTrace } = run;
-    const createDesktop = input.localVm?.desktop;
-    const timeoutMs = plan.sessionBudgetMs;
-    const requestTimeoutMs = e2bRequestTimeoutMs(env);
-    return {
-        ...(createDesktop === undefined ? {} : { createDesktop }),
-        onTrace: (participantId, items, usage, metadata) => liveTrace.flush?.(participantId, items, usage, metadata),
-        ...callerDriving(input, config),
-        residual: plan.residual,
-        studyId: plan.studyId,
-        caps: plan.caps,
-        appUrl,
+    const { config, seams, env, externalCommsConfig, externalCommsEmail } = admitted;
+    const deps = desktopParticipantDeps({
+        plan,
         brain: plan.runner.brain,
         subject: plan.runner.subject,
-        ...(localTreeArchiveBuffer === undefined ? {} : { localTreeArchiveBuffer }),
         env,
-        openaiApiKey,
-        e2bApiKey,
-        requestTimeoutMs,
+        openaiApiKey: admitted.openaiApiKey,
+        e2bApiKey: admitted.e2bApiKey,
+        timeoutMs: plan.sessionBudgetMs,
         sandboxMs: plan.sandboxMs,
-        timeoutMs,
-        participantCount,
-        artifactRoot: runPaths,
+        participantCount: admitted.participantCount,
+        artifactRoot: run.runPaths,
         studyCwd: input.cwd,
-        redactScreenshots,
-        scrubKnownValues,
-        runSession,
-        // The study-level ledger exists once per run, shared by every participant. Dry runs never
-        // spend, so they carry none.
-        ...(dryRun || plan.caps.maxTotalUsd === undefined
-            ? {}
-            : { runBudget: makeCuaRunBudget(plan.caps.maxTotalUsd) }),
-        ...(externalCommsConfig === undefined || externalCommsEmail === undefined
-            ? {}
-            : {
-                externalComms: {
-                    email: externalCommsEmail,
-                    inboxUrl: externalInboxUrl(externalCommsConfig),
-                },
-            }),
-        now: seams.now ?? Date.now,
-        ...(seams.desktopModule === undefined ? {} : { desktopModule: seams.desktopModule }),
-        ...(input.prepareDesktop === undefined ? {} : { prepareDesktop: input.prepareDesktop }),
-        ...(seams.detachedTimers === undefined ? {} : { detachedTimers: seams.detachedTimers }),
-        onStream: streams.onStream,
+        redactScreenshots: run.redactScreenshots,
+        scrubKnownValues: admitted.secrets.scrub,
+        runSession: admitted.runSession,
+        liveFlush: () => run.liveTrace.flush,
+        onStream: admitted.streams.onStream,
         reportSubjectPhase: subjectPhaseReporter(input),
-    };
+        seams,
+        prepareDesktop: input.prepareDesktop,
+    }, {
+        createDesktop: input.localVm?.desktop,
+        ...callerDriving(input, config),
+        localTreeArchiveBuffer: admitted.localTreeArchiveBuffer,
+        externalComms: externalCommsConfig === undefined || externalCommsEmail === undefined
+            ? undefined
+            : { email: externalCommsEmail, inboxUrl: externalInboxUrl(externalCommsConfig) },
+    });
+    return { ...deps, appUrl: admitted.appUrl };
 }
 /** The caller's createProvider and inProcess executor, with the run's config bound. */
 function callerDriving(input, config) {
@@ -377,7 +335,3 @@ function subjectPhaseReporter(input) {
         input.emit?.(phaseEvent(event, { kind: "participant", participant }));
     };
 }
-function makeCuaRunId() {
-    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-    return `cua-${stamp}-${randomBytes(4).toString("hex")}`;
-}

package/dist/routes/computer-use/single-bundle.js

@@ -3,7 +3,8 @@ import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import {} from "../../run/streams.js";
 import { aggregateTaskFunnels, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
-import { describeSubjectState, participantFeedbackCandidates, phaseEventIdSuffix, publicSafeAppUrlLabel, subjectProvenanceMessage, } from "./bundle-parts.js";
+import { describeSubjectState, phaseEventIdSuffix, publicSafeAppUrlLabel, subjectProvenanceMessage, } from "./bundle-parts.js";
+import { participantFeedbackCandidates } from "./participant-feedback.js";
 import { participantStatus as participantStatusFor } from "../../run/judge.js";
 import { buildRunCostSummary } from "../../run/cost-summary.js";
 import { participantEvent, participantIds, participantRecord, participantStream, } from "../../run/participant-records.js";
@@ -359,13 +360,13 @@ export function buildSingleParticipantBundle(args) {
                 runId: args.run.runId,
                 scenarioId: `cua-${args.studyId}`,
                 adapterId: args.studyId,
-                goal: redactText(args.mission),
                 substrate: runnerSubstrate(args),
                 participants: [
                     {
                         participantId: args.participantId ?? "lane-01",
                         streamId: SINGLE.streamId,
                         personaId: args.persona.id,
+                        goal: redactText(args.mission),
                         ...(args.session === undefined ? {} : { session: args.session }),
                         ...(args.traceArtifactPath === undefined
                             ? {}

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

@@ -26,7 +26,7 @@ import { type RunDesktopGeometry } from "../../run/streams.js";
 import { type PreparedOutputRoot } from "../../run/contained-output.js";
 import type { ComputerUseParticipant, SharedWorldParticipant } from "../../study/plan-participants.js";
 import type { ResolvedParticipant } from "../../run/participant.js";
-import { type StudyResultIdentity } from "../../run/study-result.js";
+import { type StudyResultErrorCode, type StudyResultIdentity } from "../../run/study-result.js";
 export declare const CUA_FANOUT_STRATEGY: "per-lane-worlds";
 export declare const CUA_MAX_CONCURRENCY_ENV = "HUMANISH_CUA_MAX_CONCURRENCY";
 export declare const DEFAULT_APP_URL_SESSION_TIMEOUT_MS: number;
@@ -182,7 +182,7 @@ export interface CuaParticipantSummary {
     concurrency: number;
     waves: number;
 }
-export type CuaActorStudyErrorCode = "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_STUDY_INVALID" | "HUMANISH_COMPUTER_USE_FAILED" | "HUMANISH_COMPUTER_USE_KEYS_MISSING" | "HUMANISH_COMPUTER_USE_AGENT_MISSING" | "HUMANISH_COMPUTER_USE_AGENT_SIGNIN_REQUIRED" | "HUMANISH_COMPUTER_USE_SUBJECT_ENV_MISSING" | "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED" | "HUMANISH_COMPUTER_USE_SUBJECT_INVALID" | "HUMANISH_COMPUTER_USE_SUBJECT_UNSAFE" | "HUMANISH_COMPUTER_USE_EXECUTOR_NO_PROVIDER" | "HUMANISH_COMPUTER_USE_LOCAL_APP_NO_EXECUTOR" | "HUMANISH_COMPUTER_USE_LOCAL_DESKTOP_MISSING" | "HUMANISH_COMPUTER_USE_FANOUT_INVALID" | "HUMANISH_COMPUTER_USE_RERUN_INVALID" | "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY" | "HUMANISH_RUN_ID_IN_USE" | "HUMANISH_COMPUTER_USE_UNPRICED_CAP" | "HUMANISH_COMPUTER_USE_COMMS_CATCH_UNREACHABLE" | "HUMANISH_COMPUTER_USE_COMMS_TOKEN_INVALID" | "HUMANISH_WATCH_ALLOW_REQUIRES_OAUTH" | "HUMANISH_WATCH_OAUTH_REQUIRES_TUNNEL" | "HUMANISH_WATCH_OPTION_CONFLICT" | "HUMANISH_WATCH_TUNNEL_REQUIRES_EXPOSE" | "HUMANISH_WATCH_EXPOSE_REQUIRES_EDGE_AUTH" | "HUMANISH_WATCH_EXPOSE_REQUIRES_LIVE_FOLLOW" | "HUMANISH_WATCH_SAFE_NOT_APPLICABLE" | "HUMANISH_SERVE_TUNNEL_NOT_FOUND" | "HUMANISH_SERVE_TUNNEL_START_FAILED";
+export type CuaActorStudyErrorCode = StudyResultErrorCode | "HUMANISH_COMPUTER_USE_FAILED" | "HUMANISH_COMPUTER_USE_KEYS_MISSING" | "HUMANISH_COMPUTER_USE_AGENT_MISSING" | "HUMANISH_COMPUTER_USE_AGENT_SIGNIN_REQUIRED" | "HUMANISH_COMPUTER_USE_SUBJECT_ENV_MISSING" | "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED" | "HUMANISH_COMPUTER_USE_SUBJECT_INVALID" | "HUMANISH_COMPUTER_USE_SUBJECT_UNSAFE" | "HUMANISH_COMPUTER_USE_EXECUTOR_NO_PROVIDER" | "HUMANISH_COMPUTER_USE_LOCAL_APP_NO_EXECUTOR" | "HUMANISH_COMPUTER_USE_LOCAL_DESKTOP_MISSING" | "HUMANISH_COMPUTER_USE_FANOUT_INVALID" | "HUMANISH_COMPUTER_USE_RERUN_INVALID" | "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY" | "HUMANISH_COMPUTER_USE_UNPRICED_CAP" | "HUMANISH_COMPUTER_USE_COMMS_CATCH_UNREACHABLE" | "HUMANISH_COMPUTER_USE_COMMS_TOKEN_INVALID" | "HUMANISH_WATCH_ALLOW_REQUIRES_OAUTH" | "HUMANISH_WATCH_OAUTH_REQUIRES_TUNNEL" | "HUMANISH_WATCH_OPTION_CONFLICT" | "HUMANISH_WATCH_TUNNEL_REQUIRES_EXPOSE" | "HUMANISH_WATCH_EXPOSE_REQUIRES_EDGE_AUTH" | "HUMANISH_WATCH_EXPOSE_REQUIRES_LIVE_FOLLOW" | "HUMANISH_WATCH_SAFE_NOT_APPLICABLE" | "HUMANISH_SERVE_TUNNEL_NOT_FOUND" | "HUMANISH_SERVE_TUNNEL_START_FAILED";
 /** Subject provenance projection: what the actor actually drove. */
 export interface CuaSubjectProjection {
     source: "app-url" | "clone" | "local-tree";

package/dist/routes/preview.js

@@ -1,17 +1,11 @@
 // The preview route: a study whose subject is this repo runs the synthetic dry run. planStudy decides
 // the sim count and refuses what a synthetic run would ignore; runPreviewPlan does the rest.
-import { studyResultIdentity } from "../run/study-result.js";
+import { refusedResult, studyResultIdentity, } from "../run/study-result.js";
 import { runDryRun } from "../run/dry-run.js";
 import path from "node:path";
 /** A refused preview's result. */
 export function previewStudyRefusal(cwd, studyId, refusal) {
-    return {
-        ...studyResultIdentity("preview", studyId),
-        ok: false,
-        cwd: path.resolve(cwd),
-        warnings: [],
-        error: { code: refusal.code, message: refusal.message },
-    };
+    return refusedResult("preview", { studyId, cwd: path.resolve(cwd), error: { code: refusal.code, message: refusal.message } }, {});
 }
 /** runStudyWith's step for a preview plan: it has no local checks and takes no scorer, so it returns its run. */
 export function admitPreviewPlan(plan, input) {

package/dist/routes/scripted/bundle.d.ts

@@ -1,7 +1,7 @@
 import type { ActorPersonaRef } from "../../actors/contract.js";
 import type { ScriptedBrowserSessionResult } from "../../actors/scripted-browser/actor.js";
 import type { BrowserPersonaJourney, BrowserSurface } from "../../actors/scripted-browser/types.js";
-import type { DesktopResourceObservation } from "../../substrates/e2b/desktop-resources.js";
+import type { SubjectDesktopUsage } from "../../substrates/e2b/subject-sandbox.js";
 import { type ReviewSummary, type RunBundle, type RunSubjectProvenance, type BundleRun } from "../../run/bundle.js";
 /** What the scripted study's bundle is built from. */
 interface ScriptedBundleArgs {
@@ -24,11 +24,7 @@ interface ScriptedBundleArgs {
     source: RunBundle["source"];
     subject?: RunSubjectProvenance;
     /** The provisioned clone's desktop; absent when no sandbox was created. */
-    subjectDesktop?: {
-        durationMs: number | undefined;
-        observation: DesktopResourceObservation | undefined;
-        killed: boolean;
-    };
+    subjectDesktop?: SubjectDesktopUsage;
     surfaces: readonly BrowserSurface[];
     /** The run's verdict (judgeScripted). */
     verdict: ReviewSummary["verdict"];

package/dist/routes/scripted/result.d.ts

@@ -6,6 +6,7 @@ import type { RunBundle } from "../../run/bundle.js";
 import type { RunScope } from "../../run/run.js";
 import { type ExecutionFailure } from "../../run/judge.js";
 import type { ScriptedSubject } from "./subject.js";
+import type { E2BSubjectSandbox } from "../../substrates/e2b/subject-sandbox.js";
 import { type ScriptedBrowserStudyResult } from "./types.js";
 /** What the finish reads from the run. */
 export interface ScriptedFinishInputs {
@@ -44,6 +45,6 @@ export declare function scriptedExecutionFailures(args: {
     sessionError: string | undefined;
     expected: number;
     sessionResults: readonly Pick<ScriptedBrowserSessionResult, "completionReason" | "reason">[];
-    subject: Pick<ScriptedSubject, "sandboxId" | "killed" | "releaseWarning"> | undefined;
+    subject: Pick<E2BSubjectSandbox, "sandboxId" | "killed" | "releaseWarning"> | undefined;
 }): ExecutionFailure[];
 export declare function finishScriptedRun(inputs: ScriptedFinishInputs): Promise<ScriptedBrowserStudyResult>;

package/dist/routes/scripted/result.js

@@ -53,11 +53,11 @@ export async function finishScriptedRun(inputs) {
     const { actor, dryRun } = plan;
     const { runId, paths: runPaths } = run;
     const subjectCommit = scriptedSubject?.commit;
-    const subjectSandboxId = scriptedSubject?.sandboxId;
-    const subjectKilled = scriptedSubject?.killed ?? false;
+    const subjectSandboxId = scriptedSubject?.sandbox.sandboxId;
+    const subjectKilled = scriptedSubject?.sandbox.killed ?? false;
     const hostDigest = scriptedSubject?.hostDigest;
     const stateStepRecords = scriptedSubject?.stateStepRecords ?? [];
-    const subjectDesktop = scriptedSubject?.desktopUsage();
+    const subjectDesktop = scriptedSubject?.sandbox.desktopUsage();
     const screenshotsBySurface = new Map();
     for (const result of sessionResults) {
         screenshotsBySurface.set(result.capture.surface.id, await existingScreenshots(runPaths, result));
@@ -114,7 +114,7 @@ export async function finishScriptedRun(inputs) {
         sessionError,
         expected: surfaces.length,
         sessionResults,
-        subject: scriptedSubject,
+        subject: scriptedSubject?.sandbox,
     }), policy);
     const finished = await run.finish(bundle, {
         ok: resultOk({ judgment, execution, scorerFailures: [], policy }),

package/dist/routes/scripted/route.js

@@ -14,11 +14,9 @@
 // subject, so its build provenance is unpinned and the evidence binds to the scenario digest. A
 // clone run records commit, env names, state provenance and a host digest, never the raw getHost
 // URL or a secret value.
-import { randomBytes } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import path from "node:path";
 import { redactText, toErrorMessage } from "../../evidence/redaction.js";
-import { buildRunSource } from "../../run/bundle.js";
 import { prepareSelectedOutputDirectory } from "../../run/contained-output.js";
 import {} from "../../run/run.js";
 import { admitRoute, completeRefusalAnalysis } from "../../run/route-shell.js";
@@ -30,7 +28,7 @@ import { prepareScriptedRun } from "./setup.js";
 import { ScriptedSubject } from "./subject.js";
 import { runScriptedSessions, writeSurfaceTraces } from "./surface-sessions.js";
 import {} from "./types.js";
-import { studyResultIdentity } from "../../run/study-result.js";
+import { refusedResult } from "../../run/study-result.js";
 /**
  * A refused scripted study's result, at the refusal's stage: a before-scope refusal has its own field
  * order and no analysis record; the others come after the output directory checks.
@@ -39,34 +37,25 @@ export async function scriptedStudyRefusal(options, refusal) {
     const { config, dryRun } = options;
     const cwd = path.resolve(options.cwd);
     const actorType = config.actor?.type ?? "";
+    const error = { code: refusal.code, message: refusal.message };
     if (refusal.beforeScope)
-        return {
-            ...studyResultIdentity("scripted", config.id),
-            ok: false,
-            cwd,
+        return refusedResult("scripted", { studyId: config.id, cwd, error }, {
             actor: actorType,
             dryRun,
             runId: options.runId ?? "not-created",
             appUrl: config.subject.appUrl ?? "",
             sessions: [],
-            warnings: [],
-            error: { code: refusal.code, message: refusal.message },
-        };
+        });
     // The other refusals come after the output directory checks and carry the analysis record.
     const physicalCwd = await realpath(cwd);
     await prepareSelectedOutputDirectory(path.dirname(physicalCwd), physicalCwd);
-    const refused = {
-        ...studyResultIdentity("scripted", config.id),
-        ok: false,
-        cwd,
+    const refused = refusedResult("scripted", { studyId: config.id, cwd, error }, {
         actor: refusal.actor ?? actorType,
         appUrl: refusal.appUrl ?? config.subject.appUrl ?? "",
         dryRun,
         runId: options.runId ?? "not-created",
         sessions: [],
-        warnings: [],
-        error: { code: refusal.code, message: refusal.message },
-    };
+    });
     return completeRefusalAnalysis(refused, config, options);
 }
 /**
@@ -88,30 +77,20 @@ async function runScriptedPlanInScope(plan, input, scope) {
         return prepared.result;
     const { dryRun } = plan;
     const { setup } = prepared;
-    const started = await scope.startRun({
+    const started = await scope.startRun(plan, input, {
         cwd: setup.physicalCwd,
-        runId: input.runId,
-        mintRunId: makeScriptedRunId,
-        mode: dryRun ? "dry-run" : "live",
-        study: plan.study,
-        warnings: plan.warnings,
+        prefix: "scripted",
         // Only a clone subject is served from a sandbox; an app-url run drives a local browser.
         sandboxes: setup.clone ? undefined : "none",
         renderReview: renderScriptedReviewMarkdown,
-        observer: { open: input.open === true, render: setup.deps.renderObserver },
+        secrets: setup.secrets,
     });
     if (!started.ok) {
         return setup.failed(started.code, started.message);
     }
     const { run } = started;
-    const { createdAt, paths: runPaths } = run;
+    const { paths: runPaths, source } = run;
     const artifactRoot = runPaths.physicalRunRoot;
-    const source = await buildRunSource({
-        capturedAt: createdAt,
-        cwd: setup.physicalCwd,
-        humanishSource: "present",
-        packageName: "humanish",
-    });
     const scriptedSubject = setup.clone
         ? new ScriptedSubject({
             plan,
@@ -124,7 +103,7 @@ async function runScriptedPlanInScope(plan, input, scope) {
             timeoutMs: setup.timeoutMs,
             subjectEnvNames: setup.subjectEnvNames,
             hasGithubToken: setup.hasGithubToken,
-            scrubKnownValues: setup.scrubKnownValues,
+            scrubKnownValues: run.secrets.scrub,
             now: setup.deps.now ?? Date.now,
             warnings: setup.warnings,
         })
@@ -156,10 +135,10 @@ async function runScriptedPlanInScope(plan, input, scope) {
             }
             // The session itself maps launch failures to harness_error; reaching here means the
             // harness around it failed. Redacted at this boundary before persisting anywhere.
-            sessionError = redactText(setup.scrubKnownValues(toErrorMessage(error)));
+            sessionError = redactText(run.secrets.scrub(toErrorMessage(error)));
         }
         finally {
-            await scriptedSubject?.teardown();
+            await scriptedSubject?.sandbox.release();
         }
         await writeSurfaceTraces(runPaths, sessionResults);
     }
@@ -182,7 +161,3 @@ async function runScriptedPlanInScope(plan, input, scope) {
         scriptedSubject,
     });
 }
-function makeScriptedRunId() {
-    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-    return `scripted-${stamp}-${randomBytes(4).toString("hex")}`;
-}

package/dist/routes/scripted/setup.d.ts

@@ -1,6 +1,7 @@
 import type { ActorPersonaRef } from "../../actors/contract.js";
 import type { BrowserPersonaJourney, ScriptedBrowserEvidenceUrlPolicy } from "../../actors/scripted-browser/types.js";
 import type { ScriptedPlan } from "../../study/plan-types.js";
+import { RunSecrets } from "../../run/secrets.js";
 import { type ScriptedBrowserStudyResult, type ScriptedRunInput } from "./types.js";
 import type { StudyDeps } from "../../study/study-deps.js";
 /** What setup hands the run: the plan's subject and scenario, keys and the browser to launch. */
@@ -20,7 +21,7 @@ export interface ScriptedRunSetup {
     e2bApiKey: string;
     hasGithubToken: boolean;
     redactRepoLabel: boolean;
-    scrubKnownValues: (text: string) => string;
+    secrets: RunSecrets;
     /** The loopback app URL, or the clone's serve URL until its getHost URL replaces it. */
     appUrl: string;
     scenario: {

package/dist/routes/scripted/setup.js

@@ -1,16 +1,16 @@
 // What a scripted run needs before it starts: the checks the plan cannot make (the scenario file,
 // the E2B key and subject env of a live clone, a browser to launch) and the values the run reads
-// (the evidence URL policy, the scrubber for clone values, the persona and the session budget).
+// (the evidence URL policy, the run's known secrets, the persona and the session budget).
 import { realpath } from "node:fs/promises";
-import { missingKeys, missingSubjectEnv } from "../../study/requirements.js";
+import { firstLiveRefusal, keysCheck, subjectEnvCheck } from "../../study/requirements.js";
 import path from "node:path";
 import { resolveBrowserCommand } from "../../actors/scripted-browser/browser-command.js";
-import { describeMissingKeys } from "../../keys/key-resolution.js";
 import { prepareSelectedOutputDirectory } from "../../run/contained-output.js";
+import { RunSecrets } from "../../run/secrets.js";
 import { evidenceAppUrlOf } from "./plan.js";
 import { resolveScriptedScenario } from "./scenario.js";
 import {} from "./types.js";
-import { studyResultIdentity } from "../../run/study-result.js";
+import { refusedResult } from "../../run/study-result.js";
 // Journey wall-clock budget per surface: 5 minutes. A scripted surface has zero model cost and
 // sandbox-seconds are pennies; a short default only truncated slow-loading subjects.
 const DEFAULT_SESSION_TIMEOUT_MS = 300_000;
@@ -27,17 +27,12 @@ export async function prepareScriptedRun(plan, input) {
     const warnings = [];
     const clone = plan.subject.kind === "clone" ? plan.subject : undefined;
     const evidenceAppUrl = evidenceAppUrlOf(plan.subject);
-    const failed = (code, message) => ({
-        ...studyResultIdentity("scripted", plan.studyId),
-        ok: false,
-        cwd,
+    const failed = (code, message) => refusedResult("scripted", { studyId: plan.studyId, cwd, warnings, error: { code, message } }, {
         actor: plan.actor,
         appUrl: evidenceAppUrl,
         dryRun,
         runId: input.runId ?? "not-created",
         sessions: [],
-        warnings,
-        error: { code, message },
     });
     const urlPolicy = clone
         ? { kind: "provisioned-subject", evidenceOrigin: evidenceAppUrl }
@@ -47,11 +42,11 @@ export async function prepareScriptedRun(plan, input) {
     const e2bApiKey = env.E2B_API_KEY?.trim() ?? "";
     const hasGithubToken = subjectEnvNames.includes("GITHUB_TOKEN");
     const redactRepoLabel = plan.residual.policies?.redactRepos ?? hasGithubToken;
-    const scrubSourceValues = [
+    const secrets = new RunSecrets([
+        e2bApiKey,
         ...(clone ? [clone.repo] : []),
         ...subjectEnvNames.map((name) => env[name] ?? ""),
-    ].filter(Boolean);
-    const scrubKnownValues = (text) => scrubSourceValues.reduce((acc, value) => acc.split(value).join("[redacted]"), text);
+    ]);
     // A clone's URL is replaced by its getHost URL once it is served.
     let appUrl = plan.subject.kind === "clone" ? plan.subject.serve.url : plan.subject.appUrl;
     const scenario = await resolveScriptedScenario(projectRoot, plan.scenarioRef);
@@ -63,20 +58,18 @@ export async function prepareScriptedRun(plan, input) {
     }
     const journey = scenario.journey;
     // The plan lists E2B_API_KEY and the subject env only for a live clone.
-    const missing = missingKeys(plan.requirements, env);
-    if (missing.length > 0) {
-        return {
-            ok: false,
-            result: failed("HUMANISH_SCRIPTED_KEYS_MISSING", `Live clone scripted-browser studies require ${missing.join(" and ")} (dry-run remains $0 and does not provision a subject). ${describeMissingKeys(missing, env)}`),
-        };
-    }
-    const unsetSubjectEnv = missingSubjectEnv(plan.requirements, env);
-    if (unsetSubjectEnv.length > 0) {
-        return {
-            ok: false,
-            result: failed("HUMANISH_SCRIPTED_SUBJECT_ENV_MISSING", `Subject env values missing for a live clone scripted-browser study: ${unsetSubjectEnv.join(", ")}.`),
-        };
-    }
+    const { requirements } = plan;
+    const refusal = await firstLiveRefusal([
+        () => keysCheck({
+            requirements,
+            env,
+            code: "HUMANISH_SCRIPTED_KEYS_MISSING",
+            need: (names) => `Live clone scripted-browser studies require ${names} (dry-run remains $0 and does not provision a subject).`,
+        }),
+        () => subjectEnvCheck({ requirements, env, code: "HUMANISH_SCRIPTED_SUBJECT_ENV_MISSING" }),
+    ]);
+    if (refusal)
+        return { ok: false, result: failed(refusal.code, refusal.message) };
     const surfaces = plan.surfaces;
     const timeoutMs = plan.sessionTimeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS;
     const persona = {
@@ -114,7 +107,7 @@ export async function prepareScriptedRun(plan, input) {
             e2bApiKey,
             hasGithubToken,
             redactRepoLabel,
-            scrubKnownValues,
+            secrets,
             appUrl,
             scenario,
             journey,