humanish 0.133.1 → 0.134.0

package/dist/verify/verify.js

@@ -7,9 +7,9 @@ import { containsSensitiveJson } from "../evidence/sensitive-json.js";
 import { keyedSandboxIds, readRunSandboxIds } from "../run/sandbox-ids.js";
 import { validatePreparedRunArtifactPaths } from "../run/paths.js";
 import { isReadRunBundleSchema, RUN_BUNDLE_FILE, RUN_BUNDLE_SCHEMA, RUN_BUNDLE_V1_SCHEMA, RUN_BUNDLE_V2_SCHEMA, RUN_BUNDLE_V3_SCHEMA, } from "../run/bundle.js";
-import { ContainedReadRefusedError, refusalText } from "../run/contained-output.js";
+import { ContainedReadRefusedError, readContainedRegularFile, refusalText, RUN_ARTIFACT_MAX_BYTES, } from "../run/contained-output.js";
 import { isCleanupResult, isRunBundle } from "../run/bundle-shape.js";
-import { loadStreamTraces } from "../run/stream-trace.js";
+import { loadStreamTraces, StreamTraceTooLargeError } from "../run/stream-trace.js";
 import { readRunJsonIfExists, readRunTextIfExists, resolveRunPath, runJsonValue, } from "../run/locate.js";
 import { SANDBOX_RECEIPTS_ARTIFACT } from "../run/sandbox-receipts.js";
 import { isRecord } from "../run/type-guards.js";
