humanish 0.106.1 → 0.108.0

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

@@ -7,30 +7,38 @@ import {} from "../../substrates/e2b/sdk.js";
 import {} from "../../substrates/e2b/desktop-resources.js";
 import {} from "../../substrates/detached.js";
 import {} from "../../lab/types.js";
-import { renderObserver } from "../../observer/render.js";
-import {} from "../../run/status.js";
+import {} from "../../observer/render.js";
 import {} from "../../run/bundle.js";
 import {} from "../../run/streams.js";
 import {} from "../../run/contained-output.js";
-import {} from "../../subject/local-tree-archive.js";
-export const CUA_ACTOR_LAB_SCHEMA = "humanish.cua-lab-result.v2";
-// The only fan-out topology this slice ships: N lanes = N independent E2B desktop sandboxes,
-// each its own world (clone/serve + subject.state per lane). Shared-world is layer 7 (#164).
+import {} from "../../run/study-result.js";
+// The fan-out topology of this route: N participants = N independent E2B desktop sandboxes,
+// each its own world (clone/serve + subject.state per participant). Shared-world has its own route.
 export const CUA_FANOUT_STRATEGY = "per-lane-worlds";
-// Env override that may only LOWER the effective concurrency (never raise concurrent paid
-// desktops — invariant 3). Read names-only into a local; the value never persists.
+// Env override that may only lower the effective concurrency (never raise concurrent paid
+// desktops). Read names-only into a local; the value never persists.
 export const CUA_MAX_CONCURRENCY_ENV = "HUMANISH_CUA_MAX_CONCURRENCY";
-// The DEFAULT session budget, sized so a study can FINISH (docs/principles/three-roles.md: a
-// session ends because the participant is done, not because a timer fired — the time-box is a
+// The default session budget, sized so a study can finish (docs/principles/three-roles.md: a
+// session ends because the participant is done, not because a timer fired; the time-box is a
 // session-level cap a researcher sets generously; spend protection is the dollar caps' job).
 // The old 300s default ended real signup studies mid-flow: observed studies run 16-40 turns at
-// ~5-6s per turn BEFORE any email wait, so five minutes was the biggest single source of
+// ~5-6s per turn before any email wait, so five minutes was the biggest single source of
 // budget_reached endings that read as participant failures.
 //
 // App-url and in-process routes default to 30 minutes. Provisioned routes (clone/local-tree)
 // default to whatever the 1-hour sandbox cap leaves after provisioning, declared state seeding,
-// and the teardown buffer — 20 minutes on a stateless clone — floored at the old five minutes so
-// a state-heavy lab still gets a session at all. An EXPLICIT execution.timeoutMs is never
+// and the teardown buffer (20 minutes on a stateless clone), floored at the old five minutes so
+// a state-heavy lab still gets a session at all. An explicit execution.timeoutMs is never
 // adjusted: when it cannot be provisioned, the plan-time cap refusal shows the arithmetic.
 export const DEFAULT_APP_URL_SESSION_TIMEOUT_MS = 30 * 60_000;
 export const MIN_DERIVED_SESSION_TIMEOUT_MS = 5 * 60_000;
+/** The subject env names forwarded into a participant's sandbox: a provisioned subject's only. */
+export function participantSubjectEnv(subject) {
+    return subject.kind === "clone" || subject.kind === "local-tree" ? subject.env : [];
+}
+/** The serve URL a participant's inbox maps links back to: the served app's, when there is one. */
+export function participantServeUrl(subject) {
+    if (subject.kind === "clone" || subject.kind === "local-tree")
+        return subject.serve.url;
+    return "serveUrl" in subject ? subject.serveUrl : undefined;
+}

package/dist/routes/preview.d.ts

@@ -1,13 +1,19 @@
 import type { AdmittedPlan, RunLabOptions } from "../run-lab.js";
 import type { LabPlan, PlanRefusal } from "../lab/plan-types.js";
 import type { RunResult } from "../run/results.js";
