humanish 0.110.4 → 0.111.1

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

@@ -25,7 +25,6 @@ import { projectParticipantSubjects, subjectProvenanceArg } from "./subject-proj
 import { participantSubjectEnv, } from "./types.js";
 import { studyPersonaIds } from "../../study/persona-resolve.js";
 import { studyResultIdentity } from "../../run/study-result.js";
-import { actorOf } from "../../study/study-fields.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
@@ -48,7 +47,7 @@ export async function refuseCuaStudy(options, refusal) {
         ...studyResultIdentity("computer-use", config.id),
         ok: false,
         cwd: projectRoot.physicalPath,
-        actor: refusal.actor ?? actorOf(config)?.type ?? "",
+        actor: refusal.actor ?? config.actor?.type ?? "",
         appUrl: declaredAppUrl(config),
         dryRun,
         runId: options.runId ?? "not-created",
@@ -214,6 +213,7 @@ export async function startCuaRun(plan, input, admitted, scope) {
         mintRunId: makeCuaRunId,
         mode: dryRun ? "dry-run" : "live",
         study: plan.study,
+        warnings: plan.warnings,
         renderReview: renderCuaReviewMarkdown,
         observer: { open: input.open === true, render: seams.renderObserver },
     });

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

@@ -52,8 +52,8 @@ export interface ComputerUseRunInput {
     cwd: string;
     open?: boolean;
     runId?: string;
-    /** CLI `--count` override for the homogeneous fan-out participant count (ignored when a `lanes`
-     *  roster is declared; a roster's length is authoritative). */
+    /** CLI `--count` override for the homogeneous fan-out participant count (ignored when a `participants`
+     *  list is declared; a roster's length is authoritative). */
     countOverride?: number;
     /** Explicitly create a new run containing failed or selected participants from a prior fan-out run. */
     rerun?: {
@@ -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_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 = "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";
 /** Subject provenance projection: what the actor actually drove. */
 export interface CuaSubjectProjection {
     source: "app-url" | "clone" | "local-tree";
@@ -385,7 +385,7 @@ export interface ParticipantModelDeps {
     artifactRoot: PreparedOutputRoot;
     redactScreenshots: boolean;
     scrubKnownValues: (text: string) => string;
-    /** The study's shared spend ledger, present exactly when execution.caps.maxTotalUsd is set on a
+    /** The study's shared spend ledger, present exactly when caps.maxTotalUsd is set on a
      *  live run. Preflight already refused the cap on an unpriced model. */
     runBudget?: CuaRunBudget;
     /**

package/dist/routes/preview.js

@@ -30,6 +30,7 @@ export function admitPreviewPlan(plan, input) {
 function runPreviewPlan(plan, input) {
     return runDryRun({
         ...(plan.study === undefined ? {} : { study: plan.study }),
+        ...(plan.warnings === undefined ? {} : { warnings: plan.warnings }),
         cwd: input.cwd,
         dryRun: true,
         participantCount: plan.participantCount,

package/dist/routes/scripted/plan.js

@@ -7,7 +7,6 @@ import { browserSurfaces } from "../../actors/scripted-browser/types.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { isNonEmpty, planBase, provisionedSubject } from "../../study/plan-base.js";
 import { cloneTargetValidationReason, desktopMediaValidationReason, taskProtocolValidationReason, } from "../../study/validation.js";
-import { actorOf, surfaceCount, scenarioRefOf } from "../../study/study-fields.js";
 // 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;
@@ -43,7 +42,7 @@ export function planScriptedStudy(config, input) {
     const cloneTargetReason = cloneTargetValidationReason(config);
     if (cloneTargetReason)
         return refuse("HUMANISH_SCRIPTED_SUBJECT_UNSAFE", cloneTargetReason);
-    const actorType = actorOf(config)?.type ?? "";
+    const actorType = config.actor?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isScriptedBrowserActorDescriptor(descriptor))
         return refuse("HUMANISH_SCRIPTED_ACTOR_UNSUPPORTED", `actor.type "${actorType}" is not a registered scripted-browser actor.`);
@@ -64,7 +63,7 @@ export function planScriptedStudy(config, input) {
         subject = { kind: "loopback", appUrl };
     }
     // The steps are the actor, so there is no built-in journey to fall back on.
-    const scenarioRef = scenarioRefOf(config);
+    const scenarioRef = config.scenario;
     if (!scenarioRef?.trim())
         return refuse("HUMANISH_SCRIPTED_SCENARIO_INVALID", "A scripted-browser study needs `scenario`: the actor runs the browser steps in that scenario file.", { actor, appUrl: evidenceAppUrlOf(subject) });
     const requirements = [];
@@ -76,7 +75,7 @@ export function planScriptedStudy(config, input) {
     // The browser runs on this machine on both subjects; a clone's is pointed at its getHost URL.
     if (!input.dryRun && input.injectedBrowser !== true)
         requirements.push({ kind: "host-browser" });
-    const persona = actorOf(config)?.persona;
+    const persona = config.actor?.persona;
     const timeoutMs = config.execution?.timeoutMs;
     return {
         ok: true,
@@ -89,7 +88,7 @@ export function planScriptedStudy(config, input) {
             actor,
             subject,
             scenarioRef,
-            surfaces: browserSurfaces.slice(0, surfaceCount(config) ?? DEFAULT_SURFACE_COUNT),
+            surfaces: browserSurfaces.slice(0, config.surfaces?.length ?? DEFAULT_SURFACE_COUNT),
             ...(persona === undefined ? {} : { personaId: persona }),
             ...(timeoutMs === undefined ? {} : { sessionTimeoutMs: timeoutMs }),
             requirements,

package/dist/routes/scripted/route.js

@@ -6,7 +6,7 @@
 //
 // Spend: scripted steps make no model requests, and their traces record zero token usage. A local
 // app-url run spends no sandbox minutes; a live clone run spends E2B minutes to clone and serve the
-// subject. `scenario.mode: live` is required anyway, because a live run actuates a real browser
+// subject. `mode: live` is required anyway, because a live run actuates a real browser
 // against a real app (it fills forms and clicks buttons). A dry run parses and digest-pins the
 // scenario and writes the contract bundle without touching anything.
 //
@@ -31,7 +31,6 @@ import { ScriptedSubject } from "./subject.js";
 import { runScriptedSessions, writeSurfaceTraces } from "./surface-sessions.js";
 import {} from "./types.js";
 import { studyResultIdentity } from "../../run/study-result.js";
-import { actorOf } from "../../study/study-fields.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,7 +38,7 @@ import { actorOf } from "../../study/study-fields.js";
 export async function scriptedStudyRefusal(options, refusal) {
     const { config, dryRun } = options;
     const cwd = path.resolve(options.cwd);
-    const actorType = actorOf(config)?.type ?? "";
+    const actorType = config.actor?.type ?? "";
     if (refusal.beforeScope)
         return {
             ...studyResultIdentity("scripted", config.id),
@@ -95,6 +94,7 @@ async function runScriptedPlanInScope(plan, input, scope) {
         mintRunId: makeScriptedRunId,
         mode: dryRun ? "dry-run" : "live",
         study: plan.study,
+        warnings: plan.warnings,
         // Only a clone subject is served from a sandbox; an app-url run drives a local browser.
         sandboxes: setup.clone ? undefined : "none",
         renderReview: renderScriptedReviewMarkdown,

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

@@ -8,7 +8,7 @@ interface ResolvedScriptedScenario {
     sourceDigest: string;
 }
 /**
- * Resolve and consume `scenario.ref`. Path-style refs (contain a separator or end .yaml/.yml)
+ * Resolve and consume `scenario`. Path-style refs (contain a separator or end .yaml/.yml)
  * resolve against cwd and are clamped inside it: a ../../ escape is rejected, never recorded
  * as repo-relative provenance. Id-style refs must be public-safe tokens and resolve to
  * humanish/scenarios/<ref>.yaml (then .yml). Every failure mode is fail-closed. planScriptedStudy

package/dist/routes/scripted/scenario.js

@@ -1,4 +1,4 @@
-// Resolve a scripted-browser study's `scenario.ref` to a committed scenario file and parse its
+// Resolve a scripted-browser study's `scenario` to a committed scenario file and parse its
 // `browser.steps` into the journey the actor runs. The ref is an id or a repo-relative path that must
 // stay inside the project; provenance records it repo-relative with the scenario's digest.
 import { parse as parseYaml } from "yaml";
@@ -6,11 +6,11 @@ import path from "node:path";
 import { parseBrowserPersonaJourneyFromScenario } from "../../actors/scripted-browser/journey.js";
 import { digestText } from "../../evidence/redaction.js";
 import { readContainedRegularFile, } from "../../run/contained-output.js";
-// Same public-safe token shape the study id uses; an id-style scenario.ref must match it before
+// Same public-safe token shape the study id uses; an id-style `scenario` must match it before
 // it is interpolated into a repo path.
 const SCENARIO_REF_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
 /**
- * Resolve and consume `scenario.ref`. Path-style refs (contain a separator or end .yaml/.yml)
+ * Resolve and consume `scenario`. Path-style refs (contain a separator or end .yaml/.yml)
  * resolve against cwd and are clamped inside it: a ../../ escape is rejected, never recorded
  * as repo-relative provenance. Id-style refs must be public-safe tokens and resolve to
  * humanish/scenarios/<ref>.yaml (then .yml). Every failure mode is fail-closed. planScriptedStudy

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

@@ -47,7 +47,7 @@ export interface ScriptedBrowserStudyResult extends AutomaticAnalysisResult, Stu
         killed: boolean;
     };
     hostDigest?: string;
-    /** The consumed scenario.ref: digest-pinned provenance of the executable steps. */
+    /** The consumed `scenario`: digest-pinned provenance of the executable steps. */
     scenario?: {
         id: string;
         source: string;
@@ -58,7 +58,7 @@ export interface ScriptedBrowserStudyResult extends AutomaticAnalysisResult, Stu
     observer?: ObserverResult;
     warnings: string[];
     error?: {
-        code: "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_SCRIPTED_FAILED" | "HUMANISH_SCRIPTED_ACTOR_UNSUPPORTED" | "HUMANISH_SCRIPTED_SCENARIO_INVALID" | "HUMANISH_SCRIPTED_SUBJECT_UNSAFE" | "HUMANISH_SCRIPTED_BROWSER_MISSING" | "HUMANISH_SCRIPTED_KEYS_MISSING" | "HUMANISH_SCRIPTED_SUBJECT_ENV_MISSING" | "HUMANISH_SCRIPTED_GETHOST_UNAVAILABLE" | "HUMANISH_RUN_ID_IN_USE";
+        code: "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_STUDY_INVALID" | "HUMANISH_SCRIPTED_FAILED" | "HUMANISH_SCRIPTED_ACTOR_UNSUPPORTED" | "HUMANISH_SCRIPTED_SCENARIO_INVALID" | "HUMANISH_SCRIPTED_SUBJECT_UNSAFE" | "HUMANISH_SCRIPTED_BROWSER_MISSING" | "HUMANISH_SCRIPTED_KEYS_MISSING" | "HUMANISH_SCRIPTED_SUBJECT_ENV_MISSING" | "HUMANISH_SCRIPTED_GETHOST_UNAVAILABLE" | "HUMANISH_RUN_ID_IN_USE";
         message: string;
     };
 }

package/dist/routes/shared-world/handoff.js

@@ -30,7 +30,7 @@ const HANDOFF_DEADLINE_BUDGET_FRACTION = 0.4;
 // convergence proof): at most this many single-frame reads before the participant is assumed to be
 // somewhere without a code. Each reader stops the instant it has what it needs, so in practice only
 // a handful fire (a participant reaches its /lobby within a few turns). NOTE: these reads are
-// out-of-band OpenAI calls (external-public route only) and are left out of execution.caps.maxUsd,
+// out-of-band OpenAI calls (external-public route only) and are left out of caps.maxUsd,
 // so this hard cap is what bounds their spend (each read is one cheap single-frame OCR call). If
 // this route ever runs under a strict budget, fold the estimate in.
 const MAX_LOBBY_CODE_VISION_READS = 30;

package/dist/routes/shared-world/participant-specs.js

@@ -200,7 +200,7 @@ export function participantRunDeps(ctx, live, scrubKnownValues) {
  * scrubbed of the run's known secret values.
  */
 export async function buildParticipantSpecs(participants, cwd, scrubKnownValues) {
-    // Only the personas the participants use: an actors[0].persona that every participant overrides
+    // Only the personas the participants use: an actor.persona that every participant overrides
     // is never applied, so it is not read.
     const personaResolution = await resolveCommittedPersonasForCwd(cwd, participants.map((participant) => participant.personaId));
     const actorSpecs = participants.map((participant) => buildActorSpec(participant, personaResolution.personas));

package/dist/routes/shared-world/plan.js

@@ -10,9 +10,8 @@ import { brainOf, planCaps, desktopRequirements, isNonEmpty, planBase, } from ".
 import { sharedWorldParticipants } from "../../study/plan-participants.js";
 import { PUBLIC_TARGET_OWNER_PATTERN } from "../../study/parse/subject.js";
 import { REPO_SLUG_PATTERN } from "../../study/parse/values.js";
-import { concurrentSharedWorldValidationReason, desktopMediaValidationReason, externalPublicSharedWorldValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, scenarioCapsValidationReason, taskProtocolValidationReason, } from "../../study/validation.js";
+import { concurrentSharedWorldValidationReason, desktopMediaValidationReason, externalPublicSharedWorldValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, taskProtocolValidationReason, } from "../../study/validation.js";
 import { MODEL_RATES, unpricedCapMessage } from "../../run/pricing.js";
-import { actorOf, capsOf } from "../../study/study-fields.js";
 /** The registered descriptor for a planned actor; planSharedWorldStudy checked the registry. */
 export function sharedWorldDescriptorOf(actorType) {
     const descriptor = actorRegistry[actorType];
@@ -39,7 +38,7 @@ export function planSharedWorldStudy(config, input) {
     const tasksReason = taskProtocolValidationReason(config, false);
     if (tasksReason)
         return refuse("HUMANISH_STUDY_TASKS_UNSUPPORTED", tasksReason);
-    const actorType = actorOf(config)?.type ?? "";
+    const actorType = config.actor?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isCuaActorDescriptor(descriptor))
         return refuse("HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED", `actor.type "${actorType}" is not a registered computer-use actor.`);
@@ -54,17 +53,16 @@ export function planSharedWorldStudy(config, input) {
     // A library caller's config skips the parser, which refuses these first.
     studyUrlCredentialReason(config) ??
         outputTokenLimitValidationReason(config) ??
-        scenarioCapsValidationReason(config) ??
         (externalPublic
             ? externalPublicSharedWorldValidationReason(config)
             : concurrentSharedWorldValidationReason(config));
     if (invalidReason)
         return refuse(invalid, invalidReason, actor);
-    if (actorOf(config)?.maxOutputTokens !== undefined && input.hasRunSession === true)
+    if (config.actor?.maxOutputTokens !== undefined && input.hasRunSession === true)
         return refuse(invalid, "maxOutputTokens cannot be enforced by a custom runSession.", actor);
-    const caps = capsOf(config, "shared-world");
+    const caps = config.caps;
     if (!input.dryRun && (caps?.maxUsd !== undefined || caps?.maxTotalUsd !== undefined)) {
-        const model = (actorOf(config)?.model ?? DEFAULT_OPENAI_CU_MODEL).trim().toLowerCase();
+        const model = (config.actor?.model ?? DEFAULT_OPENAI_CU_MODEL).trim().toLowerCase();
         if (!MODEL_RATES[model])
             return refuse("HUMANISH_SHARED_WORLD_UNPRICED_CAP", unpricedCapMessage(model), actor);
     }
@@ -107,7 +105,7 @@ export function planSharedWorldStudy(config, input) {
                 ? {}
                 : { sessionTimeoutMs: config.execution.timeoutMs }),
             brain,
-            caps: planCaps(config, "shared-world"),
+            caps: planCaps(config),
             requirements: base.dryRun
                 ? []
                 : [

package/dist/routes/shared-world/route.js

@@ -48,7 +48,7 @@ import { prepareConcurrentRun } from "./setup.js";
 import { browserRouteScorer } from "../../study/adapter-scorer-loader.js";
 import { withLateScorer } from "../../study/route-inputs.js";
 import {} from "./types.js";
-import { actorOf, participantList } from "../../study/study-fields.js";
+import { participantList } from "../../study/study-fields.js";
 /** The shared-world code for each local-agent refusal, kind for kind with computer-use. */
 const LOCAL_AGENT_REFUSAL_CODES = {
     "agent-missing": "HUMANISH_SHARED_WORLD_AGENT_MISSING",
@@ -63,7 +63,7 @@ export function sharedWorldStudyRefusal(options, refusal) {
     const fail = concurrentStudyFailure({
         cwd: path.resolve(options.cwd),
         studyId: config.id,
-        actor: actorOf(config)?.type ?? "",
+        actor: config.actor?.type ?? "",
         participantCount: declared.length,
         // The parser fills concurrency for multi-participant studies, so this fallback serves only
         // library callers: every declared participant runs at once unless the author declared a cap.

package/dist/routes/shared-world/setup.js

@@ -56,6 +56,7 @@ function startConcurrentRun(study, cwd, scope) {
         mintRunId: makeRunId,
         mode: plan.dryRun ? "dry-run" : "live",
         study: plan.study,
+        warnings: plan.warnings,
         renderReview: renderConcurrentReviewMarkdown,
         observer: { open: input.open === true, render: deps.renderObserver },
     });

package/dist/routes/shared-world/types.d.ts

@@ -54,7 +54,7 @@ export interface SharedWorldRunInput {
      *  core-stamped onto the bundle as evidence. Absent for library callers. */
     scorerProvenance?: RunScorerProvenance;
 }
-export type ConcurrentSharedWorldStudyErrorCode = "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_SHARED_WORLD_FAILED" | "HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED" | "HUMANISH_SHARED_WORLD_INVALID" | "HUMANISH_SHARED_WORLD_KEYS_MISSING"
+export type ConcurrentSharedWorldStudyErrorCode = "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_STUDY_INVALID" | "HUMANISH_SHARED_WORLD_FAILED" | "HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED" | "HUMANISH_SHARED_WORLD_INVALID" | "HUMANISH_SHARED_WORLD_KEYS_MISSING"
 /** A local-agent brain's CLI is not on `PATH`. */
  | "HUMANISH_SHARED_WORLD_AGENT_MISSING"
 /** A local-agent brain's CLI is signed out, or could not report its sign-in status. */

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

@@ -1,5 +1,5 @@
 import type { ActorPersonaRef, ActorTrace } from "../../actors/contract.js";
-import type { StudyScenarioCaps, StudyRuntimeAuth } from "../../study/types.js";
+import type { StudyCaps, StudyRuntimeAuth } from "../../study/types.js";
 import { type RunBundle, type RunCostSummary, type BundleRun } from "../../run/bundle.js";
 import { type Verdict } from "../../run/judge.js";
 import type { TerminalLedgers } from "./types.js";
@@ -21,7 +21,7 @@ export declare function buildTerminalProductBundle(args: {
     persona: ActorPersonaRef;
     productName: string;
     publicSurfaces: string[];
-    caps?: StudyScenarioCaps;
+    caps?: StudyCaps;
     runtimeAuth?: string;
     stdin: "disabled" | "planned" | "sent";
     policies: {
@@ -51,7 +51,7 @@ export declare function buildLiveTerminalProductBundle(args: {
     persona: ActorPersonaRef;
     productName: string;
     publicSurfaces: string[];
-    caps?: StudyScenarioCaps;
+    caps?: StudyCaps;
     runtimeAuthKeyName: string;
     runtimeAuth?: StudyRuntimeAuth;
     policies: {

package/dist/routes/terminal/dry-run.js

@@ -30,6 +30,7 @@ export async function runDryTerminalStudy(args) {
         mintRunId: makeTerminalRunId,
         mode: "dry-run",
         study: plan.study,
+        warnings: plan.warnings,
         renderReview: renderTerminalReviewMarkdown,
         observer: { open: input.open === true, render: input.deps?.renderObserver },
     });

package/dist/routes/terminal/ledger.d.ts

@@ -1,5 +1,5 @@
 import type { ActorTokenUsage } from "../../actors/contract.js";
-import type { StudyScenarioCaps } from "../../study/types.js";
+import type { StudyCaps } from "../../study/types.js";
 import { type CostCategory } from "../../run/terminal-contract.js";
 import type { CostLine, NoSpendProof, TerminalCostLedger } from "./types.js";
 /**
@@ -41,7 +41,7 @@ export declare function buildNoSpendProof(ledger: TerminalCostLedger, maxUsd: nu
  * grant a green pass: the no-spend proof reports them as unmeasured. maxMinutes is wall-clock and is
  * enforced separately (runWithWallClock); it is not a ledger-derived cap.
  */
-export declare function evaluateCapsAgainstLedger(ledger: TerminalCostLedger, caps: StudyScenarioCaps): {
+export declare function evaluateCapsAgainstLedger(ledger: TerminalCostLedger, caps: StudyCaps): {
     ok: true;
 } | {
     ok: false;

package/dist/routes/terminal/lifetime.js

@@ -1,5 +1,5 @@
 // How long a live terminal sandbox may live. Its server-side timeout has to cover everything that
-// runs in it before the codex command, the command's own wall clock (scenario.caps.maxMinutes) and
+// runs in it before the codex command, the command's own wall clock (caps.maxMinutes) and
 // the reclamation buffer after that clock's kill. A timeout shorter than that lets E2B kill the
 // sandbox before the command's deadline and before the evidence is read.
 import { NODE_BOOTSTRAP_TIMEOUT_MS } from "../../subject/node-bootstrap.js";

package/dist/routes/terminal/live-finish.js

@@ -23,11 +23,30 @@ function buildLiveTrace(inputs) {
     // chunks before any transcript/trace/event artifact is persisted. Check both each stream and
     // the combined event order that the transcript uses; either view can assemble a split value.
     scrubSplitKnownValues(terminalEvents, knownSecretValues, discardedPrefixes);
-    // Build the actor trace first (the cost ledger reads its tokenUsage).
-    const normalizedTranscript = normalizeLocalActorTranscript(terminalEvents.map((e) => e.chunk).join(""));
+    // Build the actor trace first (the cost ledger reads its tokenUsage). A session past the cap
+    // ends its transcript with what was not stored, and its trace says the same.
+    const cut = inputs.recorder.transcriptCut();
+    const normalizedTranscript = `${normalizeLocalActorTranscript(terminalEvents.map((e) => e.chunk).join(""))}${cut ? `\n[humanish] ${cut.notice}` : ""}`;
     // Parsed from the full stream: usage records arrive once per turn, and the tail
-    // would drop all but the last.
-    const terminalTokenUsage = parseTerminalTokenUsage(normalizedTranscript);
+    // would drop all but the last. Records past the cap were kept as they arrived.
+    const terminalTokenUsage = parseTerminalTokenUsage([normalizedTranscript, ...(cut?.usage ?? [])].join("\n"));
+    const read = inputs.recorder.participantText.finish();
+    const participant = cut
+        ? {
+            ...read,
+            items: [
+                ...read.items,
+                {
+                    id: "notice-transcript",
+                    kind: "notice",
+                    lifecycle: "completed",
+                    status: "truncated",
+                    title: "terminal output truncated",
+                    text: cut.notice,
+                },
+            ],
+        }
+        : read;
     const trace = buildTerminalActorTrace({
         persona,
         productName: product.name,
@@ -40,7 +59,7 @@ function buildLiveTrace(inputs) {
         terminalEvents,
         commandLog,
         transcriptTail: tailOf(normalizedTranscript),
-        participant: inputs.recorder.participantText.finish(),
+        participant,
         runtimeAuth: runtimeEnv.mode,
         runtime,
         ...(terminalTokenUsage === undefined ? {} : { tokenUsage: terminalTokenUsage }),
@@ -117,7 +136,7 @@ export async function finishLiveTerminalSession(inputs) {
     const judgment = judgeTerminal({ dryRun: false, participant });
     // The run cost summary, as the computer-use route records it: the sandbox's compute time from
     // its span and observed size, and the participant's tokens (unpriced for Codex). It is not part
-    // of the cap ledger above, whose lines sum against scenario.caps.maxUsd.
+    // of the cap ledger above, whose lines sum against caps.maxUsd.
     const desktops = session.runCostDesktops();
     const runCost = buildRunCostSummary({
         participants: [{ trace }],

package/dist/routes/terminal/live-sandbox.js

@@ -349,9 +349,13 @@ export class LiveTerminalSandbox {
         });
         // Score by the verdict-nonce marker over the scrubbed, redacted and normalized transcript, with
         // the exact same logic the local-actor routes use (extractLocalActorVerdict/normalizeLocalActorTranscript).
+        // Output past the transcript cap is scanned as it arrives, since it is not stored.
         const rawTranscript = terminalEvents.map((e) => e.chunk).join("");
         const normalizedTranscript = normalizeLocalActorTranscript(rawTranscript);
-        const markerStatus = extractLocalActorVerdict(normalizedTranscript, verdictNonce);
+        const cut = this.inputs.recorder.transcriptCut();
+        const markerStatus = extractLocalActorVerdict(normalizedTranscript, verdictNonce) ?? cut?.verdict ?? null;
+        if (cut)
+            recordLifecycle("terminal-lab.transcript.exceeded", cut.notice);
         if (this.timedOut) {
             this.status = "timed_out";
             this.completionReason = "timed_out";

package/dist/routes/terminal/plan.js

@@ -13,7 +13,6 @@ import { NODE_BOOTSTRAP_TIMEOUT_MS } from "../../subject/node-bootstrap.js";
 import { terminalSandboxTimeoutMs } from "./lifetime.js";
 import { isExactRuntimeVersion, TERMINAL_RUNTIME_VERSION_TIMEOUT_MS } from "./runtime.js";
 import { PRODUCT_SETUP_TIMEOUT_MS, TERMINAL_SANDBOX_TIMEOUT_BUFFER_MS, } from "./types.js";
-import { actorOf, capsOf } from "../../study/study-fields.js";
 /**
  * Plan a terminal-product study. It is called for any config handed to the terminal runner, not
  * only one routeOf sends here, so a config for another route gets this route's refusal.
@@ -41,12 +40,12 @@ export function planTerminalStudy(config, input) {
     const tasksReason = taskProtocolValidationReason(config, false);
     if (tasksReason)
         return refuse("HUMANISH_STUDY_TASKS_UNSUPPORTED", tasksReason);
-    const actorType = actorOf(config)?.type ?? "";
+    const actorType = config.actor?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isTerminalActorDescriptor(descriptor))
         return refuse("HUMANISH_TERMINAL_ACTOR_UNSUPPORTED", `actor.type "${actorType}" is not a registered terminal actor.`);
     const runtimeVersion = config.execution?.runtime?.version;
-    const actor = actorOf(config);
+    const actor = config.actor;
     if ((config.execution?.runtime !== undefined && !isExactRuntimeVersion(runtimeVersion)) ||
         (actor?.model !== undefined &&
             (typeof actor.model !== "string" || actor.model.trim().length === 0)) ||
@@ -84,7 +83,7 @@ export function planTerminalStudy(config, input) {
         ...(egressAllow === undefined ? {} : { egressAllow }),
         ...(stdin === undefined ? {} : { stdin }),
     };
-    const caps = capsOf(config, "terminal");
+    const caps = config.caps;
     if (input.dryRun)
         return { ok: true, plan: { ...shared, dryRun: true, ...(caps ? { caps } : {}) } };
     // The live route injects the runtime key into one command only, and only a registered actor

package/dist/routes/terminal/recorder.d.ts

@@ -8,6 +8,7 @@ export declare function createTerminalRecorder(args: {
     nowIso: () => string;
     sanitize: (text: string) => string;
     knownSecretValues: readonly string[];
+    verdictNonce: string;
 }): {
     lifecycle: LifecycleRecord[];
     commandLog: CommandLogRecord[];
@@ -22,6 +23,11 @@ export declare function createTerminalRecorder(args: {
         append(raw: string): void;
         finish(): import("./participant-text.js").TerminalParticipantText;
     };
+    transcriptCut: () => {
+        notice: string;
+        verdict: ReturnType<() => ("blocked" | "failed" | "passed") | null>;
+        usage: string[];
+    } | undefined;
     recordLifecycle: (event: string, message: string) => void;
     recordStreamedTerminalChunk: (stream: "stdout" | "stderr", raw: string) => void;
     appendReturnedTerminalOutput: (stream: "stdout" | "stderr", raw: string) => void;

package/dist/routes/terminal/recorder.js

@@ -1,13 +1,15 @@
 import { createHash } from "node:crypto";
+import { createLocalActorVerdictScanner } from "../../run/terminal-contract.js";
 import { createTerminalParticipantReader } from "./participant-text.js";
-import { MAX_TRANSCRIPT_BYTES, } from "./types.js";
+import { terminalUsageRecords } from "./token-usage.js";
+import { MAX_TRANSCRIPT_BYTES, PENDING_LINE_CHARS, } from "./types.js";
 /**
  * The terminal run's ledgers and capture buffers, mutated through the live lifecycle. Every chunk
  * is scrubbed and redacted as it is stored. Raw bytes leave the append functions only for the
  * in-memory participant reader, which keeps sanitized decoded text.
  */
 export function createTerminalRecorder(args) {
-    const { nowIso, sanitize, knownSecretValues } = args;
+    const { nowIso, sanitize, knownSecretValues, verdictNonce } = args;
     const lifecycle = [];
     const commandLog = [];
     const terminalEvents = [];
@@ -19,24 +21,76 @@ export function createTerminalRecorder(args) {
     // Reads the agent's text from the raw stdout in memory; it keeps only sanitized decoded text.
     const participantText = createTerminalParticipantReader(sanitize);
     let transcriptBytes = 0;
+    // Output past the cap is not stored, but the participant reader, the verdict marker and token
+    // usage still read all of it, so a long session is judged and priced as a short one is.
+    const notStored = { stdout: 0, stderr: 0 };
+    const laterVerdict = createLocalActorVerdictScanner(verdictNonce);
+    const laterUsage = [];
+    // The stdout line in progress past the cap. Undefined while the rest of a line is skipped: the
+    // line the cap cut through (its start is stored) or one longer than the pending limit.
+    let laterLine;
+    let stdoutAtLineStart = true;
+    let pastCap = false;
+    const readLaterStdout = (raw) => {
+        let text = raw;
+        if (laterLine === undefined) {
+            const end = text.indexOf("\n");
+            if (end < 0)
+                return;
+            text = text.slice(end + 1);
+            laterLine = "";
+        }
+        laterLine += text;
+        const end = laterLine.lastIndexOf("\n");
+        if (end >= 0) {
+            laterUsage.push(...terminalUsageRecords(sanitize(laterLine.slice(0, end))));
+            laterLine = laterLine.slice(end + 1);
+        }
+        if (laterLine.length > PENDING_LINE_CHARS)
+            laterLine = undefined;
+    };
     const recordLifecycle = (event, message) => {
         lifecycle.push({ at: nowIso(), event, message: sanitize(message) });
     };
     const appendTerminalChunk = (stream, raw) => {
+        if (stream === "stdout")
+            participantText.append(raw);
         if (transcriptBytes >= MAX_TRANSCRIPT_BYTES) {
             for (const order of [stream, "combined"]) {
                 const remaining = maxDiscardedPrefixChars - discardedPrefixes[order].length;
                 if (remaining > 0)
                     discardedPrefixes[order] += raw.slice(0, remaining);
             }
+            if (!pastCap) {
+                pastCap = true;
+                // The stored stream seeds the scan, so a marker the cap split in two is still found.
+                laterVerdict.push(terminalEvents.map((event) => event.chunk).join(""));
+                laterLine = stdoutAtLineStart ? "" : undefined;
+            }
+            notStored[stream] += Buffer.byteLength(raw, "utf8");
+            laterVerdict.push(sanitize(raw));
+            if (stream === "stdout")
+                readLaterStdout(raw);
             return;
         }
         transcriptBytes += Buffer.byteLength(raw, "utf8");
-        // Scrub, then redact, at the source. Only the participant reader below
-        // sees the raw bytes, and it stores none of them.
+        // Scrub, then redact, at the source. Only the participant reader and the readers of output
+        // past the cap see raw bytes, and they store none of them.
         terminalEvents.push({ at: nowIso(), stream, chunk: sanitize(raw) });
-        if (stream === "stdout")
-            participantText.append(raw);
+        if (stream === "stdout" && raw)
+            stdoutAtLineStart = raw.endsWith("\n");
+    };
+    /** What the cap left out, for the transcript, the trace and the run events; undefined when the
+     *  whole session was stored. */
+    const transcriptCut = () => {
+        if (!pastCap)
+            return undefined;
+        const bytes = notStored.stdout + notStored.stderr;
+        return {
+            notice: `Output past the ${MAX_TRANSCRIPT_BYTES / 1024} KiB transcript cap was not stored: ${bytes} bytes (${notStored.stdout} stdout, ${notStored.stderr} stderr). The verdict marker, token usage and agent messages were still read from it.`,
+            verdict: laterVerdict.verdict(),
+            usage: laterUsage,
+        };
     };
     // E2B can stream every byte through callbacks and return the same complete output.
     // Track transport delivery, independently per stream, rather than deduplicating participant
@@ -78,6 +132,7 @@ export function createTerminalRecorder(args) {
         interventions,
         discardedPrefixes,
         participantText,
+        transcriptCut,
         recordLifecycle,
         recordStreamedTerminalChunk,
         appendReturnedTerminalOutput,

package/dist/routes/terminal/route.js

@@ -17,7 +17,7 @@
 //      spending. Opt-in openai-env injects the raw key command-scoped, never through
 //      Sandbox.create({envs}).
 //      Enforced in credentials.ts and runtime-auth.ts.
-//   2. Fail-closed cap. The live key is never exercised without scenario.caps in force: maxUsd
+//   2. Fail-closed cap. The live key is never exercised without `caps` in force: maxUsd
 //      (default/require 0 = no-spend) + maxMinutes (wall-clock kill of the codex command).
 //      Enforced in plan.ts (caps required), live-sandbox.ts and lifetime.ts (the wall clock).
 //   3. Public surfaces only. The mission references only subject.product.publicSurfaces + the
@@ -54,7 +54,6 @@ import { terminalRouteScorer } from "../../study/adapter-scorer-loader.js";
 import { withLateScorer } from "../../study/route-inputs.js";
 import {} from "./types.js";
 import { studyResultIdentity } from "../../run/study-result.js";
-import { actorOf } from "../../study/study-fields.js";
 /** A refused terminal study's result: the route's envelope, and the analysis record a refusal gets. */
 export function terminalStudyRefusal(options, refusal) {
     const { config, dryRun } = options;
@@ -62,7 +61,7 @@ export function terminalStudyRefusal(options, refusal) {
         ...studyResultIdentity("terminal", config.id),
         ok: false,
         cwd: path.resolve(options.cwd),
-        actor: refusal.actor ?? actorOf(config)?.type ?? "",
+        actor: refusal.actor ?? config.actor?.type ?? "",
         product: config.subject.product?.name ?? "",
         dryRun,
         runId: options.runId ?? "not-created",