@loadmill/droid-cua 2.38.0 → 2.40.0

package/build/src/desktop/computer-use.js

@@ -1,6 +1,8 @@
 import { buildActionEventMeta } from "../device/action-event-meta.js";
 import { buildTypeActionPayload, buildTypeActionText, } from "../device/sensitive-action.js";
 import { getConfiguredStepDelayMs } from "../utils/step-delay.js";
+import { getWindowsVisibleBounds } from "./windows-visible-bounds.js";
+import sharp from "sharp";
 const SCREENSHOT_WIDTH = 1440;
 const ACCESSIBILITY_HIT_TOLERANCE = 12;
 const MACOS_CAPTURE_INSETS = { left: 50, right: 50, top: 38, bottom: 62 };
@@ -26,6 +28,57 @@ function assertResult(result, label) {
         throw new Error(result.content?.find((item) => item.type === "text")?.text || `${label} failed.`);
     }
 }
+function readScreenshot(result) {
+    const image = result.content?.find((item) => item.type === "image");
+    const sizeText = result.content?.find((item) => item.type === "text")?.text || "";
+    const size = /^(\d+)x(\d+)$/.exec(sizeText.trim());
+    if (!image?.data || !size)
+        throw new Error("Desktop screenshot returned no image or dimensions.");
+    return { data: image.data, width: Number(size[1]), height: Number(size[2]) };
+}
+async function isBlackScreenshot(data) {
+    const { channels } = await sharp(Buffer.from(data, "base64")).stats();
+    return channels.slice(0, 3).every((channel) => channel.max === 0);
+}
+async function captureWindowFromDesktop(native, bounds) {
+    const display = native.getDisplaySize();
+    // Read full-resolution pixels; resizing the desktop first loses window detail.
+    const screen = native.takeScreenshot(undefined, undefined, 0, undefined, undefined);
+    if (!screen.base64)
+        throw new Error("Desktop screen capture returned no image.");
+    const left = Math.round(bounds.x * screen.width / display.width);
+    const top = Math.round(bounds.y * screen.height / display.height);
+    const width = Math.round(bounds.width * screen.width / display.width);
+    const height = Math.round(bounds.height * screen.height / display.height);
+    const visibleLeft = Math.max(0, left);
+    const visibleTop = Math.max(0, top);
+    const visibleRight = Math.min(screen.width, left + width);
+    const visibleBottom = Math.min(screen.height, top + height);
+    if (visibleRight <= visibleLeft || visibleBottom <= visibleTop) {
+        throw new Error("The window must overlap the primary display for Windows screen capture.");
+    }
+    let image = sharp(Buffer.from(screen.base64, "base64")).extract({
+        left: visibleLeft,
+        top: visibleTop,
+        width: visibleRight - visibleLeft,
+        height: visibleBottom - visibleTop,
+    });
+    if (visibleLeft !== left || visibleTop !== top || visibleRight !== left + width || visibleBottom !== top + height) {
+        image = image.extend({
+            left: visibleLeft - left,
+            top: visibleTop - top,
+            right: left + width - visibleRight,
+            bottom: top + height - visibleBottom,
+            background: "black",
+        });
+    }
+    // Materialize the crop and padding before resize (Sharp can reorder operations).
+    const cropped = await image.png().toBuffer();
+    const { data, info } = await sharp(cropped)
+        .resize({ width: SCREENSHOT_WIDTH, withoutEnlargement: true })
+        .png().toBuffer({ resolveWithObject: true });
+    return { data: data.toString("base64"), width: info.width, height: info.height };
+}
 function sameBounds(left, right) {
     return left && right && left.x === right.x && left.y === right.y && left.width === right.width && left.height === right.height;
 }
@@ -63,7 +116,7 @@ async function createLibraryClient() {
     ]);
     return connectInProcess(createComputerUseServer({ profile: "ax", vision: true }));
 }