+import { type StudyResultIdentity } from "../run/study-result.js";
 type PreviewPlan = Extract<LabPlan, {
     readonly route: "preview";
 }>;
+/**
+ * The preview route's result when a study runs: the synthetic run's result, named as a study
+ * result. `humanish run` with no study returns the plain `RunResult`.
+ */
+export type PreviewStudyResult = Omit<RunResult, "schema"> & StudyResultIdentity<"preview">;
 /** A refused preview's result. */
-export declare function previewLabRefusal(cwd: string, refusal: Extract<PlanRefusal, {
+export declare function previewLabRefusal(cwd: string, studyId: string, refusal: Extract<PlanRefusal, {
     readonly route: "preview";
-}>): RunResult;
+}>): PreviewStudyResult;
 /** runLab's step for a preview plan: it has no local checks and takes no scorer, so it returns its run. */
 export declare function admitPreviewPlan(plan: PreviewPlan, input: Pick<RunLabOptions, "cwd" | "runId" | "open">): AdmittedPlan<"preview">;
 export {};

package/dist/routes/preview.js

@@ -1,11 +1,12 @@
 // The preview route: a lab whose subject is this repo runs the synthetic dry run. planLab decides
 // the sim count and refuses what a synthetic run would ignore; runPreviewPlan does the rest.
