humanish 0.111.0 → 0.111.2

package/dist/routes/computer-use/bundle-parts.d.ts

@@ -43,6 +43,10 @@ export declare function providerResourcesForOutcome(args: {
     ids: ParticipantIds;
     participantId: string;
 }): RunProviderResource[];
+/**
+ * The app URL as a run records it: the URL, or its digest when verify would flag it. verify reads the
+ * URL decoded, so an E2B URL percent-encoded in a parameter gets the digest too.
+ */
 export declare function publicSafeAppUrlLabel(url: string): string;
 /** Short id-safe suffix for a subject-phase RunEvent: drops the shared prefix/suffix so each
  *  phase gets a distinct bundle event id (e.g. "clone", "state-before-build"). */

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

@@ -3,7 +3,8 @@
 // public-safe app URL label, the URL digest and the subject-phase event id suffix. The builders are bundle.ts (the dispatcher and the judge),
 // single-bundle.ts and fanout-bundle.ts.
 import { feedbackProofCommands } from "../../feedback/proof.js";
-import { containsSensitive, digestText, redactText } from "../../evidence/redaction.js";
+import { scanEncodedText } from "../../evidence/encoded-text.js";
+import { digestText, redactText } from "../../evidence/redaction.js";
 import {} from "../../run/bundle.js";
 import { participantResourceIds } from "../../run/participant-records.js";
 import { resolveSelfReportedFriction } from "./self-report.js";
@@ -169,8 +170,12 @@ export function providerResourcesForOutcome(args) {
         },
     ];
 }
+/**
+ * The app URL as a run records it: the URL, or its digest when verify would flag it. verify reads the
+ * URL decoded, so an E2B URL percent-encoded in a parameter gets the digest too.
+ */
 export function publicSafeAppUrlLabel(url) {
-    return containsSensitive(url) ? `[target-url:${digestUrl(url)}]` : url;
+    return scanEncodedText(url).sensitive ? `[target-url:${digestUrl(url)}]` : url;
 }
 /** Short id-safe suffix for a subject-phase RunEvent: drops the shared prefix/suffix so each
  *  phase gets a distinct bundle event id (e.g. "clone", "state-before-build"). */

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

@@ -4,7 +4,7 @@ import { actorEnding } from "../../actors/stop-cause.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
-import { participantFeedbackCandidates, providerResourcesForOutcome } from "./bundle-parts.js";
+import { participantFeedbackCandidates, providerResourcesForOutcome, publicSafeAppUrlLabel, } from "./bundle-parts.js";
 import { participantFactsOf } from "./participant-facts.js";
 import { participantPassed, participantStatus } from "../../run/judge.js";
 import { buildRunCostSummary, desktopSpanToMinutes } from "../../run/cost-summary.js";
