humanish 0.75.0 → 0.77.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";
@@ -736,10 +736,13 @@ async function fillDesktopBrowserWindow(desktop, windowId, resolution, requestTi
     })
         .catch(() => undefined);
 }
-async function openDesktopBrowserTarget(desktop, targetUrl, requestTimeoutMs, browserPreference) {
+async function openDesktopBrowserTarget(desktop, targetUrl, requestTimeoutMs, browserPreference, 
+/** Launch-time flags that make mobile fidelity (#221) hold across every tab: the user agent and
+ *  touch events are browser-wide here, where the CDP holder covers only the launch page. */
+extraChromiumFlags = []) {
     const requestedBrowser = browserPreference ?? "default";
     if (isHttpUrl(targetUrl)) {
-        const chromiumFlags = CHROMIUM_EVIDENCE_HYGIENE_FLAGS.map(shellSingleQuote).join(" ");
+        const chromiumFlags = [...CHROMIUM_EVIDENCE_HYGIENE_FLAGS, ...extraChromiumFlags].map(shellSingleQuote).join(" ");
         const browserLaunchCommand = [
             "set -euo pipefail",
             `target_url=${shellSingleQuote(targetUrl)}`,
@@ -882,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;
@@ -891,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) {
@@ -899,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 }),
@@ -937,6 +976,80 @@ export function makeChromeDesktopGeometryObserver(desktop, requestTimeoutMs, end
         };
     };
 }