+import { 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 previewLabRefusal(cwd, refusal) {
+export function previewLabRefusal(cwd, studyId, refusal) {
     return {
-        schema: "humanish.run-result.v1",
+        ...studyResultIdentity("preview", studyId),
         ok: false,
         cwd: path.resolve(cwd),
         warnings: [],
@@ -18,8 +19,10 @@ export function admitPreviewPlan(plan, input) {
         ok: true,
         run: async () => ({
             route: "preview",
-            backend: "synthetic",
-            result: await runPreviewPlan(plan, input),
+            result: {
+                ...(await runPreviewPlan(plan, input)),
+                ...studyResultIdentity("preview", plan.labId),
+            },
         }),
     };
 }
@@ -29,7 +32,7 @@ function runPreviewPlan(plan, input) {
         ...(plan.lab === undefined ? {} : { lab: plan.lab }),
         cwd: input.cwd,
         dryRun: true,
-        simCount: plan.participantCount,
+        participantCount: plan.participantCount,
         ...(input.runId === undefined ? {} : { runId: input.runId }),
         ...(input.open === undefined ? {} : { observer: { open: input.open } }),
     });

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

@@ -2,15 +2,13 @@ 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 ReviewSummary, type RunBundle, type RunSubjectProvenance } from "../../run/bundle.js";
-import type { RunLabProvenance } from "../../run/status.js";
+import { type ReviewSummary, type RunBundle, type RunSubjectProvenance, type BundleRun } from "../../run/bundle.js";
 /** What the scripted lab's bundle is built from. */
 interface ScriptedBundleArgs {
-    /** Lab provenance for the bundle\'s own `lab` field (#455). */
-    lab?: RunLabProvenance;
+    /** The run this bundle belongs to; the bundle head reads its id, mode, start and lab. */
+    run: BundleRun;
     actorId: string;
     appUrl: string;
-    createdAt: string;
     desktopTemplate?: string;
     dryRun: boolean;
     hostDigest?: string;
@@ -18,7 +16,6 @@ interface ScriptedBundleArgs {
     labId: string;
     labTitle?: string;
     persona: ActorPersonaRef;
-    runId: string;
     scenarioSource: string;
     scenarioSourceDigest: string;
     screenshotsBySurface: Map<string, string[]>;
@@ -37,8 +34,8 @@ interface ScriptedBundleArgs {
     verdict: ReviewSummary["verdict"];
 }
 /**
- * Project the scripted lab run into a humanish.run-bundle.v1 (no schema change — a new
- * producer only). The load-bearing line is `stream.actor = result.trace`: the provider-neutral
+ * Project the scripted lab run into a humanish.run-bundle.v1 (no schema change: a new
+ * producer only). The key line is `stream.actor = result.trace`: the provider-neutral
  * ActorTrace seam the Observer renders and verifyRun's engagement check reads. Exported for
  * the bundle-builder tests.
  */

package/dist/routes/scripted/bundle.js

@@ -1,5 +1,6 @@
 // Assemble the scripted-browser lab's run bundle from its sessions, and the review summary and
 // markdown that ship with it.
+import { verdictText } from "../../run/judge.js";
 import { redactText } from "../../evidence/redaction.js";
 import { buildRunCostSummary, desktopSpanToMinutes, spendFreeCostSummary, } from "../../run/cost-summary.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
@@ -7,31 +8,26 @@ import {} from "../../run/streams.js";
 import { participantEvent, recordIdOf } from "../../run/participant-records.js";
 import { scriptedSurfaceIds, scriptedSurfaceRecords } from "./surface-records.js";
 /**
- * Project the scripted lab run into a humanish.run-bundle.v1 (no schema change — a new
- * producer only). The load-bearing line is `stream.actor = result.trace`: the provider-neutral
+ * Project the scripted lab run into a humanish.run-bundle.v1 (no schema change: a new
+ * producer only). The key line is `stream.actor = result.trace`: the provider-neutral
  * ActorTrace seam the Observer renders and verifyRun's engagement check reads. Exported for
  * the bundle-builder tests.
  */
 export function buildScriptedLabBundle(args) {
     const resultBySurface = new Map(args.sessionResults.map((result) => [result.capture.surface.id, result]));
-    const records = args.surfaces.map((surface, index) => scriptedSurfaceRecords(args, surface, index, resultBySurface.get(surface.id), args.screenshotsBySurface.get(surface.id) ?? []));
+    // Each surface's records are stamped with the run's start.
+    const context = { ...args, createdAt: args.run.createdAt };
+    const records = args.surfaces.map((surface, index) => scriptedSurfaceRecords(context, surface, index, resultBySurface.get(surface.id), args.screenshotsBySurface.get(surface.id) ?? []));
     const events = scriptedEvents(args);
     const review = buildScriptedReview(args);
     const ranLive = args.sessionResults.length > 0 || args.sessionError !== undefined;
     const cost = args.dryRun ? undefined : scriptedCost(args.subjectDesktop);
     return {
-        ...bundleHead({
-            runId: args.runId,
-            mode: args.dryRun ? "dry-run" : "live",
-            participants: args.surfaces.length,
-            createdAt: args.createdAt,
-            ...(args.lab === undefined ? {} : { lab: args.lab }),
-            source: args.source,
-        }),
+        ...bundleHead(args.run, { participants: args.surfaces.length, source: args.source }),
         persona: {
             id: args.persona.id,
             name: `Scripted journey persona (${args.persona.id})`,
-            source: `lab:${args.labId}`,
+            source: `study:${args.labId}`,
             sourceDigest: args.persona.promptDigest,
         },
         scenario: {
@@ -43,7 +39,7 @@ export function buildScriptedLabBundle(args) {
         },
         lifecycle: [
             {
-                at: args.createdAt,
+                at: args.run.createdAt,
                 event: "scripted-lab.run.created",
                 message: `Created scripted-browser lab run with ${args.surfaces.length} surface${args.surfaces.length === 1 ? "" : "s"} (actor ${args.actorId}).`,
             },
@@ -54,8 +50,8 @@ export function buildScriptedLabBundle(args) {
         redaction: {
             status: "passed",
             notes: ranLive
-                ? "Scripted step URLs are sanitized to loopback origin+path (query/hash redacted) and step text passes text redaction. Screenshots are FULL-FIDELITY (raw), retained for local use in gitignored .humanish — NOT redacted for publishing; policies.redactScreenshots is not yet supported on this route."
-                : "Dry-run contract bundle: no browser ran and no screenshots were captured. The scenario contract is digest-pinned; live step text passes text redaction when a session runs.",
+                ? "Scripted step URLs are reduced to loopback origin and path (query and hash removed), and step text passes text redaction. Screenshots are unblurred and kept for local use in the gitignored .humanish/ folder; they are not redacted for publishing, and policies.redactScreenshots is not supported on this route yet."
+                : "Dry-run bundle: no browser ran and no screenshots were captured. The scenario is digest-pinned; live step text passes text redaction when a session runs.",
         },
         artifacts: bundleArtifacts(),
         review,
@@ -70,25 +66,25 @@ function scriptedEvents(args) {
     const events = [
         {
             id: "event-000-created",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "scripted-lab.run.created",
             message: `Created scripted-browser lab run for ${args.labId} (actor ${args.actorId}, ${args.surfaces.length} surface${args.surfaces.length === 1 ? "" : "s"}).`,
         },
         {
             id: "event-001-subject",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "scripted-lab.subject.declared",
-            // Invariant 5: provenance recorded or its absence DECLARED. The lab did not provision
+            // Provenance is recorded or its absence declared. The lab did not provision
             // this subject on app-url routes; clone routes carry structured subject provenance below.
             message: args.subject
                 ? `Provisioned synthetic subject: clone of ${args.subject.repo}${args.subject.commit ? `@${args.subject.commit}` : ""}, served + getHost-exposed in-sandbox; env names: ${args.subject.envNames?.join(", ") || "none"} (values never persisted); state provenance: ${args.subject.state.provenance}; evidence host digest: ${args.hostDigest ?? "dry-run"}.`
-                : `Subject app declared at ${args.appUrl}; the lab did not provision it — subject build/commit provenance is UNPINNED; evidence binds to the scenario digest ${args.scenarioSourceDigest}.`,
+                : `Subject app declared at ${args.appUrl}; humanish did not provision it, so its build and commit are unpinned. The evidence is tied to the scenario digest ${args.scenarioSourceDigest}.`,
         },
         {
             id: "event-002-spend",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "scripted-lab.spend",
             message: args.subject
@@ -103,14 +99,14 @@ function scriptedEvents(args) {
                 at: result.capture.capturedAt,
                 level: result.status === "passed" ? "info" : "warn",
                 type: `scripted-lab.session.${result.completionReason}`,
-                message: `${result.capture.surface.id}: ${result.status} — ${result.reason}`,
+                message: `${result.capture.surface.id}: ${result.status} (${result.reason})`,
             }));
         }
     }
     else if (args.sessionError !== undefined) {
         events.push({
             id: "event-003-session-error",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "error",
             type: "scripted-lab.session.error",
             message: args.sessionError,
@@ -119,10 +115,10 @@ function scriptedEvents(args) {
     else {
         events.push({
             id: "event-003-contract",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "scripted-lab.contract.ready",
-            message: `Dry-run contract bundle ready: scenario ${args.journey.scenarioId} @ ${args.scenarioSourceDigest} (${args.scenarioSource}, ${args.journey.steps.length} step${args.journey.steps.length === 1 ? "" : "s"}) parsed and digest-pinned; switch scenario.mode to live to actuate a real browser.`,
+            message: `Dry-run bundle ready: scenario ${args.journey.scenarioId} @ ${args.scenarioSourceDigest} (${args.scenarioSource}, ${args.journey.steps.length} step${args.journey.steps.length === 1 ? "" : "s"}) parsed and digest-pinned; switch scenario.mode to live to actuate a real browser.`,
         });
     }
     return events;
@@ -156,8 +152,8 @@ function buildScriptedReview(args) {
         return {
             schema: REVIEW_SCHEMA,
             verdict: args.verdict,
-            summary: `Dry-run contract for scenario ${args.journey.scenarioId} (${args.scenarioSource}, ${args.journey.steps.length} steps) against ${args.appUrl}: composition and scenario contract proven at $0; no browser ran.`,
-            gaps: ["Live scripted session not yet run (dry-run contract only)."],
+            summary: `Dry run of scenario ${args.journey.scenarioId} (${args.scenarioSource}, ${args.journey.steps.length} steps) against ${args.appUrl}: composition and scenario checked at $0; no browser ran.`,
+            gaps: ["Live scripted session not yet run (dry run only)."],
         };
     }
     const passed = args.sessionResults.filter((result) => result.status === "passed").length;
@@ -181,7 +177,7 @@ export function renderScriptedReviewMarkdown(bundle) {
         "",
         `- run: ${bundle.runId}`,
         `- mode: ${bundle.mode}`,
-        `- verdict: ${bundle.review.verdict}`,
+        `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
         `- summary: ${bundle.review.summary}`,
         `- scenario: ${bundle.scenario.id} @ ${bundle.scenario.sourceDigest} (${bundle.scenario.source})`,
         ...(subject ? [`- subject: ${subject.message}`] : []),

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

@@ -1,8 +1,8 @@
+import type { LabDeps } from "../../lab/lab-deps.js";
 import type { RoutePlanResult, RouteRefusal, ScriptedPlan } from "../../lab/plan-types.js";
 import type { LabConfig } from "../../lab/types.js";
-import type { RunLabProvenance } from "../../run/status.js";
 /** The error a scripted lab returns before a run starts. */
-export interface ScriptedRefusal extends RouteRefusal<"scripted", "HUMANISH_LAB_ANALYSIS_INVALID" | "HUMANISH_LAB_TASKS_UNSUPPORTED" | "HUMANISH_SCRIPTED_LAB_ACTOR_UNSUPPORTED" | "HUMANISH_SCRIPTED_LAB_SCENARIO_INVALID" | "HUMANISH_SCRIPTED_LAB_SUBJECT_UNSAFE"> {
+export interface ScriptedRefusal extends RouteRefusal<"scripted", "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_SCRIPTED_ACTOR_UNSUPPORTED" | "HUMANISH_SCRIPTED_SCENARIO_INVALID" | "HUMANISH_SCRIPTED_SUBJECT_UNSAFE"> {
     /**
      * Set on the receiving, analysis and tasks refusals. The route returns those before it opens its
      * run scope, so their result has its own field order and no automatic-analysis record.
@@ -15,16 +15,14 @@ export interface ScriptedRefusal extends RouteRefusal<"scripted", "HUMANISH_LAB_
 export type ScriptedPlanResult = RoutePlanResult<ScriptedPlan, ScriptedRefusal>;
 /** The app URL a run's evidence names: a provisioned subject's getHost URL is never persisted. */
 export declare function evidenceAppUrlOf(subject: ScriptedPlan["subject"]): string;
+/** Whether a test injected the browser, so a live run needs no host browser. */
+export declare function injectedBrowser(deps: LabDeps | undefined): boolean;
 /**
  * Plan a scripted-browser lab. It is called for any config handed to the scripted runner, not only
  * one routeOf sends here, so a config for another route gets this route's refusal.
  */
 export declare function planScriptedLab(config: LabConfig, input: {
     readonly dryRun: boolean;
-    readonly lab?: RunLabProvenance;
-    /** An injected browser means a live run needs no host browser. */
-    readonly hooks?: {
-        readonly launchBrowser?: unknown;
-        readonly browserCommand?: string;
-    };
+    /** A test's injected browser means a live run needs no host browser. */
+    readonly injectedBrowser?: boolean;
 }): ScriptedPlanResult;

package/dist/routes/scripted/plan.js

@@ -7,13 +7,17 @@ import { browserSurfaces } from "../../actors/scripted-browser/types.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { isNonEmpty, planBase, provisionedSubject } from "../../lab/plan-base.js";
 import { cloneTargetValidationReason, desktopMediaValidationReason, taskProtocolValidationReason, } from "../../lab/validation.js";
-// Default surface roster is 1 (desktop only): the defaults-table single-lane row governs;
+// Default surface roster is 1 (desktop only): the defaults-table single-participant row governs;
 // `count: 2` is the declared override that adds the mobile surface.
 const DEFAULT_SURFACE_COUNT = 1;
 /** The app URL a run's evidence names: a provisioned subject's getHost URL is never persisted. */
 export function evidenceAppUrlOf(subject) {
     return subject.kind === "clone" ? "[provisioned-subject]" : subject.appUrl;
 }
+/** Whether a test injected the browser, so a live run needs no host browser. */
+export function injectedBrowser(deps) {
+    return Boolean(deps?.launchBrowser || deps?.browserCommand);
+}
 /**
  * Plan a scripted-browser lab. It is called for any config handed to the scripted runner, not only
  * one routeOf sends here, so a config for another route gets this route's refusal.
@@ -25,23 +29,23 @@ export function planScriptedLab(config, input) {
     });
     const beforeScope = { beforeScope: true };
     if (String(config.comms?.email?.kind) === "real")
-        return refuse("HUMANISH_SCRIPTED_LAB_SCENARIO_INVALID", "Real email receiving is unsupported on the scripted route. Use a supported hosted computer-use browser lab.", beforeScope);
+        return refuse("HUMANISH_SCRIPTED_SCENARIO_INVALID", "Real email receiving is unsupported on the scripted route. Use a supported hosted computer-use browser lab.", beforeScope);
     const analysis = resolveAutomaticAnalysis(config.review?.analysis);
     if (!analysis.ok)
-        return refuse("HUMANISH_LAB_ANALYSIS_INVALID", analysis.message, beforeScope);
+        return refuse("HUMANISH_STUDY_ANALYSIS_INVALID", analysis.message, beforeScope);
     const tasksReason = taskProtocolValidationReason(config, false);
     if (tasksReason)
-        return refuse("HUMANISH_LAB_TASKS_UNSUPPORTED", tasksReason, beforeScope);
+        return refuse("HUMANISH_STUDY_TASKS_UNSUPPORTED", tasksReason, beforeScope);
     const mediaReason = desktopMediaValidationReason(config);
     if (mediaReason)
-        return refuse("HUMANISH_SCRIPTED_LAB_SCENARIO_INVALID", mediaReason);
+        return refuse("HUMANISH_SCRIPTED_SCENARIO_INVALID", mediaReason);
     const cloneTargetReason = cloneTargetValidationReason(config);
     if (cloneTargetReason)
-        return refuse("HUMANISH_SCRIPTED_LAB_SUBJECT_UNSAFE", cloneTargetReason);
+        return refuse("HUMANISH_SCRIPTED_SUBJECT_UNSAFE", cloneTargetReason);
     const actorType = config.actors[0]?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isScriptedBrowserActorDescriptor(descriptor))
-        return refuse("HUMANISH_SCRIPTED_LAB_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered scripted-browser actor.`);
+        return refuse("HUMANISH_SCRIPTED_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered scripted-browser actor.`);
     const actor = descriptor.id;
     // The parser checks the loopback entry too; a library caller skips the parser. A clone's URL is
     // minted by getHost during the run, and its evidence names only the placeholder.
@@ -49,20 +53,19 @@ export function planScriptedLab(config, input) {
     if (config.subject.source === "clone") {
         const provisioned = provisionedSubject(config);
         if (provisioned?.kind !== "clone" || !provisioned.repo)
-            return refuse("HUMANISH_SCRIPTED_LAB_SUBJECT_UNSAFE", "clone scripted-browser labs require one subject repo plus subject.serve; parseLabConfig should have rejected this config.", { actor, appUrl: "[provisioned-subject]" });
+            return refuse("HUMANISH_SCRIPTED_SUBJECT_UNSAFE", "clone scripted-browser labs require one subject repo plus subject.serve; parseLabConfig should have rejected this config.", { actor, appUrl: "[provisioned-subject]" });
         subject = provisioned;
     }
     else {
         const appUrl = normalizeLocalAppUrl(config.subject.appUrl ?? "");
         if (!appUrl)
-            return refuse("HUMANISH_SCRIPTED_LAB_SUBJECT_UNSAFE", "subject.appUrl must be a loopback http(s) URL (127.0.0.1 or localhost) on the scripted-browser route.", { actor });
+            return refuse("HUMANISH_SCRIPTED_SUBJECT_UNSAFE", "subject.appUrl must be a loopback http(s) URL (127.0.0.1 or localhost) on the scripted-browser route.", { actor });
         subject = { kind: "loopback", appUrl };
     }
     // The steps are the actor, so there is no built-in journey to fall back on.
     const scenarioRef = config.scenario?.ref;
     if (!scenarioRef?.trim())
-        return refuse("HUMANISH_SCRIPTED_LAB_SCENARIO_INVALID", "scripted-browser labs require `scenario.ref` — the committed scenario's browser steps are what this actor executes.", { actor, appUrl: evidenceAppUrlOf(subject) });
-    const hooks = input.hooks ?? {};
+        return refuse("HUMANISH_SCRIPTED_SCENARIO_INVALID", "A scripted-browser study needs `scenario.ref`: the actor runs the browser steps in that scenario file.", { actor, appUrl: evidenceAppUrlOf(subject) });
     const requirements = [];
     if (!input.dryRun && subject.kind === "clone") {
         requirements.push({ kind: "key", name: "E2B_API_KEY" });
@@ -70,7 +73,7 @@ export function planScriptedLab(config, input) {
             requirements.push({ kind: "subject-env", names: subject.env });
     }
     // The browser runs on this machine on both subjects; a clone's is pointed at its getHost URL.
-    if (!input.dryRun && !hooks.launchBrowser && !hooks.browserCommand)
+    if (!input.dryRun && input.injectedBrowser !== true)
         requirements.push({ kind: "host-browser" });
     const persona = config.actors[0]?.persona;
     const timeoutMs = config.execution?.timeoutMs;
@@ -79,7 +82,6 @@ export function planScriptedLab(config, input) {
         plan: {
             ...planBase(config, {
                 dryRun: input.dryRun,
-                ...(input.lab === undefined ? {} : { lab: input.lab }),
                 analysis,
             }),
             route: "scripted",

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

@@ -36,13 +36,16 @@ export interface ScriptedFinishInputs {
 }
 /**
  * The scripted run's execution failures: the session's own error, a live surface that never
- * returned, a surface that ended in a harness error, and an Observer that failed.
+ * returned, a surface that ended in a harness error, a subject sandbox whose release is
+ * unconfirmed, and an Observer that failed.
  */
 export declare function scriptedExecutionFailures(args: {
     dryRun: boolean;
+    runId: string;
     sessionError: string | undefined;
     expected: number;
     sessionResults: readonly Pick<ScriptedBrowserSessionResult, "completionReason" | "reason">[];
+    subject: Pick<ScriptedSubject, "sandboxId" | "killed" | "releaseWarning"> | undefined;
     observer: Pick<ObserverResult, "ok" | "error">;
 }): ExecutionFailure[];
 export declare function finishScriptedRun(inputs: ScriptedFinishInputs): Promise<ScriptedBrowserLabResult>;

package/dist/routes/scripted/result.js

@@ -1,9 +1,10 @@
-import { judgeExecution, judgeScripted, OUTCOME_POLICIES, resultOk, } from "../../run/judge.js";
+import { judgeExecution, sandboxCleanupFailure, judgeScripted, OUTCOME_POLICIES, resultOk, } from "../../run/judge.js";
 import { validatePreparedRunArtifactPaths } from "../../run/paths.js";
 import { resolveSubjectState } from "../computer-use/subject-projection.js";
 import { buildScriptedLabBundle } from "./bundle.js";
 import { existingScreenshots } from "./session-result.js";
-import { SCRIPTED_BROWSER_LAB_SCHEMA } from "./types.js";
+import {} from "./types.js";
+import { studyResultIdentity } from "../../run/study-result.js";
 /** What judgeScripted reads from one surface's session. Scripted has no engagement or blocker rule. */
 function scriptedSurfaceFacts(result) {
     return {
@@ -16,7 +17,8 @@ function scriptedSurfaceFacts(result) {
 }
 /**
  * The scripted run's execution failures: the session's own error, a live surface that never
- * returned, a surface that ended in a harness error, and an Observer that failed.
+ * returned, a surface that ended in a harness error, a subject sandbox whose release is
+ * unconfirmed, and an Observer that failed.
  */
 export function scriptedExecutionFailures(args) {
     const { sessionError, sessionResults, observer } = args;
@@ -39,6 +41,9 @@ export function scriptedExecutionFailures(args) {
                 },
             ]
             : []),
+        ...(args.subject?.sandboxId === undefined || args.subject.killed
+            ? []
+            : [sandboxCleanupFailure("subject", args.subject.releaseWarning, args.runId)]),
         ...(observer.ok
             ? []
             : [
@@ -54,7 +59,7 @@ export async function finishScriptedRun(inputs) {
     const { surfaces, sessionResults, sessionError, warnings, clone, redactRepoLabel } = inputs;
     const { subjectEnvNames, scriptedSubject } = inputs;
     const { actor, dryRun } = plan;
-    const { runId, createdAt, paths: runPaths } = run;
+    const { runId, paths: runPaths } = run;
     const subjectCommit = scriptedSubject?.commit;
     const subjectSandboxId = scriptedSubject?.sandboxId;
     const subjectKilled = scriptedSubject?.killed ?? false;
@@ -86,16 +91,14 @@ export async function finishScriptedRun(inputs) {
         surfaces: sessionResults.map(scriptedSurfaceFacts),
     });
     const bundle = buildScriptedLabBundle({
-        ...(plan.lab === undefined ? {} : { lab: plan.lab }),
+        run,
         actorId: actor,
         appUrl: evidenceAppUrl,
-        createdAt,
         dryRun,
         journey,
         labId: plan.labId,
         ...(plan.title ? { labTitle: plan.title } : {}),
         persona,
-        runId,
         scenarioSource: scenario.source,
         scenarioSourceDigest: scenario.sourceDigest,
         screenshotsBySurface,
@@ -114,7 +117,7 @@ export async function finishScriptedRun(inputs) {
     const finished = await run.finish(bundle);
     // Surface the local-fidelity posture so the operator knows the bundle is not publish-safe as-is.
     if (sessionResults.some((result) => result.trace.redaction.screenshots === "raw")) {
-        warnings.push("Screenshots are full-fidelity (raw) for local use — the bundle stays in gitignored .humanish and nothing scans these pixels; review them before sharing anywhere. policies.redactScreenshots is not yet supported on the scripted route.");
+        warnings.push("Screenshots are unblurred for local use: the bundle stays in the gitignored .humanish/ folder and nothing scans these pixels, so review them before sharing. policies.redactScreenshots is not supported on the scripted route yet.");
     }
     const observer = await finished.renderObserver();
     await validatePreparedRunArtifactPaths(runPaths);
@@ -122,19 +125,20 @@ export async function finishScriptedRun(inputs) {
     const policy = OUTCOME_POLICIES.scripted;
     const execution = judgeExecution(scriptedExecutionFailures({
         dryRun,
+        runId,
         sessionError,
         expected: surfaces.length,
         sessionResults,
+        subject: scriptedSubject,
         observer,
     }), policy);
     const ok = resultOk({ judgment, execution, scorerFailures: [], policy });
     await finished.recordOutcome({ ok, execution });
     const harnessErrorSession = sessionResults.find((result) => result.completionReason === "harness_error");
     return {
-        schema: SCRIPTED_BROWSER_LAB_SCHEMA,
+        ...studyResultIdentity("scripted", plan.labId),
         ok,
         cwd,
-        labId: plan.labId,
         actor,
         appUrl: evidenceAppUrl,
         dryRun,
@@ -163,7 +167,7 @@ export async function finishScriptedRun(inputs) {
             ? {}
             : {
                 error: {
-                    code: "HUMANISH_SCRIPTED_LAB_FAILED",
+                    code: "HUMANISH_SCRIPTED_FAILED",
                     message: sessionError ??
                         (observer.ok
                             ? harnessErrorSession