@loadmill/droid-cua 2.9.0 → 2.10.0

package/build/src/commands/help.js

@@ -14,17 +14,17 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '' });
     addOutput({ type: 'info', text: 'Usage:' });
     addOutput({ type: 'info', text: '  droid-cua --avd <device-name> [options]' });
-    addOutput({ type: 'info', text: '  droid-cua --target web --url <starting-url> --instructions <file> [options]' });
+    addOutput({ type: 'info', text: '  droid-cua --target web --instructions <file> [options]' });
     addOutput({ type: 'info', text: '' });
     addOutput({ type: 'info', text: 'Options:' });
     addOutput({ type: 'info', text: '  --target <kind>        Target kind: mobile (default) or web' });
     addOutput({ type: 'info', text: '  --avd <name>           Device name (Android device ID/serial or iOS Simulator)' });
     addOutput({ type: 'info', text: '  --platform <platform>  Force platform: android or ios' });
     addOutput({ type: 'info', text: '  --instructions <file>  Run test file in headless mode' });
-    addOutput({ type: 'info', text: '  --url <value>          Required starting URL for --target web headless runs' });
     addOutput({ type: 'info', text: '  --session-mode <mode>  Browser session mode for web runs: persistent or fresh' });
     addOutput({ type: 'info', text: '  --config <file>        Headless execution JSON config for prompt parity' });
     addOutput({ type: 'info', text: '  --cua-model <model>    Headless CUA model override: gpt-5.4 or gpt-5.4-mini' });
+    addOutput({ type: 'info', text: '  --aim-assist <mode>    Headless Aim Assist mode: off, smart, or always' });
     addOutput({ type: 'info', text: '  --context <file>       Optional app context file injected into execution runs' });
     addOutput({ type: 'info', text: '  --no-context           Disable app context for headless execution' });
     addOutput({ type: 'info', text: '  --context-optimization-threshold <tokens> Headless Context Optimization compaction threshold' });
@@ -33,8 +33,6 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '  --execution-prompt <text> Headless execution prompt customization text' });
     addOutput({ type: 'info', text: '  --base-prompt-file     Headless base prompt customization file' });
     addOutput({ type: 'info', text: '  --execution-prompt-file Headless execution prompt customization file' });
-    addOutput({ type: 'info', text: '  --strict               Strict Mode: re-observe after the first action in a chain' });
-    addOutput({ type: 'info', text: '  --no-strict            Disable Strict Mode for headless config-driven runs' });
     addOutput({ type: 'info', text: '  --record               Record screenshots during execution' });
     addOutput({ type: 'info', text: '  --debug                Enable structured JSONL debug artifacts' });
     addOutput({ type: 'info', text: '' });
@@ -75,7 +73,7 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '  droid-cua --avd "iPhone 16"             (iOS Simulator, auto-detected)' });
     addOutput({ type: 'info', text: '  droid-cua --platform ios --avd MySim    (Force iOS platform)' });
     addOutput({ type: 'info', text: '  droid-cua --instructions tests/login.dcua --context app/context.md' });
-    addOutput({ type: 'info', text: '  droid-cua --target web --url docs.example.com --instructions tests/search.dcua' });
+    addOutput({ type: 'info', text: '  droid-cua --target web --instructions tests/search.dcua' });
     addOutput({ type: 'info', text: '  /create login-test                      (design a new test)' });
     addOutput({ type: 'info', text: '  /list                                   (see all tests)' });
     addOutput({ type: 'info', text: '  /view login-test                        (view test contents)' });

package/build/src/commands/run.js

@@ -88,7 +88,7 @@ export async function handleRun(args, session, context) {
         });
     }
     // Set execution mode system prompt (replaces any design mode prompt)
-    const executionPrompt = buildExecutionModePrompt(session.deviceInfo, {}, appContextText, { strictMode: Boolean(context.engine?.strictMode) });
+    const executionPrompt = buildExecutionModePrompt(session.deviceInfo, {}, appContextText);
     session.setSystemPrompt(executionPrompt);
     // Create execution mode
     const executionMode = new ExecutionMode(session, context.engine, instructions);

package/build/src/core/aim-assist.js