+/** The user agent a mobile-emulated lane presents unless the lab sets its own. */
+export const DEFAULT_MOBILE_USER_AGENT = "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1";
+/**
+ * Apply mobile emulation (#221) to the lane's launch page and read back what the page reports.
+ * Fails CLOSED: a request that cannot be applied throws, because a desktop run labelled mobile is
+ * the over-trust this feature exists to prevent. A read-back that cannot be taken is a warning
+ * (the emulation was applied; only the proof is missing).
+ */
+export async function applyMobileEmulation(desktop, requestTimeoutMs, endpoint, targetId, request) {
+    const command = (mode) => chromeCdpProbeCommand({ ...endpoint, ...(targetId === undefined ? {} : { targetId }), prefer: "pinned", mode, emulation: request });
+    const read = async () => {
+        const result = await desktop.commands.run(command("fidelity"), { requestTimeoutMs, timeoutMs: 15_000 });
+        if (result.exitCode !== undefined && result.exitCode !== 0) {
+            return { unavailable: `probe exited ${result.exitCode}: ${tailOf(result.stderr ?? result.stdout ?? "")}` };
+        }
+        return parseChromeCdpProbeOutput(result.stdout);
+    };
+    // The UA / touch / DPR overrides are bound to the DevTools session that set them and lapse the
+    // moment its socket closes (measured: only the viewport width survived a one-shot apply). So the
+    // applier stays attached for the lane's whole life as a detached process; the sandbox teardown
+    // ends it. Its first stdout line says what was applied.
+    const holderName = `mobile-emulation-${Date.now().toString(36)}`;
+    await startDetachedProcess(desktop, { name: holderName, command: command("hold"), requestTimeoutMs });
+    let announced;
+    for (let attempt = 0; attempt < 30 && announced === undefined; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        const log = await readDetachedLog(desktop, holderName, requestTimeoutMs).catch(() => "");
+        const line = log.split("\n").find((candidate) => candidate.trim().startsWith("{"));
+        if (line !== undefined)
+            announced = parseChromeCdpProbeOutput(line);
+    }
+    if (announced === undefined) {
+        throw new Error("mobile emulation could not be applied: the in-sandbox applier printed nothing within 15 s");
+    }
+    if (announced.unavailable !== undefined) {
+        throw new Error(`mobile emulation could not be applied (${announced.unavailable}); applied before failing: ${(announced.applied ?? []).join(", ") || "nothing"}`);
+    }
+    const applied = announced;
+    const warnings = [];
+    // The reload inside the applier takes a moment; the read-back is retried until the page reports
+    // the requested viewport and user agent, so a slow page does not read as "no proof".
+    let readBack = await read();
+    for (let attempt = 0; attempt < 20 && (readBack.fidelity === undefined || readBack.fidelity.innerWidth !== request.width || !readBack.fidelity.userAgent.includes(request.userAgent.slice(0, 24))); attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        readBack = await read();
+    }
+    const fidelityRead = readBack;
+    const requested = {
+        width: request.width,
+        height: request.height,
+        deviceScaleFactor: request.deviceScaleFactor,
+        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, holderName, ...(emulatedTargetId === undefined ? {} : { targetId: emulatedTargetId }) };
+    }
+    const resolved = { ...fidelityRead.fidelity, source: "cdp" };
+    if (resolved.innerWidth !== request.width) {
+        warnings.push(`Mobile emulation requested a ${request.width} px viewport; the page reports ${resolved.innerWidth} px.`);
+    }
+    if (resolved.devicePixelRatio !== request.deviceScaleFactor) {
+        warnings.push(`Mobile emulation requested devicePixelRatio ${request.deviceScaleFactor}; the page reports ${resolved.devicePixelRatio}.`);
+    }
+    if (request.touch && resolved.maxTouchPoints === 0) {
+        warnings.push("Mobile emulation requested touch; the page reports navigator.maxTouchPoints 0.");
+    }
+    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, holderName, ...(emulatedTargetId === undefined ? {} : { targetId: emulatedTargetId }) };
+}
 function isMeasuredRect(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -1018,11 +1131,14 @@ export async function captureDesktopBrowserGeometry(args) {
         : undefined;
     const browserWindow = chromeGeometry?.browserWindow ?? xdotoolWindow;
     const viewport = chromeGeometry?.viewport;
+    // The fill check reads the X window when it was measured: under mobile emulation (#221) the
+    // page's window.outerWidth reports the EMULATED screen (414), which is not a fill failure.
+    const fillBounds = xdotoolWindow ?? browserWindow;
     if (!browserWindow) {
         warnings.push(`Browser outer bounds could not be measured for lane ${args.laneId}.`);
     }
-    else if (browserWindow.width !== args.requestedScreen[0] || browserWindow.height !== args.requestedScreen[1]) {
-        warnings.push(`Browser window fill did not reach the requested ${args.requestedScreen[0]}x${args.requestedScreen[1]} screen for lane ${args.laneId}; measured outer bounds are ${browserWindow.width}x${browserWindow.height}.`);
+    else if (fillBounds !== undefined && (fillBounds.width !== args.requestedScreen[0] || fillBounds.height !== args.requestedScreen[1])) {
+        warnings.push(`Browser window fill did not reach the requested ${args.requestedScreen[0]}x${args.requestedScreen[1]} screen for lane ${args.laneId}; measured outer bounds are ${fillBounds.width}x${fillBounds.height}.`);
     }
     if (!viewport) {
         // Name the cause, not only the symptom: the same dead DevTools channel that loses the viewport
@@ -1165,8 +1281,17 @@ function hasBlockerLanguage(text) {
 // study completed without a participant-reported finding". Friction is the INCLUSIVE scan; a
 // false positive here adds a candidate a person then reads, which is the cheap direction.
 const REPORTED_DEFECT_LANGUAGE = /\b(defects?|bugs?|accessibilit(y|ies)|inaccessible|not (keyboard|screen.?reader)[- ]?accessible|confus(ed|ing)|hesitat(ed|ion)|unexpected(ly)?|unclear|hard to (find|tell|see|read|reach)|no (visible )?focus|overlap(ped|ping|s)?|truncat(ed|es|ion)|cut off|did nothing|nothing happened|no effect)\b/;
+// The friction scan's own negations (#614). "Nothing was confusing", "no defects", "not unclear"
+// are what a participant writes when it has NOTHING to report, and until 2026-09-03 each of them
+// counted as reported friction and became a feedback candidate whose "actual" was a sentence
+// reporting no problem. Only the report-shaped adjectives are negatable here: "no visible focus",
+// "not keyboard-accessible" and "did nothing" are defects and stay.
+const NEGATED_REPORT_LANGUAGE = /\b(?:nothing|no|not|never|without|none)\s+(?:was\s+|were\s+|felt\s+|seemed\s+|really\s+|particularly\s+|especially\s+|major\s+|real\s+|obvious\s+|noticeable\s+)*(?:confus(?:ed|ing|ion)|unclear|unexpected(?:ly)?|hesitat(?:ed|ion|ions)|surpris(?:ed|ing|es)|defects?|bugs?|overlap(?:ped|ping|s)?|truncat(?:ed|es|ion)|hard to (?:find|tell|see|read|reach))\b/g;
+function stripNegatedReportLanguage(text) {
+    return text.replace(NEGATED_REPORT_LANGUAGE, " ");
+}
 function completionReasonContradictsGoal(reason) {
-    const text = stripQuotedSpans(stripNegatedNonBlockerPhrases(reason.toLowerCase()));
+    const text = stripQuotedSpans(stripNegatedReportLanguage(stripNegatedNonBlockerPhrases(reason.toLowerCase())));
     return hasBlockerLanguage(text) || REPORTED_DEFECT_LANGUAGE.test(text);
 }
 /** The verdict scan (strict): like the friction scan, but resolved-arc segments are stripped
@@ -1203,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, "")
@@ -1371,6 +1500,9 @@ export async function runCuaLane(spec, deps) {
     let browserLaunchIdentity;
     let browserLaunched = false;
     let initialBrowserGeometry;
+    let appliedFidelity;
+    let emulatedTargetId;
+    let emulationHolderName;
     let browserWindowId;
     let browserTargetId;
     const declaredScreen = declaredScreenForRender(spec.devicePreset, spec.deviceName, spec.resolution);
@@ -1423,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.
@@ -1562,12 +1704,46 @@ export async function runCuaLane(spec, deps) {
                 });
             }
             if (!desktopCliRoute) {
-                const browserLaunch = await openDesktopBrowserTarget(desktop, targetUrl, deps.requestTimeoutMs, config.execution?.desktop?.browser);
+                const requestedFidelity = config.execution?.desktop?.fidelity;
+                const browserLaunch = await openDesktopBrowserTarget(desktop, targetUrl, deps.requestTimeoutMs, config.execution?.desktop?.browser, requestedFidelity?.mobileEmulation && spec.devicePreset.isMobile
+                    ? [
+                        `--user-agent=${requestedFidelity.userAgent ?? DEFAULT_MOBILE_USER_AGENT}`,
+                        ...(requestedFidelity.touch === false ? [] : ["--touch-events=enabled"])
+                    ]
+                    : []);
                 desktopBrowser = browserLaunch.evidence;
                 launchedBrowserFamily = browserLaunch.family;
                 browserLaunchIdentity = browserLaunch.identity;
                 browserLaunched = true;
                 await desktop.wait(BROWSER_SETTLE_MS).catch(() => undefined);
+                // Mobile fidelity beyond viewport size (#221): applied to the launch page before the
+                // geometry capture and the participant's first observation, OUTSIDE the stream/geometry
+                // try below (whose catch degrades to a warning): a request that cannot be applied fails
+                // the lane closed with the reason.
+                // Only lanes on a mobile preset are emulated: a run-wide flag must not hand a desktop or
+                // tablet lane an iPhone user agent (the first live proof did exactly that to the desktop
+                // newcomer beside the phone lane). Those lanes carry no fidelity block, which is honest.
+                const fidelityRequest = config.execution?.desktop?.fidelity;
+                if (fidelityRequest?.mobileEmulation && spec.devicePreset.isMobile) {
+                    if (launchedBrowserFamily !== "chromium") {
+                        throw new Error(`execution.desktop.fidelity.mobileEmulation needs Chrome or Chromium on lane ${spec.laneId}; the launched browser family is ${launchedBrowserFamily}. Set execution.desktop.browser: chrome.`);
+                    }
+                    const applied = await applyMobileEmulation(desktop, deps.requestTimeoutMs, {
+                        ...(browserLaunchIdentity?.cdpPort === undefined ? {} : { cdpPort: browserLaunchIdentity.cdpPort }),
+                        ...(browserLaunchIdentity?.profileDir === undefined ? {} : { profileDir: browserLaunchIdentity.profileDir }),
+                        targetUrl
+                    }, browserTargetId, {
+                        width: spec.devicePreset.width,
+                        height: spec.devicePreset.height,
+                        deviceScaleFactor: fidelityRequest.deviceScaleFactor ?? spec.devicePreset.deviceScaleFactor,
+                        touch: fidelityRequest.touch ?? true,
+                        userAgent: fidelityRequest.userAgent ?? DEFAULT_MOBILE_USER_AGENT
+                    });
+                    appliedFidelity = applied.fidelity;
+                    emulatedTargetId = applied.targetId;
+                    emulationHolderName = applied.holderName;
+                    warnings.push(...applied.warnings);
+                }
             }
             else {
                 // A terminal window, opened the way the browser is opened on every other route: the
@@ -1707,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 }]
+                                        };
+                                    }
+                                })
                         }
                     }
                     : {}),
@@ -1788,10 +1983,20 @@ 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 }),
                     ...(chosenGeometry.viewport === undefined ? {} : { viewport: chosenGeometry.viewport }),
+                    ...(appliedFidelity === undefined ? {} : { fidelity: appliedFidelity }),
                     ...((desktopGeometry.warnings?.length ?? 0) + geometryWarnings.length === 0
                         ? {}
                         : { warnings: [...(desktopGeometry.warnings ?? []), ...geometryWarnings] })
@@ -3433,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) {