@@ -72,10 +72,12 @@ function fanoutReview(args, streams) {
         verdict,
         ...(participants === undefined ? {} : { participants }),
         ...(runTasks === undefined ? {} : { tasks: runTasks }),
+        // The app URL is named as the participant records name it: one on an E2B host names a
+        // sandbox, so the summary carries its digest, which verify accepts in a shared run.
         summary: args.inProgress === true
             ? `Live computer-use fan-out is running (${specs.length} participants, one world each); terminal participant evidence has not been written yet.`
             : args.dryRun
-                ? `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Dry-run fan-out: ${specs.length} participants composed for ${args.descriptor.id} against ${args.appUrl}, one world each; no desktops launched, $0 spend.`
+                ? `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Dry-run fan-out: ${specs.length} participants composed for ${args.descriptor.id} against ${publicSafeAppUrlLabel(args.appUrl)}, one world each; no desktops launched, $0 spend.`
                 : `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Computer-use fan-out (${specs.length} participants, one world each): ${passedParticipants}/${plural(specs.length, "participant")} reached a terminal, engaged verdict${participants ? `: ${formatParticipantOutcomes(participants, participantEndings)}` : ""}${runTasks ? `; tasks: ${formatRunTaskFunnel(runTasks)}` : ""}.`,
         gaps: args.inProgress === true
             ? ["Live fan-out session is still running."]

package/dist/routes/computer-use/local-vm.js

@@ -10,7 +10,6 @@ import { createRestrictedCodexParticipant } from "../../actors/codex/restricted-
 import { withCloseReport } from "./participant-model.js";
 import { guestMediaConfigSchema } from "../../guest/media-config.js";
 import { startLocalCapturedInbox } from "../../substrates/local/captured-inbox.js";
-import { actorOf } from "../../study/study-fields.js";
 function guestMedia(config) {
     const declaredMedia = config.execution?.desktop?.media;
     return declaredMedia === undefined
@@ -165,7 +164,7 @@ export function prepareLocalVmRun(options) {
     const media = guestMedia(config);
     // A caller-supplied provider replaces the Codex account participant, so the account is
     // neither checked nor used.
-    const account = actorOf(config)?.type === "local-agent" && options.createProvider === undefined;
+    const account = config.actor?.type === "local-agent" && options.createProvider === undefined;
     const state = { sessions: [], participants: [], cleanupUnconfirmed: false };
     const context = {
         config,

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

@@ -228,10 +228,15 @@ export async function recordParticipantTrace(spec, deps, session, warnings) {
  * carried it on every request. It says why, and how many early turns became a text summary.
  */
 export function explicitContextWarning(conversation) {
+    const answer = conversation.rejection === "stored_item"
+        ? " (a stored item the request referenced was not found)"
+        : conversation.rejection === "previous_response"
+            ? " (the previous response was refused or not found)"
+            : "";
     const why = conversation.explicitReason === "zdr_rejection"
         ? `The OpenAI organization rejected server-side conversation state (zero data retention)${conversation.switchedAtRequest === undefined
             ? ""
-            : ` on request ${conversation.switchedAtRequest}`}`
+            : ` on request ${conversation.switchedAtRequest}`}${answer}`
         : "zeroDataRetention is set";
     const summarized = conversation.summarizedTurns === 0
         ? ""

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

@@ -16,7 +16,6 @@ import { isLocalBrowserStudy } from "../../substrates/local/runtime-config.js";
 import { boundedConcurrency, defaultSessionTimeoutMs, resolveParticipantSandboxMs, } from "./participant-runs.js";
 import { MAX_SANDBOX_MS } from "../../substrates/e2b/lifetime.js";
 import {} from "./types.js";
-import { actorOf, declaresSharedWorld } from "../../study/study-fields.js";
 /** The registered descriptor for a planned actor id; planComputerUseStudy checked the registry. */
 export function cuaDescriptorOf(actor) {
     const descriptor = actorRegistry[actor];
@@ -87,7 +86,7 @@ function unsupportedDeclarationReason(config, hasRunSession, driving, { inProces
     const reason = desktopMediaValidationReason(config) || outputTokenLimitValidationReason(config);
     if (reason)
         return invalid(reason);
-    if (actorOf(config)?.maxOutputTokens !== undefined &&
+    if (config.actor?.maxOutputTokens !== undefined &&
         (hasRunSession || driving.createProvider || driving.inProcess))
         return invalid("maxOutputTokens cannot be enforced by a custom runSession/provider/executor route.");
     const receivingReason = receivingEmailValidationReason(config);
@@ -219,7 +218,7 @@ export function planComputerUseStudy(config, input) {
     if (tasksReason)
         return refuse("before-scope", "HUMANISH_STUDY_TASKS_UNSUPPORTED", tasksReason);
     // The parser checks the actor too; a library caller skips the parser.
-    const actorType = actorOf(config)?.type ?? "";
+    const actorType = config.actor?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isCuaActorDescriptor(descriptor))
         return refuse("in-scope", "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED", `actor.type "${actorType}" is not a registered computer-use actor.`);
@@ -230,7 +229,7 @@ export function planComputerUseStudy(config, input) {
     // A shared world runs every participant against one app; this route would run them as separate
     // participants. It comes after the rules above, so a shared-world config that breaks one of them,
     // which runStudyWith sends here, still gets that rule's message.
-    if (declaresSharedWorld(config))
+    if (config.route === "shared-world")
         return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "route: shared-world studies run every participant against one shared app on the shared-world route; this route runs independent participants. The shared-world route takes subject.source clone or local-tree, or app-url with policies.allowPublicTargets: true, on execution.target e2b-desktop.", actor);
     // The in-process route drives subject.appUrl on this machine and creates no desktop, so it would
     // skip the subject a clone, local-tree or desktop-cli study declares.

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

@@ -32,7 +32,6 @@ import { runStudyParticipants } from "./live-phase.js";
 import { admitCuaRun, refuseCuaStudy, startCuaRun } from "./setup.js";
 import {} from "./types.js";
 import { studyResultIdentity } from "../../run/study-result.js";
-import { actorOf } from "../../study/study-fields.js";
 /**
  * A refused computer-use study's result, at the refusal's stage: a before-scope refusal has its own
  * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
@@ -45,7 +44,7 @@ export async function computerUseStudyRefusal(options, refusal) {
             ...studyResultIdentity("computer-use", config.id),
             ok: false,
             cwd: path.resolve(options.cwd),
-            actor: actorOf(config)?.type ?? "",
+            actor: config.actor?.type ?? "",
             dryRun,
             runId: options.runId ?? "not-created",
             appUrl: config.subject.appUrl ?? config.subject.serve?.url ?? "",

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/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

@@ -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/shared-world/plan.js

@@ -12,7 +12,6 @@ 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, 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.`);
@@ -59,11 +58,11 @@ export function planSharedWorldStudy(config, input) {
             : 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);
+    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);
     }

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/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/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 }),

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);
+    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

