humanish 0.111.0 → 0.111.1

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;

package/dist/run/dry-run.js

@@ -67,6 +67,7 @@ async function runDryRunInScope(options, scope) {
         mintRunId: () => `dryrun-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`,
         mode: options.dryRun ? "dry-run" : "live",
         study: options.study,
+        warnings: options.warnings,
         renderReview: renderReviewMarkdown,
         // The run starts at the time its id and source were stamped with.
         now: () => Date.parse(createdAt),

package/dist/run/results.d.ts

@@ -5,6 +5,8 @@ export declare const CLEANUP_SCHEMA = "humanish.cleanup-result.v1";
 export interface RunOptions {
     /** Which manifest produced this run. */
     study?: RunStudyProvenance;
+    /** Warnings about the study's own fields, recorded in the bundle as warn events. */
+    warnings?: readonly string[];
     cwd: string;
     dryRun?: boolean;
     runId?: string;

package/dist/run/run.d.ts

@@ -22,6 +22,8 @@ interface StartRunOptions {
     };
     /** Clock for `createdAt` and the latest pointer. */
     now?: (() => number) | undefined;
+    /** Warnings about the study's own fields. Every bundle write records each as a warn event. */
+    warnings?: readonly string[] | undefined;
 }
 /** How a run ended as an execution, as run.json records it: the result's ok and execution outcome. */
 interface RecordedOutcome {

package/dist/run/run.js

@@ -5,7 +5,7 @@
 import { redactText } from "../evidence/redaction.js";
 import { buildObserverData } from "../observer/data.js";
 import { renderObserver } from "../observer/render.js";
-import { RUN_BUNDLE_FILE, PUBLIC_TARGET_CWD } from "./bundle.js";
+import { RUN_BUNDLE_FILE, PUBLIC_TARGET_CWD, } from "./bundle.js";
 import { judgeExecution, } from "./judge.js";
 import {} from "./results.js";
 import { createRunArtifactPaths, validatePreparedRunArtifactPaths, } from "./paths.js";
@@ -112,8 +112,20 @@ function observerTarget(options) {
         };
 }
 function runPublisher(args) {
-    const { options, runId, paths, runStatus, now, admit, participantsRan } = args;
+    const { options, runId, createdAt, paths, runStatus, now, admit, participantsRan } = args;
     const observer = observerTarget(options);
+    // The study's warnings join whatever events the route wrote, once, in every write.
+    const studyWarnings = (options.warnings ?? []).map((message, index) => ({
+        id: `event-study-warning-${String(index + 1).padStart(3, "0")}`,
+        at: createdAt,
+        level: "warn",
+        type: "study.warning",
+        message,
+    }));
+    const withStudyWarnings = (events) => [
+        ...events.filter((event) => !studyWarnings.some((warning) => warning.id === event.id)),
+        ...studyWarnings,
+    ];
     let pointerWritten = false;
     // The bundle of the last write asked for, and the outcome every later write carries once a
     // signal stopped the run, so no write after the interrupt can drop it.
@@ -145,6 +157,7 @@ function runPublisher(args) {
         const recorded = interrupted ?? outcome;
         const publicBundle = await withPublicSandboxIds(paths, {
             ...evidence,
+            events: withStudyWarnings(evidence.events),
             cwd: PUBLIC_TARGET_CWD,
             ...(recorded === undefined ? {} : { outcome: recorded }),
         });
@@ -271,6 +284,7 @@ export async function runScope(fn) {
         const publisher = runPublisher({
             options,
             runId,
+            createdAt,
             paths,
             runStatus,
             now,

package/dist/run/terminal-contract.d.ts

@@ -22,4 +22,14 @@ type ActorVerdict = "passed" | "blocked" | "failed";
  * divergent verdict logic would let the two routes disagree about what "passed" means.
  */
 export declare function extractLocalActorVerdict(transcript: string, verdictNonce: string): ActorVerdict | null;
+/**
+ * The same search over text that arrives in pieces and is not kept: the terminal route reads
+ * output past its transcript cap through this. Each piece is normalized and loses its whitespace
+ * as the whole transcript does above, and the end of the previous piece is carried so a marker
+ * split between pieces is found. The first marker wins, as above.
+ */
+export declare function createLocalActorVerdictScanner(verdictNonce: string): {
+    push(text: string): void;
+    verdict(): ActorVerdict | null;
+};
 export {};

package/dist/run/terminal-contract.js

@@ -27,6 +27,9 @@ export function normalizeLocalActorTranscript(transcript) {
         .replace(/\r/g, "\n")
         .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
 }
+// The nonce is mandatory: a bare HUMANISH_ACTOR_VERDICT=<status> marker echoed by an actor (or
+// replayed from untrusted text) must never satisfy verdict extraction.
+const verdictPattern = (verdictNonce) => new RegExp(`HUMANISH_ACTOR_VERDICT=(passed|blocked|failed)HUMANISH_ACTOR_NONCE=${escapeRegExp(verdictNonce)}`, "i");
 /**
  * Extract the per-run verdict from a normalized transcript: the agent must print exactly
  * `HUMANISH_ACTOR_VERDICT=<status> HUMANISH_ACTOR_NONCE=<nonce>`, and the nonce is mandatory so a
@@ -35,13 +38,28 @@ export function normalizeLocalActorTranscript(transcript) {
  * divergent verdict logic would let the two routes disagree about what "passed" means.
  */
 export function extractLocalActorVerdict(transcript, verdictNonce) {
-    const compactTranscript = transcript.replace(/\s+/g, "");
-    // The per-run nonce is mandatory: a bare HUMANISH_ACTOR_VERDICT=<status>
-    // marker echoed by an actor (or replayed from untrusted text) must never
-    // satisfy verdict extraction.
-    const match = new RegExp(`HUMANISH_ACTOR_VERDICT=(passed|blocked|failed)HUMANISH_ACTOR_NONCE=${escapeRegExp(verdictNonce)}`, "i").exec(compactTranscript);
-    if (!match) {
-        return null;
-    }
-    return match[1]?.toLowerCase();
+    const match = verdictPattern(verdictNonce).exec(transcript.replace(/\s+/g, ""));
+    return match?.[1]?.toLowerCase() ?? null;
+}
+/**
+ * The same search over text that arrives in pieces and is not kept: the terminal route reads
+ * output past its transcript cap through this. Each piece is normalized and loses its whitespace
+ * as the whole transcript does above, and the end of the previous piece is carried so a marker
+ * split between pieces is found. The first marker wins, as above.
+ */
+export function createLocalActorVerdictScanner(verdictNonce) {
+    const pattern = verdictPattern(verdictNonce);
+    const carried = `HUMANISH_ACTOR_VERDICT=blockedHUMANISH_ACTOR_NONCE=${verdictNonce}`.length - 1;
+    let tail = "";
+    let found = null;
+    return {
+        push(text) {
+            if (found)
+                return;
+            const window = tail + normalizeLocalActorTranscript(text).replace(/\s+/g, "");
+            found = pattern.exec(window)?.[1]?.toLowerCase() ?? null;
+            tail = window.slice(-carried);
+        },
+        verdict: () => found,
+    };
 }