humanish 0.76.0 → 0.78.0

package/dist/cua-actor-lab.js

@@ -34,7 +34,7 @@ import { DEFAULT_OPENAI_CU_MODEL } from "./openai-responses-cu.js";
 import { createLocalAgentProvider, detectLocalAgents } from "./local-agent-cli.js";
 import { startAppServerSession } from "./local-agent-appserver.js";
 import { startClaudeSession } from "./local-agent-claude-session.js";
-import { createDesktopSandbox, loadE2BDesktopModule } from "./e2b-desktop-launch.js";
+import { createDesktopSandbox, withOneRetryOnTransientE2BError, loadE2BDesktopModule } from "./e2b-desktop-launch.js";
 import { probeUrl, readDetachedLog, runDetachedStep, startDetachedProcess } from "./e2b-detached.js";
 import { DEFAULT_SANDBOX_CATCH_PORT, collectCommsThread, collectExternalCommsThread, deployCommsCatch, externalCatchHealthy, externalInboxUrl, refreshInboxSurface, writeInboxSurface } from "./comms-sandbox-catch.js";
 import { FakeInbox } from "./comms-fake-inbox.js";
@@ -885,8 +885,19 @@ export function desktopBrowserFamily(value) {
  * The observer still degrades to `{}` for the loop; the callback is how a lane says out loud that
  * url/text criteria are not being measured, instead of letting the funnel report 0/N (#514).
  */
-export function makeChromeBrowserStateObserver(desktop, requestTimeoutMs, endpoint, targetId, onUnavailable) {
+export function makeChromeBrowserStateObserver(desktop, requestTimeoutMs, endpoint, targetId, onUnavailable, 
+/**
+ * Mobile emulation on later tabs (#623): the holder attaches to every page target Chrome opens
+ * after the launch page, so a tab the participant opens later should lay out at the phone width
+ * too. The first observation on each new target reads that page's OWN report; a target that
+ * reports the requested width is recorded through `onCovered`, and one that does not (or cannot
+ * be read) fires `onDrift` once, so a phone-labelled lane that spent part of its session at
+ * desktop layout says so with the number the page gave.
+ */
+drift) {
     let reported = false;
+    let drifted = false;
+    const checkedTargets = new Set(drift === undefined ? [] : [drift.emulatedTargetId]);
     const unavailable = (reason) => {
         if (!reported) {
             reported = true;
@@ -894,6 +905,29 @@ export function makeChromeBrowserStateObserver(desktop, requestTimeoutMs, endpoi
         }
         return {};
     };
+    const checkLaterTarget = async (newTargetId) => {
+        if (drift === undefined || checkedTargets.has(newTargetId))
+            return;
+        checkedTargets.add(newTargetId);
+        const read = await desktop.commands.run(chromeCdpProbeCommand({ ...endpoint, targetId: newTargetId, prefer: "pinned", mode: "fidelity" }), { requestTimeoutMs, timeoutMs: 5_000 });
+        const fidelity = read.exitCode !== undefined && read.exitCode !== 0 ? undefined : parseChromeCdpProbeOutput(read.stdout).fidelity;
+        if (fidelity !== undefined && fidelity.innerWidth === drift.expectedWidth) {
+            drift.onCovered?.(newTargetId, { innerWidth: fidelity.innerWidth, devicePixelRatio: fidelity.devicePixelRatio, maxTouchPoints: fidelity.maxTouchPoints });
+            if (drift.expectTouch === true && fidelity.maxTouchPoints === 0 && !drifted) {
+                // The viewport followed; touch did not (yet): the holder reloads a later tab once after its
+                // first navigation commits, and this observation may have landed before that reload.
+                drifted = true;
+                drift.onDrift(`a later page target reports the ${fidelity.innerWidth} px viewport but navigator.maxTouchPoints 0 on its first observation; touch reaches a document only when it loads under the override`);
+            }
+            return;
+        }
+        if (drifted)
+            return;
+        drifted = true;
+        drift.onDrift(fidelity === undefined
+            ? "the participant drove a page target other than the emulated launch tab and that page's own read-back could not be taken; whether it laid out at the phone width is not known"
+            : `the participant drove a page target other than the emulated launch tab and that page reports a ${fidelity.innerWidth} px viewport where ${drift.expectedWidth} px was requested (DPR ${fidelity.devicePixelRatio}); the mobile user agent and touch events are browser-wide, the viewport override was not re-applied to it`);
+    };
     return async () => {
         const result = await desktop.commands.run(chromeCdpProbeCommand({ ...endpoint, ...(targetId === undefined ? {} : { targetId }), prefer: "active", mode: "state" }), { requestTimeoutMs, timeoutMs: 5_000 });
         if (result.exitCode !== undefined && result.exitCode !== 0) {
@@ -902,6 +936,8 @@ export function makeChromeBrowserStateObserver(desktop, requestTimeoutMs, endpoi
         const parsed = parseChromeCdpProbeOutput(result.stdout);
         if (parsed.unavailable !== undefined)
             return unavailable(parsed.unavailable);
+        if (parsed.targetId !== undefined)
+            await checkLaterTarget(parsed.targetId);
         return {
             ...(parsed.url === undefined ? {} : { url: parsed.url }),
             ...(parsed.title === undefined ? {} : { title: parsed.title }),
@@ -994,9 +1030,10 @@ export async function applyMobileEmulation(desktop, requestTimeoutMs, endpoint,
         touch: request.touch,
         userAgent: request.userAgent
     };
+    const emulatedTargetId = applied.targetId ?? fidelityRead.targetId;
     if (fidelityRead.fidelity === undefined) {
         warnings.push(`Mobile emulation was applied but the page's own report could not be read (${fidelityRead.unavailable ?? "no fidelity read"}); desktopGeometry.fidelity carries the request without a resolved block.`);
-        return { fidelity: { tier: "mobile-emulated", requested, applied: applied.applied ?? [] }, warnings };
+        return { fidelity: { tier: "mobile-emulated", requested, applied: applied.applied ?? [] }, warnings, holderName, ...(emulatedTargetId === undefined ? {} : { targetId: emulatedTargetId }) };
     }
     const resolved = { ...fidelityRead.fidelity, source: "cdp" };
     if (resolved.innerWidth !== request.width) {
@@ -1011,7 +1048,7 @@ export async function applyMobileEmulation(desktop, requestTimeoutMs, endpoint,
     if (!resolved.userAgent.includes("Mobile") && !resolved.userAgent.includes("Android") && !resolved.userAgent.includes("iPhone")) {
         warnings.push("Mobile emulation requested a mobile user agent; the page reports a desktop one.");
     }
-    return { fidelity: { tier: "mobile-emulated", requested, applied: applied.applied ?? [], resolved }, warnings };
+    return { fidelity: { tier: "mobile-emulated", requested, applied: applied.applied ?? [], resolved }, warnings, holderName, ...(emulatedTargetId === undefined ? {} : { targetId: emulatedTargetId }) };
 }
 function isMeasuredRect(value) {
     if (!value || typeof value !== "object")
@@ -1291,12 +1328,16 @@ function stripResolvedArcSegments(text) {
     })
         .join(" ");
 }
+// Negations that DESCRIBE a defect rather than deny one. Kept out of every clause drop below.
+const DEFECT_SHAPED_NEGATION = /\bno\s+(?:visible\s+)?focus\b|\bno\s+(?:keyboard|screen.?reader)[- ]?(?:access|path|route|way|alternative|equivalent)|\bnot\s+(?:keyboard|screen.?reader)[- ]?accessible\b|\bno\s+(?:effect|feedback|response)\b|\b(?:did|does)\s+nothing\b|\bnothing\s+happened\b/;
 function stripNegatedNonBlockerPhrases(text) {
     return text
         // FIRST, before the narrower rules eat the "no blockers" and leave "encountered ... error"
         // behind: "I encountered no blockers or unclear error output." refused a clean passing run on
         // 2026-09-01. A verb of encounter followed by "no" negates the whole clause, so drop the clause.
-        .replace(/\b(?:encountered|hit|saw|found|met|had|got|ran into)\s+no\s+[^.!?\n]*/g, " ")
+        // ... unless the clause names a DEFECT: "the delete control had no visible focus" is a
+        // finding, and the verb it happens to use must not decide whether it counts (#622).
+        .replace(/\b(?:encountered|hit|saw|found|met|had|got|ran into)\s+no\s+[^.!?\n]*/g, (clause) => DEFECT_SHAPED_NEGATION.test(clause) ? clause : " ")
         .replace(/\bno\s+(?:real\s+|remaining\s+|actual\s+)?(?:blocker|blockers|blocking issue|blocking issues|error|errors|failure|failures)\s+(?:was\s+|were\s+)?(?:encountered|observed|found|hit|seen|reported|detected)\b/g, "")
         .replace(/\bwithout\s+(?:a\s+|any\s+)?(?:real\s+|remaining\s+|actual\s+)?(?:blocker|blockers|blocking issue|blocking issues|error|errors|failure|failures)\b/g, "")
         .replace(/\bnot\s+(?:blocked|a blocker|an error|failed)\b/g, "")
@@ -1460,6 +1501,8 @@ export async function runCuaLane(spec, deps) {
     let browserLaunched = false;
     let initialBrowserGeometry;
     let appliedFidelity;
+    let emulatedTargetId;
+    let emulationHolderName;
     let browserWindowId;
     let browserTargetId;
     const declaredScreen = declaredScreenForRender(spec.devicePreset, spec.deviceName, spec.resolution);
@@ -1512,7 +1555,17 @@ export async function runCuaLane(spec, deps) {
             resolution: spec.resolution,
             dpi: 96,
             lifecycle: { onTimeout: "kill" }
-        }, config.execution?.desktop?.template);
+        }, config.execution?.desktop?.template, {
+            // One retry on a transient provider error (a sandbox whose envd was not routable yet, an
+            // API reply without a body). The failed attempt may have allocated a sandbox this process
+            // never learned the id of; its own timeoutMs is what reclaims it, so the warning says so.
+            onRetry: (reason) => {
+                const named = redactText(deps.scrubKnownValues(reason));
+                warnings.push(`Sandbox create for lane ${spec.laneId} retried once after a transient provider error (${named}); ` +
+                    `a sandbox the first attempt may have allocated is not known to this run and expires on the provider's ${Math.round(deps.perLaneSandboxMs / 60_000)}-minute timeout.`);
+                onSubjectPhase({ at: new Date(deps.now()).toISOString(), type: "cua-lab.sandbox.create.retry", message: `sandbox create retried once (${named})` });
+            }
+        });
         sandboxId = desktop.sandboxId;
         // #358 salvage: journal the id to disk before any work — an interrupted run reclaims by
         // exact recorded id (`humanish reclaim`), never by enumerating the account.
@@ -1687,6 +1740,8 @@ export async function runCuaLane(spec, deps) {
                         userAgent: fidelityRequest.userAgent ?? DEFAULT_MOBILE_USER_AGENT
                     });
                     appliedFidelity = applied.fidelity;
+                    emulatedTargetId = applied.targetId;
+                    emulationHolderName = applied.holderName;
                     warnings.push(...applied.warnings);
                 }
             }
@@ -1828,7 +1883,26 @@ export async function runCuaLane(spec, deps) {
                             (reason) => {
                                 warnings.push(`Browser-state observer unavailable for lane ${spec.laneId} (${redactText(deps.scrubKnownValues(reason))}); ` +
                                     "urlIncludes/urlPathEquals/textIncludes stop conditions and task criteria are NOT being measured this session.");
-                            })
+                            }, emulatedTargetId === undefined
+                                ? undefined
+                                : {
+                                    emulatedTargetId,
+                                    expectedWidth: spec.devicePreset.width,
+                                    expectTouch: appliedFidelity?.requested.touch === true,
+                                    onDrift: (reason) => {
+                                        warnings.push(`Mobile emulation drift on lane ${spec.laneId}: ${reason} (#623).`);
+                                    },
+                                    onCovered: (coveredTargetId, read) => {
+                                        // A later tab the page itself reported at the phone width: evidence that
+                                        // the emulation followed the participant (#623), kept on the bundle.
+                                        if (appliedFidelity === undefined)
+                                            return;
+                                        appliedFidelity = {
+                                            ...appliedFidelity,
+                                            laterTargets: [...(appliedFidelity.laterTargets ?? []), { targetId: coveredTargetId, ...read }]
+                                        };
+                                    }
+                                })
                         }
                     }
                     : {}),