@@ -0,0 +1,5 @@
+export const AIM_ASSIST_MODES = ["off", "smart", "always"];
+export const DEFAULT_AIM_ASSIST_MODE = "smart";
+export function normalizeAimAssistMode(value) {
+    return AIM_ASSIST_MODES.includes(value) ? value : DEFAULT_AIM_ASSIST_MODE;
+}

package/build/src/core/execution-engine.js

@@ -101,55 +101,20 @@ function buildPreviewOutputContent({ text, annotatedScreenshotBase64 = null }) {
     }
     return content;
 }
-function getScopeAndIds(context = null, stepContext = null) {
-    const scope = context?.sessionId ? "design" : "execution";
-    const ids = scope === "design"
-        ? {
-            sessionId: context?.sessionId,
-            stepId: stepContext?.stepId,
-            instructionIndex: stepContext?.instructionIndex
-        }
-        : {
-            runId: context?.runId,
-            stepId: stepContext?.stepId,
-            instructionIndex: stepContext?.instructionIndex
-        };
-    return { scope, ids };
-}
-function buildStrictModePlan(actions = [], strictMode = false) {
-    if (!strictMode || actions.length === 0) {
-        return {
-            actionsToExecute: actions,
-            droppedActions: [],
-            truncationReason: null,
-            runtimeNote: null
-        };
-    }
-    const actionsToExecute = [actions[0]];
-    const droppedActions = actions.slice(1);
-    if (droppedActions.length === 0) {
-        return {
-            actionsToExecute,
-            droppedActions,
-            truncationReason: null,
-            runtimeNote: null
-        };
-    }
-    const leadingActionType = actionsToExecute[0]?.type;
-    const truncationReason = leadingActionType === "screenshot"
-        ? "leading_screenshot_reobserve"
-        : "post_first_action_reobserve";
-    const droppedActionTypes = droppedActions
-        .map((action) => action?.type)
-        .filter(Boolean);
-    const runtimeNote = `Strict Mode: I executed only the first ${leadingActionType === "screenshot" ? "screenshot request" : "action"} from your previous chain and intentionally skipped the remaining ${droppedActions.length} action${droppedActions.length === 1 ? "" : "s"} (${droppedActionTypes.join(", ")}) so I could re-observe the device before continuing. Base your next step only on what is visible now.`;
+function buildDebugContext(context = null, stepContext = null) {
     return {
-        actionsToExecute,
-        droppedActions,
-        truncationReason,
-        runtimeNote
+        scope: context?.sessionId ? "design" : "execution",
+        runId: context?.runId,
+        sessionId: context?.sessionId,
+        stepId: stepContext?.stepId,
+        instructionIndex: stepContext?.instructionIndex
     };
 }
+function collectPendingSafetyChecks(items = []) {
+    return items
+        .filter((item) => item.type === "pending_safety_check")
+        .map((item) => ({ id: item.id }));
+}
 function normalizeArtifactPaths(result) {
     if (result && typeof result === "object" && !Array.isArray(result)) {
         if (Array.isArray(result.annotationSourcePaths)) {
@@ -187,7 +152,6 @@ export class ExecutionEngine {
         this.recordScreenshots = options.recordScreenshots || false;
         this.screenshotDir = options.screenshotDir || null;
         this.screenshotRecorder = options.screenshotRecorder || null;
-        this.strictMode = options.strictMode === true;
         this.stepDelayMs = options.stepDelayMs ?? getConfiguredStepDelayMs();
         this.reportedScreenshotWriteError = false;
         this.reportedScreenshotAnnotateError = false;
@@ -374,6 +338,108 @@ export class ExecutionEngine {
             }));
         }
     }
+    async requestNextTurn(messages, previousResponseId, context = null, stepContext = null) {
+        return await this.sendCUARequest({
+            messages,
+            previousResponseId,
+            deviceInfo: this.session.deviceInfo,
+            debugContext: buildDebugContext(context, stepContext)
+        });
+    }
+    async executeActionBatch(actions, shouldStop, context = null, stepContext = null, trackAction = null) {
+        let sawExplicitScreenshotAction = false;
+        for (const action of actions) {
+            const actionEventId = randomUUID();
+            if (shouldStop()) {
+                return { stopped: true, sawExplicitScreenshotAction };
+            }
+            if (action.type === "screenshot") {
+                sawExplicitScreenshotAction = true;
+                continue;
+            }
+            const annotatedScreenshotResult = await this.annotateLatestScreenshot(action, {
+                runId: context?.runId,
+                sessionId: context?.sessionId,
+                stepId: stepContext?.stepId,
+                instructionIndex: stepContext?.instructionIndex,
+                eventId: actionEventId,
+                captureSource: CAPTURE_SOURCES.ACTION_CLICK_ANNOTATION
+            });
+            const annotatedScreenshotPath = screenshotPathFromRecorderResult(annotatedScreenshotResult);
+            const annotatedScreenshotDataUrl = screenshotDataUrlFromRecorderResult(annotatedScreenshotResult);
+            await this.handleModelAction(this.session.deviceId, action, this.session.deviceInfo.scale, {
+                ...context,
+                shouldStop,
+                stepId: stepContext?.stepId,
+                instructionIndex: stepContext?.instructionIndex,
+                eventId: actionEventId,
+                captureSource: CAPTURE_SOURCES.ACTION_CLICK_ANNOTATION,
+                ...(annotatedScreenshotPath ? { screenshotPath: annotatedScreenshotPath } : {}),
+                ...(context?.includeScreenshotDataUrl && annotatedScreenshotDataUrl ? { screenshotDataUrl: annotatedScreenshotDataUrl } : {})
+            });
+            if (trackAction) {
+                trackAction(action);
+            }
+            if (shouldStop()) {
+                return { stopped: true, sawExplicitScreenshotAction };
+            }
+            if (action.type !== "wait") {
+                await new Promise((resolve) => setTimeout(resolve, this.stepDelayMs));
+            }
+        }
+        return { stopped: false, sawExplicitScreenshotAction };
+    }
+    async buildActionFollowUp(callId, pendingSafetyChecks, sawExplicitScreenshotAction, addOutput, eventMeta, context = null, stepContext = null) {
+        const screenshotBase64 = await this.getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
+        emitDesktopDebug("device.screenshot", "device", {
+            runId: context?.runId,
+            stepId: stepContext?.stepId,
+            instructionIndex: stepContext?.instructionIndex
+        }, {
+            source: sawExplicitScreenshotAction ? "explicit_action" : "post_action",
+            callId,
+            width: this.session.deviceInfo?.scaled_width,
+            height: this.session.deviceInfo?.scaled_height,
+            base64Length: screenshotBase64.length
+        });
+        const screenshotEventId = randomUUID();
+        const captureSource = sawExplicitScreenshotAction ? CAPTURE_SOURCES.CALL_OUTPUT_EXPLICIT_ACTION : CAPTURE_SOURCES.CALL_OUTPUT_POST_ACTION;
+        const screenshotResult = await this.recordScreenshot(screenshotBase64, {
+            runId: context?.runId,
+            sessionId: context?.sessionId,
+            stepId: stepContext?.stepId,
+            instructionIndex: stepContext?.instructionIndex,
+            eventId: screenshotEventId,
+            captureSource
+        });
+        const screenshotPath = screenshotPathFromRecorderResult(screenshotResult);
+        addOutput({
+            type: "info",
+            text: "Capturing screen",
+            eventType: "screenshot_captured",
+            actionType: "screenshot",
+            ...eventMeta({
+                payload: {
+                    eventId: screenshotEventId,
+                    captureSource,
+                    source: sawExplicitScreenshotAction ? "explicit_action" : "post_action",
+                    ...(typeof screenshotPath === "string" && screenshotPath ? { screenshotPath } : {}),
+                    ...(context?.includeScreenshotDataUrl
+                        ? { screenshotDataUrl: `data:image/png;base64,${screenshotBase64}` }
+                        : {})
+                }
+            })
+        });
+        return [{
+                type: "computer_call_output",
+                call_id: callId,
+                output: {
+                    type: "computer_screenshot",
+                    image_url: `data:image/png;base64,${screenshotBase64}`,
+                },
+                ...(pendingSafetyChecks.length > 0 ? { acknowledged_safety_checks: pendingSafetyChecks } : {})
+            }];
+    }
     /**
      * Run a full turn with the CUA model
      * Executes actions until the model stops requesting actions
@@ -386,7 +452,6 @@ export class ExecutionEngine {
         const addOutput = context?.addOutput || printCliOutput;
         let newResponseId = response.id;
         const shouldStop = () => Boolean(trackAction?.());
-        const { scope, ids } = getScopeAndIds(context, stepContext);
         const eventMeta = (extra = {}) => ({
             runId: context?.runId,
             stepId: stepContext?.stepId,
@@ -400,10 +465,7 @@ export class ExecutionEngine {
             }
             const items = response.output || [];
             const actionableItems = extractActionableOutputItems(items);
-            // ── Collect pending safety checks ──
-            const pendingSafetyChecks = items
-                .filter(item => item.type === "pending_safety_check")
-                .map(item => ({ id: item.id }));
+            const pendingSafetyChecks = collectPendingSafetyChecks(items);
             // ── Print assistant output ──
             for (const item of items) {
                 if (item.type === "reasoning") {
@@ -461,154 +523,20 @@ export class ExecutionEngine {
                 if (shouldStop()) {
                     return newResponseId;
                 }
-                response = await this.sendCUARequest({
-                    messages: input,
-                    previousResponseId: newResponseId,
-                    deviceInfo: this.session.deviceInfo,
-                    debugContext: {
-                        scope,
-                        runId: context?.runId,
-                        sessionId: context?.sessionId,
-                        stepId: stepContext?.stepId,
-                        instructionIndex: stepContext?.instructionIndex
-                    }
-                });
+                response = await this.requestNextTurn(input, newResponseId, context, stepContext);
                 newResponseId = response.id;
                 continue;
             }
             const { call_id, actions } = actionableItem;
-            const { actionsToExecute, droppedActions, truncationReason, runtimeNote } = buildStrictModePlan(actions, this.strictMode);
-            let sawExplicitScreenshotAction = false;
-            for (const action of actionsToExecute) {
-                const actionEventId = randomUUID();
-                if (shouldStop()) {
-                    return newResponseId;
-                }
-                if (action.type === "screenshot") {
-                    sawExplicitScreenshotAction = true;
-                }
-                else {
-                    const annotatedScreenshotResult = await this.annotateLatestScreenshot(action, {
-                        runId: context?.runId,
-                        sessionId: context?.sessionId,
-                        stepId: stepContext?.stepId,
-                        instructionIndex: stepContext?.instructionIndex,
-                        eventId: actionEventId,
-                        captureSource: CAPTURE_SOURCES.ACTION_CLICK_ANNOTATION
-                    });
-                    const annotatedScreenshotPath = screenshotPathFromRecorderResult(annotatedScreenshotResult);
-                    const annotatedScreenshotDataUrl = screenshotDataUrlFromRecorderResult(annotatedScreenshotResult);
-                    await this.handleModelAction(this.session.deviceId, action, this.session.deviceInfo.scale, {
-                        ...context,
-                        shouldStop,
-                        stepId: stepContext?.stepId,
-                        instructionIndex: stepContext?.instructionIndex,
-                        eventId: actionEventId,
-                        captureSource: CAPTURE_SOURCES.ACTION_CLICK_ANNOTATION,
-                        ...(annotatedScreenshotPath ? { screenshotPath: annotatedScreenshotPath } : {}),
-                        ...(context?.includeScreenshotDataUrl && annotatedScreenshotDataUrl ? { screenshotDataUrl: annotatedScreenshotDataUrl } : {})
-                    });
-                    if (trackAction) {
-                        trackAction(action);
-                    }
-                    if (shouldStop()) {
-                        return newResponseId;
-                    }
-                    if (action.type !== "wait") {
-                        await new Promise(resolve => setTimeout(resolve, this.stepDelayMs));
-                    }
-                }
-            }
-            if (shouldStop()) {
+            const actionBatchResult = await this.executeActionBatch(actions, shouldStop, context, stepContext, trackAction);
+            if (actionBatchResult.stopped) {
                 return newResponseId;
             }
-            const screenshotBase64 = await this.getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
-            emitDesktopDebug("device.screenshot", "device", {
-                runId: context?.runId,
-                stepId: stepContext?.stepId,
-                instructionIndex: stepContext?.instructionIndex
-            }, {
-                source: sawExplicitScreenshotAction ? "explicit_action" : "post_action",
-                callId: call_id,
-                width: this.session.deviceInfo?.scaled_width,
-                height: this.session.deviceInfo?.scaled_height,
-                base64Length: screenshotBase64.length
-            });
-            const screenshotEventId = randomUUID();
-            const captureSource = sawExplicitScreenshotAction ? CAPTURE_SOURCES.CALL_OUTPUT_EXPLICIT_ACTION : CAPTURE_SOURCES.CALL_OUTPUT_POST_ACTION;
-            const screenshotResult = await this.recordScreenshot(screenshotBase64, {
-                runId: context?.runId,
-                sessionId: context?.sessionId,
-                stepId: stepContext?.stepId,
-                instructionIndex: stepContext?.instructionIndex,
-                eventId: screenshotEventId,
-                captureSource
-            });
-            const screenshotPath = screenshotPathFromRecorderResult(screenshotResult);
-            addOutput({
-                type: 'info',
-                text: 'Capturing screen',
-                eventType: 'screenshot_captured',
-                actionType: 'screenshot',
-                ...eventMeta({
-                    payload: {
-                        eventId: screenshotEventId,
-                        captureSource,
-                        source: sawExplicitScreenshotAction ? "explicit_action" : "post_action",
-                        ...(typeof screenshotPath === "string" && screenshotPath ? { screenshotPath } : {}),
-                        ...(context?.includeScreenshotDataUrl
-                            ? { screenshotDataUrl: `data:image/png;base64,${screenshotBase64}` }
-                            : {})
-                    }
-                })
-            });
-            if (runtimeNote) {
-                const executedActionTypes = actionsToExecute
-                    .map((action) => action?.type)
-                    .filter(Boolean);
-                const droppedActionTypes = droppedActions
-                    .map((action) => action?.type)
-                    .filter(Boolean);
-                emitDesktopDebug("cua.strict_mode.truncation", scope, ids, {
-                    callId: call_id,
-                    executedCount: actionsToExecute.length,
-                    droppedCount: droppedActions.length,
-                    executedActionTypes,
-                    droppedActionTypes,
-                    reason: truncationReason,
-                    note: runtimeNote
-                });
-            }
-            const input = [{
-                    type: "computer_call_output",
-                    call_id,
-                    output: {
-                        type: "computer_screenshot",
-                        image_url: `data:image/png;base64,${screenshotBase64}`,
-                    },
-                    ...(pendingSafetyChecks.length > 0 ? { acknowledged_safety_checks: pendingSafetyChecks } : {})
-                }];
-            if (runtimeNote) {
-                input.push({
-                    role: "user",
-                    content: runtimeNote
-                });
-            }
+            const input = await this.buildActionFollowUp(call_id, pendingSafetyChecks, actionBatchResult.sawExplicitScreenshotAction, addOutput, eventMeta, context, stepContext);
             if (shouldStop()) {
                 return newResponseId;
             }
-            response = await this.sendCUARequest({
-                messages: input,
-                previousResponseId: newResponseId,
-                deviceInfo: this.session.deviceInfo,
-                debugContext: {
-                    scope,
-                    runId: context?.runId,
-                    sessionId: context?.sessionId,
-                    stepId: stepContext?.stepId,
-                    instructionIndex: stepContext?.instructionIndex
-                }
-            });
+            response = await this.requestNextTurn(input, newResponseId, context, stepContext);
             newResponseId = response.id;
         }
         // ── At end, if last output was only reasoning ──

package/build/src/core/runtime-config.js

@@ -35,10 +35,9 @@ export function resolveRuntimeCredentials({ openAiApiKey = null, loadmillApiToke
         loadmillBaseUrl: trimNullableString(loadmillBaseUrl),
     };
 }
-export function resolveRuntimeConfig({ cuaModel = null, strictMode = false, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
+export function resolveRuntimeConfig({ cuaModel = null, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
     return {
         cuaModel: resolveCuaModel(cuaModel),
-        strictMode: strictMode === true,
         stepDelayMs: normalizeStepDelayMs(Number(stepDelayMs)),
         contextOptimizationEnabled: normalizeContextOptimizationEnabled(contextOptimizationEnabled),
         contextOptimizationThreshold: normalizeContextOptimizationThreshold(contextOptimizationThreshold),

package/build/src/device/openai.js

@@ -1,5 +1,6 @@
 import { buildTestRevisionSystemPrompt } from "../prompts/editor.js";
 import { createOpenAiClient, resolveRuntimeConfig } from "../core/runtime-config.js";
+import { DEFAULT_AIM_ASSIST_MODE } from "../core/aim-assist.js";
 import { DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD } from "../core/context-optimization.js";
 import { logger } from "../utils/logger.js";
 import { CuaDebugTracer } from "../utils/cua-debug-tracer.js";
@@ -90,8 +91,10 @@ function buildContextManagement(contextOptimizationEnabled, contextOptimizationT
     }
     return [{ type: "compaction", compact_threshold: contextOptimizationThreshold }];
 }
-export function buildCuaRequestParams({ cuaModel, previousResponseId, input, contextOptimizationEnabled = true, contextOptimizationThreshold = DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, }) {
+export function buildCuaRequestParams({ cuaModel, aimAssistMode = DEFAULT_AIM_ASSIST_MODE, previousResponseId, input, contextOptimizationEnabled = true, contextOptimizationThreshold = DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, }) {
     const contextManagement = buildContextManagement(contextOptimizationEnabled, contextOptimizationThreshold);
+    // Keep Responses API storage enabled on every turn so execution can chain
+    // reliably through previous_response_id across the whole run.
     return {
         model: cuaModel,
         reasoning: { effort: "medium" },
@@ -100,10 +103,12 @@ export function buildCuaRequestParams({ cuaModel, previousResponseId, input, con
         input,
         store: true,
         truncation: "auto",
-        tools: [
-            { type: "computer" },
-            previewClickTool,
-        ],
+        tools: aimAssistMode === "off"
+            ? [{ type: "computer" }]
+            : [
+                { type: "computer" },
+                previewClickTool,
+            ],
     };
 }
 /**
@@ -139,10 +144,11 @@ export async function reviseTestScript({ client, originalScript, revisionRequest
  *   debugContext?: unknown,
  * }} options
  */
-export async function sendCUARequest({ client, cuaModel, contextOptimizationEnabled = true, contextOptimizationThreshold = DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, messages, screenshotBase64, previousResponseId, callId, deviceInfo, debugContext, }) {
+export async function sendCUARequest({ client, cuaModel, aimAssistMode = DEFAULT_AIM_ASSIST_MODE, contextOptimizationEnabled = true, contextOptimizationThreshold = DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, messages, screenshotBase64, previousResponseId, callId, deviceInfo, debugContext, }) {
     const input = buildCuaInput({ messages, screenshotBase64, previousResponseId, callId });
     const requestParams = buildCuaRequestParams({
         cuaModel,
+        aimAssistMode,
         previousResponseId,
         input,
         contextOptimizationEnabled,

package/build/src/modes/design-mode-ink.js

@@ -32,9 +32,7 @@ export class DesignModeInk {
     async start() {
         const addOutput = this.context.addOutput;
         // Set design mode system prompt
-        const designPrompt = buildDesignModePrompt(this.session.deviceInfo, {}, {
-            strictMode: Boolean(this.engine?.strictMode)
-        });
+        const designPrompt = buildDesignModePrompt(this.session.deviceInfo, {});
         this.baseDesignPrompt = designPrompt;
         this.session.setSystemPrompt(designPrompt);
         // Update UI

package/build/src/modes/design-mode.js

@@ -29,9 +29,7 @@ export class DesignMode {
      */
     async start(context) {
         // Set design mode system prompt
-        const designPrompt = buildDesignModePrompt(this.session.deviceInfo, {}, {
-            strictMode: Boolean(this.engine?.strictMode)
-        });
+        const designPrompt = buildDesignModePrompt(this.session.deviceInfo, {});
         this.baseDesignPrompt = designPrompt;
         this.session.setSystemPrompt(designPrompt);
         console.log(`\n=== Design Mode: Creating test "${this.testName}" ===`);

package/build/src/prompts/base.js

@@ -27,16 +27,6 @@ function appendCustomSections(prompt, sections = []) {
 ${customSection}
 `;
 }
-function buildStrictModeRuntimeSection(runtimeOptions = {}) {
-    if (runtimeOptions?.strictMode !== true) {
-        return "";
-    }
-    return `STRICT MODE - Observation-First Runtime:
-- The runtime may execute only the first meaningful action from any multi-step action chain you propose.
-- After that first action, it will re-observe the ${runtimeOptions?.platform === "browser" ? "browser" : "device"} and continue from a fresh screenshot.
-- If you propose multiple steps, assume only the first may happen before the next turn.
-- Do not assume later proposed actions succeeded unless the next screenshot confirms them.`;
-}
 function isBrowserTarget(deviceInfo = {}) {
     return typeof deviceInfo.platform === "string" && deviceInfo.platform.trim().toLowerCase() === "browser";
 }
@@ -55,7 +45,42 @@ function describeControlledTarget(deviceInfo = {}) {
     }
     return "a mobile device";
 }
-function buildBrowserBaseSystemPrompt(deviceInfo) {
+function buildAlwaysAimAssistGuidance(targetKind) {
+    return [
+        "- Before every click action, call `preview_click` with the exact coordinates you intend to click.",
+        "- Review the returned annotated screenshot before clicking.",
+        `- Click if the marker is clearly inside the intended ${targetKind === "browser" ? "clickable" : "tappable"} control.${targetKind === "browser" ? "" : " Text inside a button, field, row, or bottom bar is okay."}`,
+        `- Adjust and preview again only if the marker is outside the target, on the ${targetKind === "browser" ? "edge" : "target border/edge"}, or closer to a neighboring target than the intended one.`,
+        "- If you preview more than once, the next click should use the most recent accepted preview coordinates unless the screen changed.",
+        "- If the click does not cause the expected UI change, treat it as a likely misclick and try a meaningfully different coordinate.",
+        "- Click precisely based on your visual estimate.",
+    ];
+}
+function buildAimAssistGuidance(targetKind, aimAssistMode = "always") {
+    if (aimAssistMode === "off") {
+        return [
+            "- Click directly based on your best visual estimate.",
+            "- If a click has no effect, treat it as a likely misclick and try a meaningfully different coordinate.",
+            "- Click precisely based on your visual estimate.",
+        ].join("\n  ");
+    }
+    if (aimAssistMode === "smart") {
+        const targetWord = targetKind === "browser" ? "clickable" : "tappable";
+        return [
+            ...buildAlwaysAimAssistGuidance(targetKind),
+            "- In Smart mode, you may skip preview only when the target is broad, isolated, stable, and unambiguous, and you are confident the click point is clearly inside the intended target.",
+            "- Good skip examples are large empty text fields, large search fields, large CTA buttons with generous padding, launcher icons, and wide rows with generous spacing and no nearby competing actions.",
+            `- Do not skip preview when the target is small, dense, visually ambiguous, close to neighboring controls, or you are not confident the marker will land clearly inside the intended ${targetWord} target.`,
+            "- If a dropdown, expanded option list, popover, or select menu is visible, always use preview before selecting an option.",
+            "- Do not skip preview in search results, bottom sheets, bottom cards, modals, overlays, keyboard-driven flows, or after recent screen changes.",
+            "- Do not skip preview for known tricky UI such as dense lists, date pickers, time pickers, calendar cells, wheels, segmented selectors, and small inline controls inside larger rows or cards.",
+            "- If the target is one option among many visually similar options, use preview before clicking.",
+        ].join("\n  ");
+    }
+    return buildAlwaysAimAssistGuidance(targetKind).join("\n  ");
+}
+function buildBrowserBaseSystemPrompt(deviceInfo, options = {}) {
+    const aimAssistMode = typeof options.aimAssistMode === "string" ? options.aimAssistMode : "always";
     return `
   You are controlling ${describeControlledTarget(deviceInfo)} in a sandboxed testing environment.
   Follow the user's instructions to interact with the browser.
@@ -67,13 +92,7 @@ function buildBrowserBaseSystemPrompt(deviceInfo) {
 
   When aiming for visual targets:
   - Reason carefully about the approximate pixel position.
-  - Before every click action, call \`preview_click\` with the exact coordinates you intend to click.
-  - Review the returned annotated screenshot before clicking.
-  - Click if the marker is clearly inside the intended clickable target.
-  - Adjust and preview again only if the marker is outside the target, on the edge, or closer to a neighboring target than the intended one.
-  - If you preview more than once, the next click should use the most recent accepted preview coordinates unless the screen changed.
-  - If the click does not cause the expected UI change, treat it as a likely misclick and try a meaningfully different coordinate.
-  - Click precisely based on your visual estimate.
+  ${buildAimAssistGuidance("browser", aimAssistMode)}
 
   Available actions: click, scroll, type, keypress, wait, screenshot.
 
@@ -129,7 +148,8 @@ function buildBrowserBaseSystemPrompt(deviceInfo) {
   - CTRL/CMD/ALT/OPTION/SHIFT may be used when they are the most reliable path
   `;
 }
-function buildMobileBaseSystemPrompt(deviceInfo) {
+function buildMobileBaseSystemPrompt(deviceInfo, options = {}) {
+    const aimAssistMode = typeof options.aimAssistMode === "string" ? options.aimAssistMode : "always";
     return `
   You are controlling ${describeControlledTarget(deviceInfo)} in a sandboxed testing environment.
   Follow the user's instructions to interact with the device.
@@ -142,13 +162,7 @@ function buildMobileBaseSystemPrompt(deviceInfo) {
 
   When aiming for visual targets:
   - Reason carefully about the approximate pixel position.
-  - Before every click action, call \`preview_click\` with the exact coordinates you intend to click.
-  - Review the returned annotated screenshot before clicking.
-  - Click if the marker is clearly inside the intended tappable control. Text inside a button, field, row, or bottom bar is okay.
-  - Adjust and preview again only if the marker is outside the target, on the target border/edge, or closer to a neighboring target than the intended one.
-  - If you preview more than once, the next click should use the most recent accepted preview coordinates unless the screen changed.
-  - If the click does not cause the expected UI change, treat it as a likely misclick and try a meaningfully different coordinate.
-  - Click precisely based on your visual estimate.
+  ${buildAimAssistGuidance("mobile", aimAssistMode)}
 
   Available actions: click, scroll, type, keypress, wait, screenshot.
 
@@ -209,9 +223,9 @@ function buildMobileBaseSystemPrompt(deviceInfo) {
   - Never use CTRL, CMD, ALT, OPTION, or SHIFT in a keypress action
   `;
 }
-function buildBaseSystemPrompt(deviceInfo) {
+function buildBaseSystemPrompt(deviceInfo, options = {}) {
     return isBrowserTarget(deviceInfo)
-        ? buildBrowserBaseSystemPrompt(deviceInfo)
-        : buildMobileBaseSystemPrompt(deviceInfo);
+        ? buildBrowserBaseSystemPrompt(deviceInfo, options)
+        : buildMobileBaseSystemPrompt(deviceInfo, options);
 }
-export { appendCustomSections, buildBaseSystemPrompt, buildCustomInstructionsSection, describeControlledTarget, isBrowserTarget, buildStrictModeRuntimeSection, };
+export { appendCustomSections, buildBaseSystemPrompt, buildCustomInstructionsSection, describeControlledTarget, isBrowserTarget, };

package/build/src/prompts/design.js

@@ -1,8 +1,7 @@
-import { appendCustomSections, buildBaseSystemPrompt, buildStrictModeRuntimeSection, isBrowserTarget } from "./base.js";
-export function buildDesignModePrompt(deviceInfo, customInstructions = {}, runtimeOptions = {}) {
+import { appendCustomSections, buildBaseSystemPrompt, isBrowserTarget } from "./base.js";
+export function buildDesignModePrompt(deviceInfo, customInstructions = {}) {
     const designCustomText = typeof customInstructions.designModeInstructions === "string" ? customInstructions.designModeInstructions.trim() : "";
     const basePrompt = buildBaseSystemPrompt(deviceInfo, customInstructions);
-    const strictModeSection = buildStrictModeRuntimeSection(runtimeOptions);
     const browserTarget = isBrowserTarget(deviceInfo);
     const prompt = `${basePrompt}
 
@@ -87,7 +86,7 @@ WRONG Example (DON'T DO THIS):
 \`\`\`
 
 Remember: You are autonomous. Explore confidently. Generate simple, executable test scripts.
-` + (strictModeSection ? `\n\n${strictModeSection}` : "");
+`;
     return appendCustomSections(prompt, [
         { title: "Base Prompt Instructions", text: customInstructions.basePromptInstructions },
         { title: "Design Mode Instructions", text: designCustomText }