@loadmill/droid-cua 2.2.2 → 2.4.0

package/build/src/commands/run.js

@@ -4,6 +4,8 @@
 import { loadTest, listTests, testExists } from "../test-store/test-manager.js";
 import { ExecutionMode } from "../modes/execution-mode.js";
 import { buildExecutionModePrompt } from "../core/prompts.js";
+import { buildAppContextBriefing } from "../core/app-context.js";
+import { logger } from "../utils/logger.js";
 /**
  * Handle /run command
  * @param {string} args - Test name
@@ -49,6 +51,7 @@ export async function handleRun(args, session, context) {
     // Load test instructions
     addOutput({ type: 'system', text: `Loading test: ${testName}` });
     const instructions = await loadTest(testName);
+    const taskText = instructions.join("\n");
     addOutput({ type: 'info', text: `Loaded ${instructions.length} instructions` });
     addOutput({ type: 'info', text: '' });
     // Disable free-form input during execution (only allow commands like /exit)
@@ -69,8 +72,34 @@ export async function handleRun(args, session, context) {
     // Each test instruction should execute in isolation
     session.updateResponseId(undefined);
     session.clearMessages();
+    let appContextBriefing = '';
+    if (context.appContextPath) {
+        try {
+            const result = await buildAppContextBriefing({
+                contextPath: context.appContextPath,
+                taskText,
+                budget: context.appContextBudget,
+            });
+            appContextBriefing = result.briefing;
+            if (appContextBriefing) {
+                addOutput({ type: 'info', text: `Loaded app context briefing from: ${result.contextPath}` });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown app context error';
+            logger.error('CLI app context compaction failed', {
+                contextPath: context.appContextPath,
+                testName,
+                message,
+            });
+            addOutput({
+                type: 'warning',
+                text: `Warning: could not load app context from ${context.appContextPath}. Running without briefing.`,
+            });
+        }
+    }
     // Set execution mode system prompt (replaces any design mode prompt)
-    const executionPrompt = buildExecutionModePrompt(session.deviceInfo);
+    const executionPrompt = buildExecutionModePrompt(session.deviceInfo, {}, appContextBriefing, { strictMode: Boolean(context.engine?.strictMode) });
     session.setSystemPrompt(executionPrompt);
     // Create execution mode
     const executionMode = new ExecutionMode(session, context.engine, instructions);

package/build/src/core/app-context.js

@@ -0,0 +1,57 @@
+import path from "path";
+import { access, readFile } from "fs/promises";
+import { constants as fsConstants } from "fs";
+import { compactAppContext } from "../device/openai.js";
+export const APP_CONTEXT_FILENAME = "context.md";
+export const DEFAULT_APP_CONTEXT_BUDGET = 300;
+export const MIN_APP_CONTEXT_BUDGET = 100;
+export const MAX_APP_CONTEXT_BUDGET = 2000;
+export function normalizeAppContextBudget(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return DEFAULT_APP_CONTEXT_BUDGET;
+    }
+    const normalized = Math.round(value);
+    if (normalized < MIN_APP_CONTEXT_BUDGET) {
+        return MIN_APP_CONTEXT_BUDGET;
+    }
+    if (normalized > MAX_APP_CONTEXT_BUDGET) {
+        return MAX_APP_CONTEXT_BUDGET;
+    }
+    return normalized;
+}
+export function getDefaultProjectContextPath(projectPath) {
+    return path.join(projectPath, APP_CONTEXT_FILENAME);
+}
+export async function readAppContextFile(filePath) {
+    await access(filePath, fsConstants.R_OK);
+    return await readFile(filePath, "utf-8");
+}
+export async function appContextFileExists(filePath) {
+    try {
+        await access(filePath, fsConstants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function buildAppContextBriefing({ contextPath, taskText, budget = DEFAULT_APP_CONTEXT_BUDGET, }) {
+    if (!contextPath) {
+        return { briefing: "", contextPath: null };
+    }
+    const normalizedBudget = normalizeAppContextBudget(budget);
+    if (normalizedBudget === 0) {
+        return { briefing: "", contextPath };
+    }
+    const rawContext = await readAppContextFile(contextPath);
+    const result = await compactAppContext({
+        contextDocument: rawContext,
+        taskDescription: taskText,
+        tokenBudget: normalizedBudget,
+    });
+    return {
+        briefing: result.briefing,
+        outputTokens: result.outputTokens,
+        contextPath,
+    };
+}

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

@@ -5,6 +5,7 @@ import { handleModelAction } from "../device/actions.js";
 import { sendCUARequest } from "../device/openai.js";
 import { emitDesktopDebug } from "../utils/desktop-debug.js";
 import { getConfiguredStepDelayMs } from "../utils/step-delay.js";
+import { printCliOutput } from "../utils/console-output.js";
 function extractComputerCalls(items) {
     const entries = [];
     for (const item of items) {
@@ -30,12 +31,105 @@ function extractComputerCalls(items) {
     }
     return entries;
 }
+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.`;
+    return {
+        actionsToExecute,
+        droppedActions,
+        truncationReason,
+        runtimeNote
+    };
+}
 export class ExecutionEngine {
     constructor(session, options = {}) {
         this.session = session;
         this.recordScreenshots = options.recordScreenshots || false;
         this.screenshotDir = options.screenshotDir || null;
+        this.screenshotRecorder = options.screenshotRecorder || null;
+        this.strictMode = options.strictMode === true;
         this.stepDelayMs = getConfiguredStepDelayMs();
+        this.reportedScreenshotWriteError = false;
+        this.getScreenshotAsBase64 = options.getScreenshotAsBase64 || getScreenshotAsBase64;
+        this.handleModelAction = options.handleModelAction || handleModelAction;
+        this.sendCUARequest = options.sendCUARequest || sendCUARequest;
+        this.getCurrentPlatform = options.getCurrentPlatform || getCurrentPlatform;
+    }
+    async recordScreenshot(screenshotBase64, metadata = {}) {
+        if (typeof screenshotBase64 !== "string" || !screenshotBase64) {
+            return null;
+        }
+        try {
+            if (this.screenshotRecorder?.saveScreenshot) {
+                return await this.screenshotRecorder.saveScreenshot(screenshotBase64, metadata);
+            }
+            if (this.recordScreenshots && this.screenshotDir) {
+                const framePath = path.join(this.screenshotDir, `frame_${String(Date.now())}.png`);
+                await writeFile(framePath, Buffer.from(screenshotBase64, "base64"));
+                return framePath;
+            }
+        }
+        catch (error) {
+            if (!this.reportedScreenshotWriteError) {
+                this.reportedScreenshotWriteError = true;
+                const scope = typeof metadata.sessionId === "string" ? "design" : "execution";
+                const ids = scope === "design"
+                    ? {
+                        sessionId: metadata.sessionId,
+                        stepId: metadata.stepId,
+                        instructionIndex: metadata.instructionIndex
+                    }
+                    : {
+                        runId: metadata.runId,
+                        stepId: metadata.stepId,
+                        instructionIndex: metadata.instructionIndex
+                    };
+                emitDesktopDebug("run.screenshot_write.error", scope, ids, {
+                    captureSource: metadata.captureSource ?? null,
+                    message: error instanceof Error ? error.message : "Failed to persist screenshot"
+                });
+            }
+        }
+        return null;
     }
     /**
      * Run a full turn with the CUA model
@@ -46,8 +140,10 @@ export class ExecutionEngine {
      * @param {Object} context - Optional Ink context for output
      */
     async runFullTurn(response, trackAction = null, context = null, stepContext = null) {
-        const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+        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,
@@ -56,11 +152,8 @@ export class ExecutionEngine {
         });
         while (true) {
             // Check for interruption before processing next batch of actions
-            if (trackAction) {
-                const shouldStop = trackAction(null); // null action = pre-batch check
-                if (shouldStop) {
-                    return newResponseId;
-                }
+            if (shouldStop()) {
+                return newResponseId;
             }
             const items = response.output || [];
             const computerCalls = extractComputerCalls(items);
@@ -118,8 +211,12 @@ export class ExecutionEngine {
             for (const { call_id, actions } of computerCalls) {
                 if (!call_id)
                     continue;
+                const { actionsToExecute, droppedActions, truncationReason, runtimeNote } = buildStrictModePlan(actions, this.strictMode);
                 let sawExplicitScreenshotAction = false;
-                for (const action of actions) {
+                for (const action of actionsToExecute) {
+                    if (shouldStop()) {
+                        return newResponseId;
+                    }
                     if (action.type === "screenshot") {
                         sawExplicitScreenshotAction = true;
                         addOutput({
@@ -136,18 +233,19 @@ export class ExecutionEngine {
                         });
                     }
                     else {
-                        await handleModelAction(this.session.deviceId, action, this.session.deviceInfo.scale, {
+                        await this.handleModelAction(this.session.deviceId, action, this.session.deviceInfo.scale, {
                             ...context,
+                            shouldStop,
                             stepId: stepContext?.stepId,
                             instructionIndex: stepContext?.instructionIndex
                         });
                         // Track action and check for interruption
                         if (trackAction) {
-                            const shouldStop = trackAction(action);
-                            if (shouldStop) {
-                                // User interrupted - stop execution immediately
-                                return newResponseId;
-                            }
+                            trackAction(action);
+                        }
+                        if (shouldStop()) {
+                            // User interrupted - stop execution immediately
+                            return newResponseId;
                         }
                         // Add delay after UI-changing actions to let the interface update
                         // before taking the screenshot (except for explicit wait actions which have their own delay)
@@ -156,7 +254,10 @@ export class ExecutionEngine {
                         }
                     }
                 }
-                const screenshotBase64 = await getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
+                if (shouldStop()) {
+                    return newResponseId;
+                }
+                const screenshotBase64 = await this.getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
                 emitDesktopDebug("device.screenshot", "device", {
                     runId: context?.runId,
                     stepId: stepContext?.stepId,
@@ -168,9 +269,30 @@ export class ExecutionEngine {
                     height: this.session.deviceInfo?.scaled_height,
                     base64Length: screenshotBase64.length
                 });
-                if (this.recordScreenshots && this.screenshotDir) {
-                    const framePath = path.join(this.screenshotDir, `frame_${String(Date.now())}.png`);
-                    await writeFile(framePath, Buffer.from(screenshotBase64, "base64"));
+                await this.recordScreenshot(screenshotBase64, {
+                    runId: context?.runId,
+                    sessionId: context?.sessionId,
+                    stepId: stepContext?.stepId,
+                    instructionIndex: stepContext?.instructionIndex,
+                    callId: call_id,
+                    captureSource: sawExplicitScreenshotAction ? "call-output-explicit-action" : "call-output-post-action"
+                });
+                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
+                    });
                 }
                 // Build next input: screenshot + any carryover reasoning
                 const selectedCuaModel = process.env.OPENAI_CUA_MODEL === "computer-use-preview" ? "computer-use-preview" : "gpt-5.4";
@@ -182,16 +304,25 @@ export class ExecutionEngine {
                             image_url: `data:image/png;base64,${screenshotBase64}`,
                         },
                         ...(selectedCuaModel === "computer-use-preview"
-                            ? { current_url: getCurrentPlatform() === "ios" ? "ios://simulator" : "android://device" }
+                            ? { current_url: this.getCurrentPlatform() === "ios" ? "ios://simulator" : "android://device" }
                             : {}),
                         ...(pendingSafetyChecks.length > 0 ? { acknowledged_safety_checks: pendingSafetyChecks } : {})
                     }];
-                response = await sendCUARequest({
+                if (runtimeNote) {
+                    input.push({
+                        role: "user",
+                        content: runtimeNote
+                    });
+                }
+                if (shouldStop()) {
+                    return newResponseId;
+                }
+                response = await this.sendCUARequest({
                     messages: input,
                     previousResponseId: newResponseId,
                     deviceInfo: this.session.deviceInfo,
                     debugContext: {
-                        scope: context?.sessionId ? "design" : "execution",
+                        scope,
                         runId: context?.runId,
                         sessionId: context?.sessionId,
                         stepId: stepContext?.stepId,

package/build/src/core/prompts.js

@@ -1,247 +1,3 @@
-/**
- * System prompt templates for different modes
- */
-function buildCustomInstructionsSection(sections = []) {
-    const nonEmptySections = sections
-        .map((section) => ({
-        title: section?.title,
-        text: typeof section?.text === "string" ? section.text.trim() : ""
-    }))
-        .filter((section) => section.title && section.text);
-    if (nonEmptySections.length === 0) {
-        return "";
-    }
-    const renderedSections = nonEmptySections
-        .map((section) => `${section.title}:\n${section.text}`)
-        .join("\n\n");
-    return `USER CUSTOM INSTRUCTIONS:
-Follow these user-configured instructions in addition to the default behavior below.
-Prefer these custom instructions when deciding how to behave.
-
-${renderedSections}`;
-}
-function appendCustomSections(prompt, sections = []) {
-    const customSection = buildCustomInstructionsSection(sections);
-    if (!customSection) {
-        return prompt;
-    }
-    return `${prompt}
-
-${customSection}
-`;
-}
-function describeControlledDevice(deviceInfo = {}) {
-    const platform = typeof deviceInfo.platform === "string" ? deviceInfo.platform.trim().toLowerCase() : "";
-    const deviceName = typeof deviceInfo.device_name === "string" ? deviceInfo.device_name.trim() : "";
-    if (platform === "ios") {
-        return deviceName ? `an iOS simulator (${deviceName})` : "an iOS device";
-    }
-    if (platform === "android") {
-        return deviceName ? `an Android device (${deviceName})` : "an Android device";
-    }
-    return "a mobile device";
-}
-export function buildBaseSystemPrompt(deviceInfo, customInstructions = {}) {
-    const controlledDevice = describeControlledDevice(deviceInfo);
-    const prompt = `
-  You are controlling ${controlledDevice} in a sandboxed testing environment.
-  Follow the user's instructions to interact with the device.
-
-  The device screen has been scaled down for display.
-  You can interact with any part of the visible phone screen, including system UI, browser UI, and app content.
-
-  The screen you see is ${deviceInfo.scaled_width} x ${deviceInfo.scaled_height} pixels.
-  Pixel (0,0) is at the top-left corner.
-
-  When aiming for visual targets:
-  - Reason carefully about the approximate pixel position.
-  - Click precisely based on your visual estimate.
-
-  Available actions: click, scroll, type, keypress, wait, screenshot.
-
-  CRITICAL - Mobile Input Constraints:
-  - This is a mobile device, not a desktop. Do NOT use desktop keyboard shortcuts or modifier chords.
-  - NEVER emit key combinations such as CTRL+A, CMD+A, CTRL+C, CTRL+V, ALT+TAB, SHIFT+ENTER, or similar shortcuts.
-  - Use 'keypress' only for a single mobile-safe key when absolutely necessary.
-  - To replace text, tap into the field and type the desired value. If correction is needed, use mobile-safe deletion only.
-  - Prefer tapping visible controls over hardware key events.
-
-  CRITICAL - Automatic Timing:
-  - After EVERY action (click, type, keypress, scroll), there is an automatic 500ms delay
-  - This 500ms is sufficient for normal UI updates and animations
-  - DO NOT add 'wait' actions unnecessarily - trust the automatic delay
-
-  Use explicit 'wait' action ONLY in these specific cases:
-  1. After launching apps from home screen or app drawer
-  2. After pressing ENTER that triggers navigation (search, URL, form submit)
-  3. After clicking links that open new apps or pages
-  4. After actions that trigger heavy loading (camera, maps, etc.)
-
-  When you MUST wait:
-  - Click app icon from home → wait → Continue
-  - Type in search box → Press ENTER → wait → Continue
-  - Click link that opens new page/app → wait → Continue
-  - Open camera/maps/heavy feature → wait → Continue
-
-  When you should NOT wait (automatic 500ms handles it):
-  - Clicking UI buttons within a running app (click button - no wait needed)
-  - Typing in text fields (type text - no wait needed)
-  - Scrolling (scroll - no wait needed)
-  - Clicking tabs or menu items within an app (click - no wait needed)
-
-  Rule of thumb: Wait for app launches and navigation. Everything else has automatic timing.
-
-  Perform the user's requested actions within the current view.
-
-  If unsure about visual elements, take a screenshot to improve your reasoning.
-  If unsure about the user's intent, make the best decision you can based on context and continue automatically.
-
-  CRITICAL - Never Ask Questions:
-  - NEVER ask the user for confirmation, clarification, or next steps
-  - NEVER ask questions like "Should I...", "Would you like...", "Do you want me to..."
-  - NEVER wait for user guidance - make autonomous decisions
-  - If stuck, try alternative approaches (go back, try different UI element, restart app)
-  - ONLY stop when the task is complete or you've exhausted reasonable approaches
-
-  Act decisively to complete the task.
-
-  Stop acting once the task appears complete.
-  Only complete the current instruction. Do not proceed beyond the current step unless asked.
-
-  Mobile-Specific Notes:
-  - ESC key maps to the Home button (return to home screen)
-  - Use Home button (ESC) to escape from stuck situations and restart
-  - Never use CTRL, CMD, ALT, OPTION, or SHIFT in a keypress action
-  `;
-    return prompt;
-}
-export function buildDesignModePrompt(deviceInfo, customInstructions = {}) {
-    const designCustomText = typeof customInstructions.designModeInstructions === "string" ? customInstructions.designModeInstructions.trim() : "";
-    const basePrompt = buildBaseSystemPrompt(deviceInfo, customInstructions);
-    const prompt = `${basePrompt}
-
-DESIGN MODE:
-You are helping design a test script for an Android app.
-Some tests intentionally validate negative outcomes (errors, failures, rejected inputs). These are expected and should be treated as successful progress when they match the test goal.
-
-Your task:
-1. Understand what the user wants to test from their initial instruction
-2. Explore the app autonomously to understand the flows
-3. Take screenshots and interact as needed to discover the UI and behavior
-4. Once you've successfully completed the user's requested flow, immediately generate the test script
-
-CRITICAL - After Completing the Task:
-- DO NOT navigate back or away from the final screen
-- The final screen state is what matters for verification
-- Generate the test script immediately showing the current state
-- Use assertions to verify state, not navigation
-- "Check that it changed" means verify the current visual state, not navigate elsewhere
-- If the target validation state is visible (including expected error states), STOP actions and immediately output the final test script
-
-CRITICAL - Recognizing When You Are Stuck:
-If you find yourself:
-- Repeating similar actions multiple times (e.g., opening/closing the same app repeatedly)
-- Not reaching a new screen or state after several attempts
-- Unsure about a higher-level decision (which tab to use, which mode to enter, where to start)
-- Unable to find the UI element or feature the user mentioned
-
-THEN STOP ACTING IMMEDIATELY and ask the user for guidance:
-1. Briefly describe what you see on screen now
-2. Explain what you were trying to do and why you're stuck
-3. Ask a single, concrete question to unblock the next step
-
-Example:
-"Chrome is open but I don't see a search bar or new tab button. Should I open a new tab, or is there a specific way you'd like me to navigate?"
-
-DO NOT continue brute-forcing the UI when stuck. The user prefers being asked over watching repeated failed attempts.
-DO NOT ask if the user wants a script after successfully completing the flow - just generate it automatically.
-
-CRITICAL - Off-Screen Element Discovery:
-- If a required element is not visible, assume it may be off-screen before changing strategy
-- Humans naturally scroll when UI appears cropped; do the same
-- Use this discovery sequence before retries or fallback navigation:
-  1. Scroll the screen in the likely direction to reveal hidden content
-  2. If still missing, do one minimal fallback (e.g., close overlay or go back once), then retry discovery
-- Do not repeat already-successful actions while searching for an off-screen target
-
-CRITICAL - Test Script Format Rules:
-- One simple instruction per line (NO numbers, NO bullets)
-- Use imperative commands: "Open X", "Click Y", "Type Z"
-- Include "assert: <condition>" lines to validate expected behavior
-- Normalize validation wording into assertions:
-  - Convert "check", "verify", "ensure", "fetch", and "compare" intent into explicit "assert: ..." lines
-  - Do not leave standalone "Check ..." or "Verify ..." lines in the final script
-- Merge duplicate or near-duplicate validation lines into one clear assertion
-- End with "exit"
-- Keep it simple and executable
-- When you generate the final result, include a suggested test name before the script
-- The suggested test name must be very short: prefer 2 to 4 words
-- Focus on the main user goal, not every assertion or detail
-- The suggested test name must be lowercase, kebab-case, and filename-safe
-- Use this exact final format:
-Suggested test name: short-kebab-case-name
-
-\`\`\`
-<test script here>
-\`\`\`
-
-CORRECT Example:
-Suggested test name: calculator-addition
-
-\`\`\`
-Open Calculator app
-assert: Calculator app is visible
-Type "2"
-Click the plus button
-Type "3"
-Click the equals button
-assert: result shows 5
-exit
-\`\`\`
-
-WRONG Example (DON'T DO THIS):
-\`\`\`
-1. Open Calculator app
-2. Verify the app opened
-3. etc...
-\`\`\`
-
-Remember: You are autonomous. Explore confidently. Generate simple, executable test scripts.
-`;
-    return appendCustomSections(prompt, [
-        { title: "Base Prompt Instructions", text: customInstructions.basePromptInstructions },
-        { title: "Design Mode Instructions", text: designCustomText }
-    ]);
-}
-export function buildExecutionModePrompt(deviceInfo, customInstructions = {}) {
-    const executionCustomText = typeof customInstructions.executionModeInstructions === "string" ? customInstructions.executionModeInstructions.trim() : "";
-    const basePrompt = buildBaseSystemPrompt(deviceInfo, customInstructions);
-    const prompt = `${basePrompt}
-
-EXECUTION MODE - Critical Behavior:
-You are executing test script commands one at a time. This is NOT a conversation.
-
-CRITICAL RULES:
-- DO NOT generate conversational text or narration
-- DO NOT ask questions like "What should I do next?", "Would you like...", "Can I assist...?"
-- DO NOT describe what you see on screen
-- DO NOT say "Let me know if you need help" or similar phrases
-- Just execute the action silently and stop immediately
-- Only generate text if the action FAILED or cannot be completed
-- Never emit desktop keyboard shortcuts or modifier combos; mobile execution only supports mobile-safe single-key presses
-- If target is not visible, perform bounded off-screen discovery first:
-  1. Scroll the screen in the likely direction to reveal hidden controls
-  2. If still missing, do one minimal fallback (e.g., close overlay or go back once), then retry
-
-Your process:
-1. Read the instruction
-2. Execute the required actions
-3. Stop immediately - no commentary, no questions
-
-Each instruction is independent. Do not reference previous instructions or ask about next steps.
-`;
-    return appendCustomSections(prompt, [
-        { title: "Base Prompt Instructions", text: customInstructions.basePromptInstructions },
-        { title: "Execution Mode Instructions", text: executionCustomText }
-    ]);
-}
+export { buildBaseSystemPrompt } from "../prompts/base.js";
+export { buildDesignModePrompt, buildDesignRecoveryPrompt } from "../prompts/design.js";
+export { buildAppContextSection, buildAssertionSystemPrompt, buildExecutionModePrompt, buildExecutionRecoveryPrompt, } from "../prompts/execution.js";

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

@@ -14,8 +14,8 @@ function normalizeMobileKeypress(keys = []) {
     }
     const key = String(keys[0]).trim().toUpperCase();
     const mobileKeyMap = {
-        ESC: "KEYCODE_HOME",
-        ESCAPE: "KEYCODE_HOME",
+        ESC: "KEYCODE_BACK",
+        ESCAPE: "KEYCODE_BACK",
         HOME: "KEYCODE_HOME",
         BACK: "KEYCODE_BACK",
         ENTER: "KEYCODE_ENTER",