@@ -79,7 +79,8 @@ export async function verifyResolvedRun(cwd, runInput, runPaths) {
     const bundlePath = path.join(runPaths.absoluteRunRoot, RUN_BUNDLE_FILE);
     const bundleRead = await readRunJsonIfExists(runPaths, RUN_BUNDLE_FILE);
     // Every check below reads the streams with their traces loaded; a trace that does not match its
-    // index fails the evidence-artifacts check and its stream is checked without its items.
+    // index fails the evidence-artifacts check, and its stream, like one past the read limit, is
+    // checked without its items.
     const traces = await loadTraces(runPaths, runJsonValue(bundleRead));
     const { bundle, recorded, refusedTraces } = traces;
     const cleanupRead = await readRunJsonIfExists(runPaths, "cleanup.json");
@@ -102,9 +103,7 @@ export async function verifyResolvedRun(cwd, runInput, runPaths) {
         unscannedArtifacts.files.push(SANDBOX_RECEIPTS_ARTIFACT);
     }
     const publicSafetyFindings = await scanRunPublicSafetyArtifacts(runPaths, derivedPublicSafetyFindings, {
-        recordingPaths: new Set(bundle
-            ? bundle.streams.flatMap((stream) => (stream.recording ? [stream.recording.path] : []))
-            : []),
+        recordingPaths: recordingPaths(bundle),
         screenshotPaths: bundle ? streamScreenshotPaths(bundle) : new Set(),
         // A run from before 0.110 with no receipts still names its ids in run.json.
         sandboxIds: [...new Set([...journaledSandboxIds, ...keyedSandboxIds(recorded)])],
@@ -127,7 +126,7 @@ export async function verifyResolvedRun(cwd, runInput, runPaths) {
             : `public-safety findings: ${publicSafetyFindings.slice(0, 5).join(", ")}`,
     });
     const missingEvidenceArtifacts = bundle
-        ? await missingLocalEvidenceArtifacts(runPaths, bundle)
+        ? await missingLocalEvidenceArtifacts(runPaths, bundle, traces.pastReadLimit)
         : [];
     const redactedShapeFrames = bundle
         ? await redactedShapeFramePaths(runPaths, bundle)
@@ -155,6 +154,7 @@ export async function verifyResolvedRun(cwd, runInput, runPaths) {
         : { warnings: [], unfinished: undefined };
     const warnings = bundle
         ? [
+            ...traces.unreadTraces,
             ...rawScreenshotPostureWarnings(bundle, redactedShapeFrames),
             ...undeclaredSubjectStateWarnings(bundle),
             ...desktopGeometryWarnings(bundle),
@@ -238,6 +238,8 @@ async function loadTraces(runPaths, stored) {
             recorded: stored,
             refusedTraces: [],
             refusedStreams: new Set(),
+            unreadTraces: [],
+            pastReadLimit: new Set(),
             ...scanned,
             pages: [],
         };
@@ -250,15 +252,34 @@ async function loadTraces(runPaths, stored) {
                 scanned[scan === "sensitive" ? "sensitive" : "opaque"].push(file);
         },
     });
+    // A file whose index records more than the read limit is not read. One past the limit on disk
+    // too is listed as unscanned, so its run grades local_only; one under it does not match its index.
+    const unread = [];
+    for (const error of refused)
+        if (error instanceof StreamTraceTooLargeError && (await pastReadLimit(runPaths, error.file))) {
+            unread.push(error);
+            scanned.opaque.push(error.file);
+        }
     return {
         bundle,
         recorded: bundle,
-        refusedTraces: refused.map((error) => error.message),
+        refusedTraces: refused
+            .filter((error) => !unread.some((past) => past === error))
+            .map((error) => error.message),
         refusedStreams: new Set(refused.map((error) => error.streamId)),
+        unreadTraces: unread.map((error) => error.message),
+        pastReadLimit: new Set(unread.map((error) => error.file)),
         ...scanned,
         pages: pageFindings(bundle),
     };
 }
+/** Whether the run file at `file` holds more than RUN_ARTIFACT_MAX_BYTES, read only when it does not. */
+async function pastReadLimit(runPaths, file) {
+    const read = await readContainedRegularFile(runPaths, file, RUN_ARTIFACT_MAX_BYTES);
+    return read.status === "refused" && read.reason === "too-large";
+}
+/** The continuous recordings the bundle registers, which CONTINUOUS_MEDIA grades. */
+const recordingPaths = (bundle) => new Set(bundle?.streams.flatMap((stream) => (stream.recording ? [stream.recording.path] : [])) ?? []);
 /** The trace scan's results, beside the walk's: each file named once, then each page finding. */
 function addTraceScan(traces, findings, unscanned) {
     for (const file of traces.sensitive)

package/docs/architecture/actor-contract.md

@@ -168,7 +168,9 @@ export interface ActorTraceItem {
   screenshotRef?: { path: string; redaction: "blurred" | "ocr_scrubbed" | "none" };
   text?: string; // redacted
   page?: { origin: string; path: string }; // computer-use screenshot items; redacted, no query
-  // computer-use: the wait ui_action during which a watch of a turn that only waited ended
+  // computer-use: the wait ui_action during which a watch of a turn that only waited ended, or a
+  // "watched the screen" notice for a watch no wait carries (a held participant's turn of only
+  // screenshots, or the watch after its repeated action past the no-progress limit)
   watch?: {
     limitMs: number;
     askedMs: number; // what the turn's waits asked for; above limitMs past the watch's growth cap

package/docs/architecture/state-driven-executor.md

@@ -100,10 +100,13 @@ action**, not a fatal error:
   `budget_reached` after material progress), a `CuaAbortError` as `harness_error`,
   and any genuine non-`CommandExitError` adapter fault as `actor_error`.
 - **No infinite loop.** A skipped action changes nothing on screen, so it is not
-  progress. A run that keeps failing every action makes no progress and still
-  terminates through the existing idle / no-progress backstop
-  (`gave_up`). The resilience only converts a _single flaky command_ from fatal
-  to survivable; it never masks a genuinely stuck run.
+  progress. A run that keeps repeating a failing action makes no progress and
+  ends through the no-progress backstop (`gave_up`) at 20 such turns in a row.
+  A participant held to its scheduled end keeps its session through repeats on
+  an unchanged screen, which is how it waits on a page that changes only on
+  reload, but 20 repeats in a row that never reached the desktop end it the
+  same way. The resilience only converts a _single flaky command_ from fatal
+  to survivable.
 
 Public-safety: the notice text carries only the substrate's own stderr (tailed +
 whitespace-collapsed) and a numeric exit code, and is still run through the loop's

package/docs/contracts/run-bundle.md

@@ -20,7 +20,7 @@ writer (`src/run/run.ts`, through `splitStreamTraces` in `src/run/stream-trace.t
 each stream with an `actor`:
 
 - the trace file: the actor trace (`humanish.actor-trace.v1`) with every item, plus `artifacts`,
-  the stream's screenshot entries. Its path is the stream's actor trace artifact (`actor.json` for
+  the stream's screenshot entries, as one line of compact JSON. Its path is the stream's actor trace artifact (`actor.json` for
   one participant, `actors/<stream>.json` for more, `actor-<surface>.json` on the scripted route),
   or `actors/<n>.json`, `n` its position in `streams[]` (from 1), for a stream with none or whose
   trace artifact an earlier stream claimed. Names of that form are never reused as a stream's own
@@ -65,7 +65,12 @@ names, is refused before any file is read. The writer claims names the same way.
 must have an index: an actor with no index, with
 or without inline `items`, is refused, and so is one with both an index and inline `items`.
 verify reports a refused trace in the `local evidence artifacts exist` check, so the run is
-`blocked`. verify also scans the bytes of each trace it loaded with the public-safety text scan,
+`blocked`. A trace or live file whose index records more than the limit is reported that way too,
+unless the file on disk is a single-link regular file verify can open that holds more than 32 MiB.
+verify lists such a file under `UNSCANNED_ARTIFACT`, so the run is `local_only`. It adds the
+refusal to its warnings and checks that participant without its items. Where the run cites the
+file as evidence, verify counts it as present if it is still past 32 MiB when that check reads it;
+a citation as a screenshot or recording is still checked as one, so the run is `blocked`. verify also scans the bytes of each trace it loaded with the public-safety text scan,
 apart from its walk of the run folder, so no path exemption the walk makes applies to a trace.
 run.json's digest, which an analysis record binds, covers each index and so each trace.
 
@@ -371,6 +376,12 @@ An Observer that does not render is an `evidence` failure known only after
 show the run without it. Messages pass the same redaction and sandbox id scrub
 as the rest of the bundle.
 
+After that write, `Run.finish` replaces each raw sandbox id `sandbox-receipts.ndjson` names in the
+run's other text files with its label (`scrubRunSandboxIds` in `src/run/sandbox-ids.ts`). A file
+the sweep cannot read, such as a trace past the 32 MiB read limit, may still name a sandbox. The run
+still finishes: `Run.finish` writes `run.json` again with a `sandbox-ids.unresolved` warn event that
+names each such file and why.
+
 When a signal stops a live run, the handler writes `interrupted` into the last
 flushed `run.json`, and every later write of that run keeps it. A run stopped
 before its first flush has no `run.json`; its `status.json` is the record.

package/docs/contracts/study-analysis.md

@@ -194,8 +194,10 @@ item's text. A run.json past 16 MiB is refused as `ANALYSIS_SOURCE_TOO_LARGE`, a
 a run.json or trace without the fields analysis reads as `ANALYSIS_SOURCE_INVALID`;
 each message names the file, says why, and says no request was sent. Analysis
 verifies the run before it reads a trace, so a trace that does not match its
-index in run.json, or whose index records more than 32 MiB, fails verify and
-`humanish analyze` reports `ANALYSIS_VERIFY_FAILED`. Count and text budgets are
+index in run.json fails verify and `humanish analyze` reports
+`ANALYSIS_VERIFY_FAILED`. A trace past 32 MiB leaves the run `local_only`, and
+analysis refuses it as `ANALYSIS_SOURCE_TOO_LARGE`, naming the participant and
+the file. Count and text budgets are
 distributed across included participants, with unused capacity from short
 sessions available to longer ones. Reclaimed capture slots go first to eligible
 participants with fewer admitted images, including those deferred by their

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.133.1",
+  "version": "0.134.0",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",