@@ -1909,6 +1983,15 @@ export async function runCuaLane(spec, deps) {
                     : initialBrowserGeometry ?? finalGeometry;
                 const geometryWarnings = [...new Set(chosenGeometry.warnings.map((warning) => deps.scrubKnownValues(warning)))];
                 warnings.push(...geometryWarnings);
+                // The emulation holder's own log, after its announce line: which later targets it
+                // attached to, what it sent, and any reply that came back as an error (#623). Read while
+                // the sandbox is alive; the first live proof had no way to say what the holder did.
+                if (appliedFidelity !== undefined && emulationHolderName !== undefined) {
+                    const holderLog = await readDetachedLog(desktop, emulationHolderName, deps.requestTimeoutMs).catch(() => "");
+                    const lines = holderLog.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("{")).slice(1, 51);
+                    if (lines.length > 0)
+                        appliedFidelity = { ...appliedFidelity, holderLog: lines.map((line) => deps.scrubKnownValues(line)) };
+                }
                 desktopGeometry = {
                     screen: desktopGeometry.screen,
                     ...(chosenGeometry.browserWindow === undefined ? {} : { browserWindow: chosenGeometry.browserWindow }),
@@ -3555,9 +3638,12 @@ export async function provisionLocalTreeSubject(desktop, args) {
     const uploadStartedAt = now();
     emitPhaseStarted(args.onPhase, now, "upload", "uploading packed local-tree archive");
     try {
-        await desktop.files.write(LOCAL_TREE_REMOTE_ARCHIVE_PATH, args.archiveBuffer, {
+        await withOneRetryOnTransientE2BError(() => desktop.files.write(LOCAL_TREE_REMOTE_ARCHIVE_PATH, args.archiveBuffer, {
             requestTimeoutMs: args.requestTimeoutMs,
             useOctetStream: true
+        }), {
+            onRetry: (reason) => emitPhaseStarted(args.onPhase, now, "upload-retry", `local-tree archive upload retried once (${tailOf(args.scrub(reason))})`),
+            ...(args.sleep === undefined ? {} : { sleep: args.sleep })
         });
     }
     catch (error) {