@@ -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",

package/dist/routes/terminal/session.js

@@ -61,6 +61,7 @@ export async function runLiveTerminalSession(args) {
         // This entry point is the live terminal route; its dry-run sibling is a separate function.
         mode: "live",
         study: plan.study,
+        warnings: plan.warnings,
         renderReview: renderTerminalReviewMarkdown,
         observer: { open: input.open === true, render: deps.renderObserver },
         now,
@@ -77,7 +78,7 @@ export async function runLiveTerminalSession(args) {
     });
     const e2bApiKey = env.E2B_API_KEY?.trim() ?? "";
     // The ledgers + capture buffers, mutated through the live lifecycle.
-    const recorder = createTerminalRecorder({ nowIso, sanitize, knownSecretValues });
+    const recorder = createTerminalRecorder({ nowIso, sanitize, knownSecretValues, verdictNonce });
     const { version, model, modelSource, reasoningEffort } = plan.runtime;
     const runtime = declaredRuntimeProvenance({
         ...(version === undefined ? {} : { version }),

package/dist/routes/terminal/token-usage.d.ts

@@ -1,4 +1,7 @@
 import type { ActorTokenUsage } from "../../actors/contract.js";
+/** The usage records in complete stdout lines, kept from output past the transcript cap so
+ *  parseTerminalTokenUsage can count them with the stored ones. */
+export declare function terminalUsageRecords(lines: string): string[];
 /**
  * Accumulate runtime-turn usage from a captured `codex exec --json` stream. A Codex turn may
  * include multiple provider requests; these records cannot establish per-request pricing tiers.

package/dist/routes/terminal/token-usage.js

@@ -19,6 +19,11 @@ const USAGE_RE = /"type"\s*:\s*"turn\.completed"\s*,\s*"usage"\s*:\s*(\{[^}\n]*\
 function num(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
+/** The usage records in complete stdout lines, kept from output past the transcript cap so
+ *  parseTerminalTokenUsage can count them with the stored ones. */
+export function terminalUsageRecords(lines) {
+    return Array.from(lines.matchAll(USAGE_RE), (match) => match[0]);
+}
 /**
  * Accumulate runtime-turn usage from a captured `codex exec --json` stream. A Codex turn may
  * include multiple provider requests; these records cannot establish per-request pricing tiers.

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

@@ -53,7 +53,8 @@ export interface TerminalProductScoringContext {
     /**
      * The full normalized transcript of the in-sandbox agent session, scrubbed (literal known
      * values) then redacted (shape patterns) at the source, capped at MAX_TRANSCRIPT_BYTES, and
-     * byte-identical to the persisted terminal-transcript.txt artifact. The trace's transcriptTail
+     * byte-identical to the persisted terminal-transcript.txt artifact. A capped transcript ends
+     * with a `[humanish]` line giving the byte count that was not stored. The trace's transcriptTail
      * is a ~2KB projection of this; a scorer needs the whole session so a rubric can find
      * command-tier evidence anywhere in it.
      */

package/dist/routes/terminal/types.js

@@ -32,5 +32,6 @@ export const TEXT_ITEMS_BYTES = 128 * 1024;
 // The longest stdout line the participant reader holds while waiting for its newline.
 export const PENDING_LINE_CHARS = 1024 * 1024;
 // Hard cap on the retained event-stream + transcript size, so a runaway agent cannot balloon the
-// bundle. Redaction runs pre-truncation so a cut can never split a secret past the scrubber.
+// bundle. Redaction runs pre-truncation so a cut can never split a secret past the scrubber. Output
+// past the cap is still read for the verdict marker, token usage and the trace's agent text.
 export const MAX_TRANSCRIPT_BYTES = 512 * 1024;