-async function loadAccessibilityDriver() {
+async function loadNativeDriver() {
     const { loadNative } = await import("@zavora-ai/computer-use-mcp/host-native");
     return loadNative();
 }
@@ -183,9 +236,9 @@ function normalizeShortcut(keys, platform) {
     return keys.map((key) => aliases[String(key).toUpperCase()] || String(key).toLowerCase()).join("+");
 }
 /**
- * @param {{ app?: string, windowId?: number | null, excludePids?: number[], platform?: string, inputMode?: "accessibility" | "physical", client?: any, accessibility?: any }} options
+ * @param {{ app?: string, windowId?: number | null, excludePids?: number[], platform?: string, inputMode?: "accessibility" | "physical", focusOnConnect?: boolean, client?: any, accessibility?: any, visibleBoundsReader?: typeof getWindowsVisibleBounds }} options
  */
-export async function createDesktopController({ app: requestedApp, windowId: requestedWindowId = null, excludePids = [], platform = process.platform, inputMode = "accessibility", client: injectedClient = null, accessibility: injectedAccessibility = null, } = {}) {
+export async function createDesktopController({ app: requestedApp, windowId: requestedWindowId = null, excludePids = [], platform = process.platform, inputMode = "accessibility", focusOnConnect = false, client: injectedClient = null, accessibility: injectedAccessibility = null, visibleBoundsReader = getWindowsVisibleBounds, } = {}) {
     if (!SUPPORTED_PLATFORMS.has(platform)) {
         throw new Error("Desktop control is currently supported only on macOS and Windows.");
     }
@@ -201,59 +254,91 @@ export async function createDesktopController({ app: requestedApp, windowId: req
         let targetWindow = chooseWindow(windows, requestedWindowId == null ? null : Number(requestedWindowId));
         let capture = null;
         let deviceInfo = null;
-        let accessibility = injectedAccessibility;
+        let native = injectedAccessibility;
+        let lastVisibleBounds = null;
+        let fallbackLogged = false;
         async function getWindow() {
             return parseJsonResult(await client.getWindow(targetWindow.windowId), "Window lookup");
         }
-        async function screenshot() {
-            let window;
-            let result;
+        async function focus() {
+            const activation = parseJsonResult(await client.activateWindow(targetWindow.windowId, 2000), "Window activation");
+            const focused = await getWindow();
+            if (!activation.activated || !focused.isFocused) {
+                throw new Error("Droid could not focus the selected desktop window, so no input was sent.");
+            }
+        }
+        async function captureFromDesktop(window) {
+            if (!window.isFocused) {
+                if (inputMode !== "physical") {
+                    throw new Error("Windows desktop capture requires the target window to be visible and focused. Bring it to the foreground and retry.");
+                }
+                await focus();
+                window = await getWindow();
+            }
+            native ||= await loadNativeDriver();
+            if (lastVisibleBounds?.windowId !== targetWindow.windowId || !sameBounds(lastVisibleBounds.outer, window.bounds)) {
+                lastVisibleBounds = {
+                    windowId: targetWindow.windowId,
+                    outer: { ...window.bounds },
+                    visible: await visibleBoundsReader(targetWindow.windowId, window.bounds),
+                };
+            }
+            const actionBounds = lastVisibleBounds.visible;
+            const image = await captureWindowFromDesktop(native, actionBounds);
+            if (!fallbackLogged) {
+                console.warn("Windows window capture returned all-black pixels; using a visible-desktop crop. Keep the target unobstructed on the primary display.");
+                fallbackLogged = true;
+            }
+            return { ...image, bounds: { ...window.bounds }, actionBounds: { ...actionBounds } };
+        }
+        async function screenshot({ allowDesktopFallback = true } = {}) {
             try {
                 const currentWindows = readWindows(await client.listWindows(application.bundleId));
                 const focusedWindow = currentWindows.find((candidate) => candidate.isFocused && candidate.isOnScreen);
                 if (focusedWindow)
                     targetWindow = focusedWindow;
-                window = await getWindow();
+                const window = await getWindow();
                 if (!window.isOnScreen)
                     throw new Error("The selected desktop window is no longer visible.");
-                result = await client.screenshot({
+                const result = await client.screenshot({
                     width: SCREENSHOT_WIDTH,
                     quality: 0,
                     target_window_id: targetWindow.windowId,
                 });
                 assertResult(result, "Desktop screenshot");
+                let image = { ...readScreenshot(result), bounds: { ...window.bounds }, actionBounds: { ...window.bounds } };
+                if (allowDesktopFallback && platform === "win32" && await isBlackScreenshot(image.data)) {
+                    image = await captureFromDesktop(window);
+                }
+                capture = {
+                    bounds: image.bounds,
+                    actionBounds: image.actionBounds,
+                    width: image.width,
+                    height: image.height,
+                    contentBounds: getScreenshotContentBounds(image.width, image.height, image.bounds, platform),
+                };
+                if (deviceInfo) {
+                    deviceInfo.device_width = image.actionBounds.width;
+                    deviceInfo.device_height = image.actionBounds.height;
+                    deviceInfo.scaled_width = image.width;
+                    deviceInfo.scaled_height = image.height;
+                    deviceInfo.scale = image.width / image.actionBounds.width;
+                    deviceInfo.desktopWindowId = targetWindow.windowId;
+                }
+                return image.data;
             }
             catch (error) {
                 throw new Error(formatPermissionError(error, platform));
             }
-            const image = result.content?.find((item) => item.type === "image");
-            const sizeText = result.content?.find((item) => item.type === "text")?.text || "";
-            const size = /^(\d+)x(\d+)$/.exec(sizeText.trim());
-            if (!image?.data || !size)
-                throw new Error("Desktop screenshot returned no image or dimensions.");
-            capture = {
-                bounds: { ...window.bounds },
-                width: Number(size[1]),
-                height: Number(size[2]),
-            };
-            capture.contentBounds = getScreenshotContentBounds(capture.width, capture.height, window.bounds, platform);
-            if (deviceInfo) {
-                deviceInfo.device_width = window.bounds.width;
-                deviceInfo.device_height = window.bounds.height;
-                deviceInfo.scaled_width = capture.width;
-                deviceInfo.scaled_height = capture.height;
-                deviceInfo.scale = capture.width / window.bounds.width;
-                deviceInfo.desktopWindowId = targetWindow.windowId;
-            }
-            return image.data;
         }
         function scaledPoint(x, y) {
             if (!capture)
                 throw new Error("Capture the desktop window before executing an action.");
             const content = capture.contentBounds;
+            const bounds = capture.actionBounds;
             return [
-                Math.round(capture.bounds.x + ((x - content.x) * capture.bounds.width) / content.width),
-                Math.round(capture.bounds.y + ((y - content.y) * capture.bounds.height) / content.height),
+                Math.round(bounds.x + ((x - content.x) * bounds.width) / content.width),
+                Math.round(bounds.y + ((y - content.y) * bounds.height) / content.height),
             ];
         }
         async function prepareAction(requireFocus) {
@@ -265,11 +350,7 @@ export async function createDesktopController({ app: requestedApp, windowId: req
             }
             if (!requireFocus)
                 return;
-            const activation = parseJsonResult(await client.activateWindow(targetWindow.windowId, 2000), "Window activation");
-            const focused = await getWindow();
-            if (!activation.activated || !focused.isFocused) {
-                throw new Error("Droid could not focus the selected desktop window, so no input was sent.");
-            }
+            await focus();
         }
         const targetOptions = () => ({ targetWindowId: targetWindow.windowId, focusStrategy: "strict" });
         async function performCursorFreeAction(actionType, x, y, direction = null) {
@@ -277,8 +358,8 @@ export async function createDesktopController({ app: requestedApp, windowId: req
             const selected = chooseAccessibilityElement(tree, x, y, actionType, direction);
             if (!selected)
                 throw new Error(cursorFreeError(actionType));
-            accessibility ||= await loadAccessibilityDriver();
-            const result = accessibility.performAction(targetWindow.windowId, selected.element.role, selected.element.label, selected.action);
+            native ||= await loadNativeDriver();
+            const result = native.performAction(targetWindow.windowId, selected.element.role, selected.element.label, selected.action);
             if (!result?.performed)
                 throw new Error(`${cursorFreeError(actionType)}${result?.reason ? ` Reason: ${result.reason}.` : ""}`);
         }
@@ -375,16 +456,19 @@ export async function createDesktopController({ app: requestedApp, windowId: req
                 return { success: false, error: message };
             }
         }
-        await screenshot();
+        if (focusOnConnect)
+            await focus();
+        // Without focus, connection only probes the window; the desktop may be covered.
+        await screenshot({ allowDesktopFallback: focusOnConnect });
         deviceInfo = {
             platform: "desktop",
             source: "local",
             device_name: `${application.displayName} — ${targetWindow.title || "Untitled"}`,
-            device_width: targetWindow.bounds.width,
-            device_height: targetWindow.bounds.height,
+            device_width: capture.actionBounds.width,
+            device_height: capture.actionBounds.height,
             scaled_width: capture.width,
             scaled_height: capture.height,
-            scale: capture.width / targetWindow.bounds.width,
+            scale: capture.width / capture.actionBounds.width,
             desktopAppId: application.bundleId,
             desktopWindowId: targetWindow.windowId,
             desktopInputMode: inputMode,
@@ -394,7 +478,8 @@ export async function createDesktopController({ app: requestedApp, windowId: req
             window: targetWindow,
             deviceId: `desktop:${targetWindow.windowId}`,
             deviceInfo,
-            getScreenshotAsBase64: screenshot,
+            focus,
+            getScreenshotAsBase64: () => screenshot(),
             handleModelAction: handleAction,
             close: () => client.close(),
         };

package/build/src/desktop/windows-visible-bounds.js

@@ -0,0 +1,55 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const runFile = promisify(execFile);
+const RECT_SCRIPT = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class WindowFrame {
+  public const int DWMWA_EXTENDED_FRAME_BOUNDS = 9;
+  [StructLayout(LayoutKind.Sequential)] public struct Rect { public int Left; public int Top; public int Right; public int Bottom; }
+  [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr handle, out Rect rect);
+  [DllImport("dwmapi.dll")] public static extern int DwmGetWindowAttribute(IntPtr handle, int attribute, out Rect rect, int size);
+}
+'@
+$handle = [IntPtr]::new([long]WINDOW_ID)
+$outer = [WindowFrame+Rect]::new()
+$visible = [WindowFrame+Rect]::new()
+if (-not [WindowFrame]::GetWindowRect($handle, [ref]$outer)) { exit 1 }
+$result = [WindowFrame]::DwmGetWindowAttribute($handle, [WindowFrame]::DWMWA_EXTENDED_FRAME_BOUNDS, [ref]$visible, 16)
+if ($result -ne 0) { exit 1 }
+@($outer.Left, $outer.Top, $outer.Right, $outer.Bottom, $visible.Left, $visible.Top, $visible.Right, $visible.Bottom) -join ','
+`;
+export async function getWindowsVisibleBounds(windowId, bounds) {
+    if (process.platform !== "win32")
+        return bounds;
+    if (!Number.isSafeInteger(windowId))
+        return bounds;
+    try {
+        // GetWindowRect includes invisible resize borders; DWM reports the pixels actually drawn.
+        const script = RECT_SCRIPT.replace("WINDOW_ID", String(windowId));
+        const { stdout } = await runFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+            windowsHide: true,
+            timeout: 5000,
+        });
+        const [outerLeft, outerTop, outerRight, outerBottom, left, top, right, bottom] = stdout.trim().split(",").map(Number);
+        const scaleX = bounds.width / (outerRight - outerLeft);
+        const scaleY = bounds.height / (outerBottom - outerTop);
+        const insetLeft = Math.round((left - outerLeft) * scaleX);
+        const insetTop = Math.round((top - outerTop) * scaleY);
+        const insetRight = Math.round((outerRight - right) * scaleX);
+        const insetBottom = Math.round((outerBottom - bottom) * scaleY);
+        if (![insetLeft, insetTop, insetRight, insetBottom].every((value) => Number.isFinite(value) && value >= 0)) {
+            throw new Error("Invalid window frame insets.");
+        }
+        const width = bounds.width - insetLeft - insetRight;
+        const height = bounds.height - insetTop - insetBottom;
+        if (width <= 0 || height <= 0)
+            throw new Error("Invalid visible window dimensions.");
+        return { x: bounds.x + insetLeft, y: bounds.y + insetTop, width, height };
+    }
+    catch {
+        console.warn("Windows visible-frame lookup failed; using outer window bounds, which may include invisible resize borders.");
+        return bounds;
+    }
+}

package/build/src/device/android/connection.js

@@ -5,6 +5,18 @@ import { emitDesktopDebug } from "../../utils/desktop-debug.js";
 import { execAdb, execEmulator, spawnAdb, spawnEmulator } from "./tools.js";
 const AVD_READY_TIMEOUT_MS = 180000;
 const AVD_READY_TIMEOUT_SECONDS = AVD_READY_TIMEOUT_MS / 1000;
+const TARGET_SCALED_SHORT_EDGE = 400;
+export function calculateScaledScreenDimensions(width, height) {
+    const shortestEdge = Math.min(width, height);
+    const scale = shortestEdge > TARGET_SCALED_SHORT_EDGE
+        ? TARGET_SCALED_SHORT_EDGE / shortestEdge
+        : 1.0;
+    return {
+        scaledWidth: Math.round(width * scale),
+        scaledHeight: Math.round(height * scale),
+        scale,
+    };
+}
 async function listConnectedDevices() {
     const { stdout } = await execAdb(["devices"]);
     return stdout
@@ -238,10 +250,7 @@ export async function getDeviceInfo(deviceId) {
         process.exit(1);
     }
     const [_, width, height] = match.map(Number);
-    const targetWidth = 400;
-    const scale = width > targetWidth ? targetWidth / width : 1.0;
-    const scaledWidth = Math.round(width * scale);
-    const scaledHeight = Math.round(height * scale);
+    const { scaledWidth, scaledHeight, scale } = calculateScaledScreenDimensions(width, height);
     const [{ stdout: manufacturerRaw }, { stdout: modelRaw }, { stdout: deviceNameRaw }] = await Promise.all([
         execAdb(["-s", deviceId, "shell", "getprop", "ro.product.manufacturer"]),
         execAdb(["-s", deviceId, "shell", "getprop", "ro.product.model"]),

package/build/src/device/interface.js

@@ -31,7 +31,7 @@
  *
  * getDeviceInfo(deviceId: string): Promise<DeviceInfo>
  *   - Gets screen dimensions and calculates scale factor
- *   - Target width for scaling is 400px
+ *   - Local Android screenshots target a 400px shortest edge
  *
  * getScreenshotAsBase64(deviceId: string, deviceInfo: DeviceInfo): Promise<string>
  *   - Captures current screen state

package/build/src/integrations/loadmill/report-upload-manager.js

@@ -1,8 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
+import { findDeepestErrorCode } from "../../utils/error-details.js";
 export const MAX_SCREENSHOTS_PER_REPORT = 1000;
 export const MAX_REPORT_OBJECT_BYTES = 10 * 1024 * 1024;
-function warn(session, message) {
+function warn(session, message, phase) {
     session.failed = true;
+    session.onFailure?.({ uploadId: session.uploadId, phase, objectName: null, httpStatus: null, errorName: "ValidationError", errorCode: null });
     session.onWarning?.(message);
 }
 function getHttpStatus(error) {
@@ -16,6 +18,20 @@ function warnAboutUploadFailure(session) {
     const status = session.uploadFailureStatus ? ` (HTTP ${session.uploadFailureStatus})` : "";
     session.onWarning?.(`Cloud report upload failed${status}; further uploads skipped.`);
 }
+function recordFailure(session, phase, objectName, error) {
+    if (session.uploadFailed)
+        return;
+    session.uploadFailed = true;
+    session.uploadFailureStatus = getHttpStatus(error);
+    session.onFailure?.({
+        uploadId: session.uploadId,
+        phase,
+        objectName,
+        httpStatus: session.uploadFailureStatus,
+        errorName: error instanceof Error ? error.name : typeof error,
+        errorCode: findDeepestErrorCode(error),
+    });
+}
 function decodeScreenshot(dataUrl) {
     const match = /^data:image\/png;base64,([a-zA-Z0-9+/=\s]+)$/.exec(dataUrl);
     return match ? Buffer.from(match[1], "base64") : null;
@@ -46,15 +62,18 @@ export class DroidReportUploadManager {
      *     associateDroidRunReport: (runId: string, payload: object) => Promise<unknown>,
      *   },
      *   onWarning?: ((message: string) => void) | null,
+     *   onFailure?: ((details: { uploadId: string, phase: string, objectName: string | null, httpStatus: string | null, errorName: string, errorCode: string | null }) => void) | null,
      * }} options
      */
-    startSession({ loadmillClient, onWarning = null } = {}) {
+    startSession({ loadmillClient, onWarning = null, onFailure = null } = {}) {
         const session = {
             uploadId: randomUUID(),
             loadmillClient,
             onWarning,
+            onFailure,
             sequence: 0,
             screenshotCount: 0,
+            lastScreenshotObjectName: null,
             deduplication: new Map(),
             pending: new Set(),
             failed: false,
@@ -73,23 +92,25 @@ export class DroidReportUploadManager {
         const hash = createHash("sha256").update(dataUrl).digest("hex");
         const existing = session.deduplication.get(hash);
         if (existing) {
+            session.lastScreenshotObjectName = existing;
             return existing;
         }
         const body = decodeScreenshot(dataUrl);
         if (!body) {
-            warn(session, "Failed to upload Droid report screenshot: unsupported image data.");
+            warn(session, "Failed to upload Droid report screenshot: unsupported image data.", "validate_screenshot");
             return null;
         }
         if (body.length > MAX_REPORT_OBJECT_BYTES) {
-            warn(session, `Droid report screenshot exceeds ${MAX_REPORT_OBJECT_BYTES} bytes.`);
+            warn(session, `Droid report screenshot exceeds ${MAX_REPORT_OBJECT_BYTES} bytes.`, "validate_screenshot");
             return null;
         }
         if (session.screenshotCount >= MAX_SCREENSHOTS_PER_REPORT) {
-            warn(session, `Droid report exceeds ${MAX_SCREENSHOTS_PER_REPORT} screenshots.`);
+            warn(session, `Droid report exceeds ${MAX_SCREENSHOTS_PER_REPORT} screenshots.`, "validate_screenshot");
             return null;
         }
         const name = `screenshots/${String(++session.sequence).padStart(4, "0")}.png`;
         session.screenshotCount += 1;
+        session.lastScreenshotObjectName = name;
         session.deduplication.set(hash, name);
         this.#enqueue(session, { name, body, contentType: "image/png" });
         return name;
@@ -104,7 +125,16 @@ export class DroidReportUploadManager {
         session.finishing = true;
         session.finishPromise = this.#finish(session, { savedRunId, html }).catch((error) => {
             const status = getHttpStatus(error);
-            warn(session, `Failed to publish Droid run report${status ? ` (HTTP ${status})` : ""}.`);
+            session.onFailure?.({
+                uploadId: session.uploadId,
+                phase: "associate_report",
+                objectName: null,
+                httpStatus: status,
+                errorName: error instanceof Error ? error.name : typeof error,
+                errorCode: findDeepestErrorCode(error),
+            });
+            session.failed = true;
+            session.onWarning?.(`Failed to publish Droid run report${status ? ` (HTTP ${status})` : ""}.`);
             return { published: false, reason: "publish_failed" };
         }).finally(() => {
             this.sessions.delete(session);
@@ -122,7 +152,7 @@ export class DroidReportUploadManager {
         }
         const body = Buffer.from(html, "utf8");
         if (body.length > MAX_REPORT_OBJECT_BYTES) {
-            warn(session, `Droid HTML report exceeds ${MAX_REPORT_OBJECT_BYTES} bytes.`);
+            warn(session, `Droid HTML report exceeds ${MAX_REPORT_OBJECT_BYTES} bytes.`, "validate_report");
             return { published: false, reason: "too_large" };
         }
         const htmlUpload = await this.#enqueue(session, {
@@ -139,7 +169,11 @@ export class DroidReportUploadManager {
             key,
             screenshotCount: session.screenshotCount,
         });
-        return { published: true, key };
+        return {
+            published: true,
+            key,
+            lastScreenshotObjectName: session.lastScreenshotObjectName,
+        };
     }
     async waitForSession(session) {
         while (session?.pending?.size) {
@@ -191,6 +225,7 @@ export class DroidReportUploadManager {
     }
     async #runTask(task) {
         let result = { uploaded: false, key: null };
+        let phase = "request_policy";
         try {
             if (task.session.uploadFailed) {
                 return;
@@ -200,13 +235,13 @@ export class DroidReportUploadManager {
             if (!uploadPolicy?.key) {
                 throw new Error("Loadmill did not return an upload policy.");
             }
+            phase = "upload_object";
             await uploadObject(uploadPolicy, task.object.body, task.object.name.split("/").at(-1), task.object.contentType, this.fetchImpl);
             result = { uploaded: true, key: uploadPolicy.key };
         }
         catch (error) {
             task.session.failed = true;
-            task.session.uploadFailed = true;
-            task.session.uploadFailureStatus ??= getHttpStatus(error);
+            recordFailure(task.session, phase, task.object.name, error);
         }
         finally {
             task.session.pending.delete(task.promise);

package/build/src/integrations/loadmill/run-reporter.js

@@ -61,6 +61,7 @@ export function normalizeDroidRunStatus({ status = null, outcome = null, success
  *     contextOptimizationThreshold?: number | null,
  *   } | null,
  *   aimAssistMode?: string | null,
+ *   lloydJobId?: string | null,
  * }} input
  * @returns {{
  *   droidVersion: string | null,
@@ -68,17 +69,19 @@ export function normalizeDroidRunStatus({ status = null, outcome = null, success
  *   llmProviderMode: string | null | undefined,
  *   stepDelayMs: number | null | undefined,
  *   aimAssistMode: string | null,
+ *   lloydJobId?: string,
  *   contextOptimizationEnabled: boolean | null | undefined,
  *   contextOptimizationThreshold: number | null | undefined,
  * }}
  */
-export function buildDroidRunConfiguration({ droidVersion = null, runtimeConfig = null, aimAssistMode = null, } = {}) {
+export function buildDroidRunConfiguration({ droidVersion = null, runtimeConfig = null, aimAssistMode = null, lloydJobId = null, } = {}) {
     return {
         droidVersion,
         model: runtimeConfig?.cuaModel,
         llmProviderMode: runtimeConfig?.llmProviderMode,
         stepDelayMs: runtimeConfig?.stepDelayMs,
         aimAssistMode,
+        ...(lloydJobId ? { lloydJobId } : {}),
         contextOptimizationEnabled: runtimeConfig?.contextOptimizationEnabled,
         contextOptimizationThreshold: runtimeConfig?.contextOptimizationThreshold,
     };
@@ -108,6 +111,7 @@ export function buildDroidRunReportPayload(input = {}) {
         assertionsFailed: nonNegativeIntegerOrNull(input.assertionsFailed),
         retries: nonNegativeIntegerOrNull(input.retries),
         error: trimToNull(input.error),
+        lloydJobId: trimToNull(input.lloydJobId),
     };
     for (const key of Object.keys(payload)) {
         if (payload[key] == null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadmill/droid-cua",
-  "version": "2.38.0",
+  "version": "2.40.0",
   "description": "AI-powered Android testing agent using OpenAI's computer-use model and ADB",
   "main": "build/index.js",
   "type": "module",

package/skill/droid-cua/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: droid-cua
 description: Operate and improve Droid CUA `.dcua` test projects. Use when the user explicitly names Droid CUA or @loadmill/droid-cua, or asks to author, configure, run, diagnose, heal, stabilize, or speed up `.dcua` tests with the Droid CUA CLI or desktop app. Do not use for general web browsing, website development, browser automation, generic mobile work, or non-Droid test tasks.
+metadata:
+  version: "1.0.8"
 ---
 
 # Droid CUA
@@ -12,7 +14,7 @@ Use the existing `droid-cua` CLI and repository files. Do not invent commands, f
 1. Inspect the active test project before creating files. Find existing `.dcua` tests, `context.md`, `test-data.md`, `.secrets`, `.env`, and `ci/droid-cua.json` without reading secret values. Do not search other projects or the user's home directory for credentials.
 2. Determine the requested platform and target from the task or project. Ask the user only when the choice is unclear.
 3. Check authentication and environment readiness before the first run. Read [project-and-auth.md](references/project-and-auth.md) for project boundaries and token handling. Read [onboarding-and-troubleshooting.md](references/onboarding-and-troubleshooting.md) when setup, dependency, device, simulator, browser, or connection work is needed.
-4. Author or update the smallest useful test. Read [authoring-tests.md](references/authoring-tests.md) before changing `.dcua`, context, test data, secrets, or config.
+4. Identify the intended coverage, starting state, scenario inputs, and cleanup; author or update the smallest useful test that preserves them. Read [authoring-tests.md](references/authoring-tests.md) before changing `.dcua`, context, test data, secrets, or config.
 5. Before execution, present the proposed tests and target to the user, resolve any questions, and get their confirmation. Read [running-and-healing.md](references/running-and-healing.md) for the required pre-run check.
 6. Run the confirmed, narrowest relevant test and monitor it to completion. Keep the user oriented during the run by surfacing meaningful live screenshots, not just terminal output.
 7. For a new, changed, flaky, slow, or explicitly optimized test, continue with the evidence-driven author-run-improve loop in [iterative-improvement.md](references/iterative-improvement.md). A passing run is a baseline, not proof of readiness.
@@ -27,7 +29,7 @@ Use the existing `droid-cua` CLI and repository files. Do not invent commands, f
 - Get approval before installing dependencies, running `sudo`, accepting licenses, or changing system configuration.
 - During setup, do not create or edit user tests. Rerun only the failed readiness check, then resume the original task.
 - During healing, edit only `.dcua`, `context.md`, `test-data.md`, or Droid CUA config. Never modify application code under the guise of healing a test.
-- Never weaken or remove an assertion merely to make a failing run pass.
+- Never weaken required coverage or remove an assertion merely to make a failing run pass. Agent-added, out-of-scope assertions may be removed only with a coverage-based explanation; see [authoring-tests.md](references/authoring-tests.md).
 - Keep one canonical context file and one canonical Droid CUA config file per test project. Reuse and update those shared files; never create test-specific context or config copies for a new or improved test.
 - When improving an existing test, keep its complete flow in one independently runnable `.dcua` file. Do not split it into ordered or state-dependent tests as an optimization; Droid CUA does not currently guarantee that separate tests will run consecutively or share state.
 - Before rerunning a long test, apply the smallest evidence-supported batch that addresses its known bottlenecks. The batch may include multiple `.dcua`, context, test-data, or config improvements when each has a clear rationale and preserves coverage. Record the complete change set; isolate or revert individual changes only if the combined result regresses or remains ambiguous.
@@ -39,7 +41,7 @@ Use the existing `droid-cua` CLI and repository files. Do not invent commands, f
 
 - Prefer an existing project convention over creating a parallel structure.
 - Prefer headless runs for agent work because they are observable and return deterministic exit codes.
-- Write tests as concise, human-readable user journeys. Prefer one business-level instruction per user goal over one instruction per tap, menu, dialog, or other UI gesture; add lower-level guidance only when run evidence shows it is necessary.
+- Preserve the user's intended coverage. Write one readable micro-goal per step: a small user task with a recognizable completion point. During improvement, simplify before adding detail, and retain only detail that is necessary and supported by evidence. Do not optimize for fewer lines or compress several goals into one instruction.
 - Use explicit, user-observable outcomes in tests rather than implementation details or coordinates.
 - Diagnose the first divergence between the instruction and observed behavior before changing anything.
 - Compare runs on the same target and app build, and clearly identify every test, context, data, model, or config change included in the optimization batch.