@loadmill/droid-cua 2.8.0 → 2.9.0

package/README.md

@@ -40,6 +40,7 @@ Under the hood, `droid-cua` uses an AI agent to explore your app, execute action
 
 - Mac: [Download](https://github.com/loadmill/droid-cua-release/releases/latest/download/Loadmill-Droid-CUA.dmg)
 - Mac (Intel): [Download](https://github.com/loadmill/droid-cua-release/releases/latest/download/Loadmill-Droid-CUA-intel.dmg)
+- Windows: [Download](https://github.com/loadmill/droid-cua-release/releases/latest/download/Loadmill-Droid-CUA-Setup.exe)
 
 **2. Launch the app**
 
@@ -67,6 +68,10 @@ You can also keep project run history in a results folder and review past runs f
 - **Android** - Physical devices and emulators
 - **iOS** - Simulators on macOS
 
+Desktop app support:
+- macOS: Android and iOS simulator workflows
+- Windows: Android workflows only
+
 ## Requirements
 
 **All platforms:**
@@ -154,10 +159,9 @@ Example headless config:
     "executionModeInstructions": ""
   },
   "appContextEnabled": true,
-  "appContextBudget": 300,
   "appContextPath": "../tests/context.md",
   "contextOptimizationEnabled": true,
-  "contextOptimizationThreshold": 30000
+  "contextOptimizationThreshold": 20000
 }
 ```
 
@@ -177,7 +181,6 @@ Supported CLI options include:
 - `--config`
 - `--cua-model`
 - `--context`
-- `--app-context-budget`
 - `--no-context`
 - `--context-optimization-threshold`
 - `--no-context-optimization`
@@ -195,7 +198,7 @@ Config and precedence rules:
 - CLI flags override config file values.
 - `--context` overrides the config app-context path.
 - `--no-context` disables app context entirely.
-- Context Optimization is enabled by default with a `30000` input-token threshold.
+- Context Optimization is enabled by default with a `20000` input-token threshold.
 - `--context-optimization-threshold <tokens>` sets the threshold and enables Context Optimization.
 - `--no-context-optimization` disables Context Optimization.
 - `--base-prompt` and `--execution-prompt` let you pass prompt customizations inline on the command line.

package/build/index.js

@@ -11,16 +11,18 @@ import { ExecutionEngine } from "./src/core/execution-engine.js";
 import { buildBaseSystemPrompt, buildExecutionModePrompt } from "./src/core/prompts.js";
 import { startInkShell } from "./src/cli/ink-shell.js";
 import { ExecutionMode } from "./src/modes/execution-mode.js";
+import { createOpenAiExecutor } from "./src/device/openai.js";
 import { logger } from "./src/utils/logger.js";
 import { selectDevice } from "./src/cli/device-selector.js";
-import { buildAppContextBriefing, DEFAULT_APP_CONTEXT_BUDGET } from "./src/core/app-context.js";
-import { CONTEXT_OPTIMIZATION_ENABLED_ENV, CONTEXT_OPTIMIZATION_THRESHOLD_ENV, } from "./src/core/context-optimization.js";
+import { resolveExecutionAppContext } from "./src/core/app-context.js";
+import { createRunContext, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "./src/core/runtime-config.js";
 import { resolveHeadlessExecutionConfig } from "./src/cli/headless-execution-config.js";
 import { resolveHeadlessTarget } from "./src/cli/headless-target.js";
 import { printCliOutput } from "./src/utils/console-output.js";
 import { emitDesktopDebug } from "./src/utils/desktop-debug.js";
 import { createHeadlessDebugArtifacts } from "./src/cli/headless-debug.js";
 import { loadHeadlessInstructions } from "./src/cli/headless-instructions.js";
+import { createLoadmillApiClient } from "./src/integrations/loadmill/client.js";
 dotenv.config();
 const args = minimist(process.argv.slice(2));
 const targetConfig = resolveHeadlessTarget(args);
@@ -38,6 +40,28 @@ if (strictFlag && noStrictFlag) {
 const screenshotDir = path.join("droid-cua-recording-" + Date.now());
 if (recordScreenshots)
     await mkdir(screenshotDir, { recursive: true });
+function createCliRuntimeContext(configOverrides = {}) {
+    // CLI env/config is bootstrap input only. After this boundary the shared
+    // runtime uses explicit run-scoped config and credentials objects.
+    const context = createRunContext({
+        config: resolveRuntimeConfigFromEnv(process.env, configOverrides),
+        credentials: resolveRuntimeCredentialsFromEnv(process.env),
+    });
+    const openAi = createOpenAiExecutor({
+        client: context.clients.openai,
+        config: context.config,
+    });
+    const loadmillClient = createLoadmillApiClient({
+        token: context.credentials.loadmillApiToken,
+        baseUrl: context.credentials.loadmillBaseUrl,
+    });
+    return {
+        ...context,
+        openAi,
+        openAiClient: context.clients.openai,
+        loadmillClient,
+    };
+}
 async function main() {
     const isHeadlessInstructionsRun = Boolean(instructionsFile);
     const isBrowserTarget = targetConfig.target === "web";
@@ -102,71 +126,55 @@ async function main() {
             }
             console.log(`\nRunning test from: ${instructionsFile}\n`);
             instructions = await loadHeadlessInstructions(instructionsFile);
-            const taskText = instructions.join("\n");
             const headlessConfig = await resolveHeadlessExecutionConfig(args);
-            process.env.OPENAI_CUA_MODEL = headlessConfig.cuaModel;
-            process.env[CONTEXT_OPTIMIZATION_ENABLED_ENV] = String(headlessConfig.contextOptimizationEnabled);
-            process.env[CONTEXT_OPTIMIZATION_THRESHOLD_ENV] = String(headlessConfig.contextOptimizationThreshold);
-            console.log(`Using CUA model: ${headlessConfig.cuaModel}`);
-            let appContextBriefing = "";
-            if (!headlessConfig.appContextEnabled) {
-                emitDesktopDebug("app_context.status", "execution", { runId }, {
+            const appContext = await resolveExecutionAppContext({
+                enabled: headlessConfig.appContextEnabled,
+                contextPath: headlessConfig.appContextPath,
+            });
+            const appContextText = appContext.text;
+            const runtimeContext = createCliRuntimeContext({
+                cuaModel: headlessConfig.cuaModel,
+                strictMode: headlessConfig.strictMode,
+                promptCustomizations: headlessConfig.promptCustomizations,
+                contextOptimizationEnabled: headlessConfig.contextOptimizationEnabled,
+                contextOptimizationThreshold: headlessConfig.contextOptimizationThreshold,
+                appContext: {
+                    enabled: headlessConfig.appContextEnabled,
+                    path: appContext.contextPath,
+                    status: appContext.status,
+                    text: appContextText,
+                    message: appContext.message,
+                },
+            });
+            console.log(`Using CUA model: ${runtimeContext.config.cuaModel}`);
+            if (appContext.status === "loaded" || appContext.status === "empty") {
+                emitDesktopDebug("app_context.loaded", "execution", { runId }, {
                     source: "cli_context_flag",
-                    contextPath: null,
-                    budget: headlessConfig.appContextBudget,
-                    status: "disabled"
+                    contextPath: appContext.contextPath,
+                    status: appContext.status,
+                    text: appContextText
                 });
-            }
-            else if (headlessConfig.appContextPath) {
-                try {
-                    const result = await buildAppContextBriefing({
-                        contextPath: headlessConfig.appContextPath,
-                        taskText,
-                        budget: headlessConfig.appContextBudget,
-                    });
-                    appContextBriefing = result.briefing;
-                    emitDesktopDebug("app_context.status", "execution", { runId }, {
-                        source: "cli_context_flag",
-                        contextPath: result.contextPath,
-                        budget: headlessConfig.appContextBudget,
-                        outputTokens: result.outputTokens,
-                        status: appContextBriefing.trim().length > 0 ? "loaded" : "empty"
-                    });
-                    if (appContextBriefing) {
-                        emitDesktopDebug("app_context.briefing.full", "execution", { runId }, {
-                            source: "cli_context_flag",
-                            contextPath: result.contextPath,
-                            budget: headlessConfig.appContextBudget,
-                            outputTokens: result.outputTokens,
-                            briefing: appContextBriefing
-                        });
-                        console.log(`Using app context briefing from: ${result.contextPath}`);
-                    }
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : "Unknown app context error";
-                    emitDesktopDebug("app_context.status", "execution", { runId }, {
-                        source: "cli_context_flag",
-                        contextPath: headlessConfig.appContextPath,
-                        budget: headlessConfig.appContextBudget,
-                        status: "failed",
-                        message
-                    });
-                    console.warn(`Warning: could not load app context from ${headlessConfig.appContextPath}. Running without briefing.`);
+                if (appContextText) {
+                    console.log(`Using app context from: ${appContext.contextPath}`);
                 }
             }
+            else if (appContext.status === "failed") {
+                emitDesktopDebug("app_context.loaded", "execution", { runId }, {
+                    source: "cli_context_flag",
+                    contextPath: appContext.contextPath,
+                    status: "failed",
+                    message: appContext.message
+                });
+                console.warn(`Warning: could not load app context from ${appContext.contextPath}. Running without it.`);
+            }
             else {
-                emitDesktopDebug("app_context.status", "execution", { runId }, {
+                emitDesktopDebug("app_context.loaded", "execution", { runId }, {
                     source: "cli_context_flag",
-                    contextPath: null,
-                    budget: headlessConfig.appContextBudget,
-                    status: "missing"
+                    contextPath: appContext.contextPath,
+                    status: appContext.status
                 });
-                if (isBrowserTarget && deviceInfo.currentUrl) {
-                    appContextBriefing = `Starting URL: ${deviceInfo.currentUrl}`;
-                }
             }
-            const executionPrompt = buildExecutionModePrompt(deviceInfo, headlessConfig.promptCustomizations, appContextBriefing, { strictMode: headlessConfig.strictMode });
+            const executionPrompt = buildExecutionModePrompt(deviceInfo, headlessConfig.promptCustomizations, appContextText, { strictMode: headlessConfig.strictMode });
             session.setSystemPrompt(executionPrompt);
             const screenshotRecorder = headlessDebug.createExecutionScreenshotRecorder({
                 runId,
@@ -177,12 +185,18 @@ async function main() {
                 ? {
                     recordScreenshots: true,
                     screenshotRecorder,
-                    strictMode: headlessConfig.strictMode
+                    strictMode: runtimeContext.config.strictMode,
+                    stepDelayMs: runtimeContext.config.stepDelayMs,
+                    sendCUARequest: runtimeContext.openAi.sendCUARequest,
+                    reviseTestScript: runtimeContext.openAi.reviseTestScript,
                 }
                 : {
                     recordScreenshots,
                     screenshotDir,
-                    strictMode: headlessConfig.strictMode
+                    strictMode: runtimeContext.config.strictMode,
+                    stepDelayMs: runtimeContext.config.stepDelayMs,
+                    sendCUARequest: runtimeContext.openAi.sendCUARequest,
+                    reviseTestScript: runtimeContext.openAi.reviseTestScript,
                 };
             if (isBrowserTarget) {
                 engineOptions.getScreenshotAsBase64 = (browserSessionId, browserInfo) => getBrowserScreenshotAsBase64(browserSessionId, browserInfo);
@@ -193,7 +207,10 @@ async function main() {
             executionMode = new ExecutionMode(session, engine, instructions, true);
             const result = await executionMode.execute({
                 runId,
-                addOutput: printCliOutput
+                addOutput: printCliOutput,
+                openAiClient: runtimeContext.openAiClient,
+                loadmillClient: runtimeContext.loadmillClient,
+                runtimeCredentials: runtimeContext.credentials,
             });
             const stats = executionMode.stats || {};
             const durationMs = stats.startTime ? Math.max(0, Date.now() - stats.startTime) : 0;
@@ -238,15 +255,21 @@ async function main() {
             throw error;
         }
     }
+    const runtimeContext = createCliRuntimeContext({
+        strictMode: strictFlag,
+    });
     const engine = new ExecutionEngine(session, {
         recordScreenshots,
         screenshotDir,
-        strictMode: strictFlag,
+        strictMode: runtimeContext.config.strictMode,
+        stepDelayMs: runtimeContext.config.stepDelayMs,
+        sendCUARequest: runtimeContext.openAi.sendCUARequest,
+        reviseTestScript: runtimeContext.openAi.reviseTestScript,
     });
     // Otherwise, start interactive Ink shell
     await startInkShell(session, engine, {
         appContextPath: appContextPath ? path.resolve(appContextPath) : null,
-        appContextBudget: DEFAULT_APP_CONTEXT_BUDGET,
+        runtimeContext,
     });
 }
 main().catch((error) => {

package/build/src/browser/playwright/connection.js

@@ -8,6 +8,17 @@ import { clearActiveBrowserSession, getActiveBrowserSession, setActiveBrowserSes
 import { normalizeAutomationUrl, normalizeOptionalAutomationUrl } from "./url.js";
 const DEFAULT_VIEWPORT = { width: 1440, height: 900 };
 let browserConnectionTestHooks = null;
+async function gotoWithTimeoutTolerance(page, url) {
+    try {
+        await page.goto(url, { waitUntil: "load" });
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.name !== "TimeoutError") {
+            throw error;
+        }
+        console.warn(`Page load did not finish within the timeout for ${url}. Continuing with the current page state.`);
+    }
+}
 function normalizeKnownPageUrl(url) {
     if (typeof url !== "string" || url.trim().length === 0 || url.trim() === "about:blank") {
         return null;
@@ -133,7 +144,7 @@ export async function connectToBrowser(targetOrOptions) {
         });
     });
     if (normalizedUrl) {
-        await primaryPage.goto(normalizedUrl, { waitUntil: "load" });
+        await gotoWithTimeoutTolerance(primaryPage, normalizedUrl);
     }
     setActiveBrowserSession({
         sessionId,
@@ -169,7 +180,7 @@ export async function getScreenshotAsBase64(browserSessionId) {
 export async function navigateToUrl(browserSessionId, url) {
     const session = getActiveBrowserSession(browserSessionId);
     const normalizedUrl = normalizeAutomationUrl(url);
-    await session.page.goto(normalizedUrl, { waitUntil: "load" });
+    await gotoWithTimeoutTolerance(session.page, normalizedUrl);
     session.url = normalizedUrl;
     emitDesktopDebug("browser.navigate", "device", { browserSessionId }, {
         platform: "browser",

package/build/src/cli/headless-execution-config.js

@@ -1,9 +1,7 @@
 import path from "path";
 import { readFile } from "fs/promises";
-import { DEFAULT_APP_CONTEXT_BUDGET, MAX_APP_CONTEXT_BUDGET, MIN_APP_CONTEXT_BUDGET, } from "../core/app-context.js";
 import { DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, MAX_CONTEXT_OPTIMIZATION_THRESHOLD, MIN_CONTEXT_OPTIMIZATION_THRESHOLD, } from "../core/context-optimization.js";
-const VALID_CUA_MODELS = new Set(["gpt-5.4", "gpt-5.4-mini", "computer-use-preview"]);
-const VALID_CUA_MODEL_LIST = ["gpt-5.4", "gpt-5.4-mini", "computer-use-preview"];
+import { CUA_MODELS, isValidCuaModel, resolveCuaModel } from "../core/cua-models.js";
 function createEmptyPromptCustomizations() {
     return {
         basePromptInstructions: "",
@@ -20,17 +18,13 @@ function assertNonEmptyString(value, label) {
     }
 }
 function validateCuaModel(value, label) {
-    if (typeof value !== "string" || !VALID_CUA_MODELS.has(value)) {
-        throw new Error(`${label} must be one of: ${VALID_CUA_MODEL_LIST.join(", ")}.`);
+    if (typeof value !== "string" || !isValidCuaModel(value)) {
+        throw new Error(`${label} must be one of: ${CUA_MODELS.join(", ")}.`);
     }
     return value;
 }
 function readEnvDefaultCuaModel() {
-    const rawValue = process.env.OPENAI_CUA_MODEL;
-    if (typeof rawValue !== "string" || rawValue.trim().length === 0) {
-        return "gpt-5.4";
-    }
-    return VALID_CUA_MODELS.has(rawValue) ? rawValue : "gpt-5.4";
+    return resolveCuaModel(process.env.OPENAI_CUA_MODEL);
 }
 function parseBooleanFlagState(args, key) {
     return {
@@ -38,24 +32,6 @@ function parseBooleanFlagState(args, key) {
         disabled: args[`no-${key}`] === true || args[key] === false,
     };
 }
-function parseBudgetValue(rawValue, label) {
-    const numericValue = (() => {
-        if (typeof rawValue === "number") {
-            return rawValue;
-        }
-        if (typeof rawValue === "string" && /^-?\d+$/.test(rawValue.trim())) {
-            return Number.parseInt(rawValue, 10);
-        }
-        return Number.NaN;
-    })();
-    if (!Number.isInteger(numericValue)) {
-        throw new Error(`${label} must be an integer between ${MIN_APP_CONTEXT_BUDGET} and ${MAX_APP_CONTEXT_BUDGET}.`);
-    }
-    if (numericValue < MIN_APP_CONTEXT_BUDGET || numericValue > MAX_APP_CONTEXT_BUDGET) {
-        throw new Error(`${label} must be between ${MIN_APP_CONTEXT_BUDGET} and ${MAX_APP_CONTEXT_BUDGET}.`);
-    }
-    return numericValue;
-}
 function parseContextOptimizationThreshold(rawValue, label) {
     const numericValue = (() => {
         if (typeof rawValue === "number") {
@@ -133,7 +109,6 @@ async function loadConfigFromFile(configPath) {
         cuaModel: undefined,
         promptCustomizations: createEmptyPromptCustomizations(),
         appContextEnabled: undefined,
-        appContextBudget: undefined,
         appContextPath: undefined,
         contextOptimizationEnabled: undefined,
         contextOptimizationThreshold: undefined,
@@ -151,9 +126,6 @@ async function loadConfigFromFile(configPath) {
         }
         normalized.appContextEnabled = rawConfig.appContextEnabled;
     }
-    if ("appContextBudget" in rawConfig) {
-        normalized.appContextBudget = parseBudgetValue(rawConfig.appContextBudget, "config.appContextBudget");
-    }
     if ("appContextPath" in rawConfig && rawConfig.appContextPath != null) {
         assertNonEmptyString(rawConfig.appContextPath, "config.appContextPath");
         normalized.appContextPath = path.resolve(configDir, rawConfig.appContextPath);
@@ -210,7 +182,6 @@ export async function resolveHeadlessExecutionConfig(args, options = {}) {
         cuaModel: fileConfig?.cuaModel || readEnvDefaultCuaModel(),
         promptCustomizations,
         appContextEnabled: fileConfig?.appContextEnabled ?? true,
-        appContextBudget: fileConfig?.appContextBudget ?? DEFAULT_APP_CONTEXT_BUDGET,
         appContextPath: fileConfig?.appContextPath || null,
         contextOptimizationEnabled: fileConfig?.contextOptimizationEnabled ?? true,
         contextOptimizationThreshold: fileConfig?.contextOptimizationThreshold ?? DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD,
@@ -219,9 +190,6 @@ export async function resolveHeadlessExecutionConfig(args, options = {}) {
     if (typeof args["cua-model"] === "string") {
         resolved.cuaModel = validateCuaModel(args["cua-model"], "--cua-model");
     }
-    if (args["app-context-budget"] != null) {
-        resolved.appContextBudget = parseBudgetValue(args["app-context-budget"], "--app-context-budget");
-    }
     if (hasContextOptimizationThresholdFlag) {
         resolved.contextOptimizationEnabled = true;
         resolved.contextOptimizationThreshold = parseContextOptimizationThreshold(args["context-optimization-threshold"], "--context-optimization-threshold");

package/build/src/cli/ink-shell.js

@@ -7,7 +7,7 @@ import { routeCommand } from '../commands/index.js';
  * Start the Ink-based conversational shell
  * @param {Object} session - Session object with device info
  * @param {Object} executionEngine - Execution engine instance
- * @param {{ appContextPath?: string | null, appContextBudget?: number }} [options]
+ * @param {{ appContextPath?: string | null, runtimeContext?: Object | null }} [options]
  * @returns {Promise<void>}
  */
 export async function startInkShell(session, executionEngine, options = {}) {
@@ -34,7 +34,10 @@ export async function startInkShell(session, executionEngine, options = {}) {
                 ...context,
                 engine: executionEngine,
                 appContextPath: options.appContextPath ?? null,
-                appContextBudget: options.appContextBudget
+                runtimeContext: options.runtimeContext ?? null,
+                openAiClient: options.runtimeContext?.openAiClient ?? null,
+                loadmillClient: options.runtimeContext?.loadmillClient ?? null,
+                runtimeCredentials: options.runtimeContext?.credentials ?? null
             });
             if (!shouldContinue) {
                 shouldExit = true;

package/build/src/commands/help.js

@@ -24,9 +24,8 @@ export async function handleHelp(args, session, context) {
     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, gpt-5.4-mini, or computer-use-preview' });
-    addOutput({ type: 'info', text: '  --context <file>       Optional app context file used to brief execution runs' });
-    addOutput({ type: 'info', text: '  --app-context-budget   Headless app context token budget override' });
+    addOutput({ type: 'info', text: '  --cua-model <model>    Headless CUA model override: gpt-5.4 or gpt-5.4-mini' });
+    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' });
     addOutput({ type: 'info', text: '  --no-context-optimization Disable Context Optimization for headless execution' });

package/build/src/commands/loadmill.js

@@ -1,7 +1,8 @@
 /**
  * Loadmill command handler
  */
-import { executeLoadmillCommand, getApiToken } from "../integrations/loadmill/index.js";
+import { createLoadmillApiClient, executeLoadmillCommand, getApiToken } from "../integrations/loadmill/index.js";
+import { createOpenAiClient, resolveRuntimeCredentialsFromEnv } from "../core/runtime-config.js";
 /**
  * Handle /loadmill command
  * @param {string} args - Command arguments (natural language command)
@@ -47,8 +48,16 @@ export async function handleLoadmill(args, session, context) {
     if (context.setAgentWorking) {
         context.setAgentWorking(true, 'Running Loadmill flow...');
     }
+    const runtimeCredentials = context.runtimeCredentials || resolveRuntimeCredentialsFromEnv();
+    const loadmillClient = context.loadmillClient || createLoadmillApiClient({
+        token: runtimeCredentials.loadmillApiToken,
+        baseUrl: runtimeCredentials.loadmillBaseUrl,
+    });
+    const openAiClient = context.openAiClient || createOpenAiClient(runtimeCredentials.openAiApiKey);
     // Execute the command
     const result = await executeLoadmillCommand(command, {
+        loadmillClient,
+        openAiClient,
         onProgress: ({ message }) => {
             addOutput({ type: 'info', text: `[Loadmill] ${message}` });
         }

package/build/src/commands/run.js

@@ -4,7 +4,7 @@
 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 { resolveExecutionAppContext } from "../core/app-context.js";
 import { logger } from "../utils/logger.js";
 /**
  * Handle /run command
@@ -51,7 +51,6 @@ 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)
@@ -72,34 +71,24 @@ 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.`,
-            });
-        }
+    const appContext = await resolveExecutionAppContext({ contextPath: context.appContextPath });
+    const appContextText = appContext.text;
+    if (appContext.status === 'loaded' && appContext.contextPath) {
+        addOutput({ type: 'info', text: `Loaded app context from: ${appContext.contextPath}` });
+    }
+    else if (appContext.status === 'failed') {
+        logger.error('CLI app context load failed', {
+            contextPath: appContext.contextPath,
+            testName,
+            message: appContext.message,
+        });
+        addOutput({
+            type: 'warning',
+            text: `Warning: could not load app context from ${appContext.contextPath}. Running without it.`,
+        });
     }
     // Set execution mode system prompt (replaces any design mode prompt)
-    const executionPrompt = buildExecutionModePrompt(session.deviceInfo, {}, appContextBriefing, { strictMode: Boolean(context.engine?.strictMode) });
+    const executionPrompt = buildExecutionModePrompt(session.deviceInfo, {}, appContextText, { 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

@@ -1,24 +1,7 @@
 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);
 }
@@ -35,23 +18,64 @@ export async function appContextFileExists(filePath) {
         return false;
     }
 }
-export async function buildAppContextBriefing({ contextPath, taskText, budget = DEFAULT_APP_CONTEXT_BUDGET, }) {
+/**
+ * @param {{ contextPath?: string | null }} [options]
+ */
+export async function loadAppContext({ contextPath }) {
+    if (!contextPath) {
+        return { text: "", contextPath: null };
+    }
+    const text = await readAppContextFile(contextPath);
+    return { text, contextPath };
+}
+/**
+ * @param {{
+ *   enabled?: boolean,
+ *   contextPath?: string | null,
+ *   missingStatus?: string,
+ *   missingFileStatus?: string | null,
+ * }} [options]
+ */
+export async function resolveExecutionAppContext({ enabled = true, contextPath = null, missingStatus = "missing", missingFileStatus = null, } = {}) {
+    if (!enabled) {
+        return {
+            status: "disabled",
+            text: "",
+            contextPath: null,
+            message: null,
+        };
+    }
     if (!contextPath) {
-        return { briefing: "", contextPath: null };
+        return {
+            status: missingStatus,
+            text: "",
+            contextPath: null,
+            message: null,
+        };
+    }
+    try {
+        const result = await loadAppContext({ contextPath });
+        return {
+            status: result.text.trim().length > 0 ? "loaded" : "empty",
+            text: result.text,
+            contextPath: result.contextPath,
+            message: null,
+        };
     }
-    const normalizedBudget = normalizeAppContextBudget(budget);
-    if (normalizedBudget === 0) {
-        return { briefing: "", contextPath };
+    catch (error) {
+        if (missingFileStatus && error && typeof error === "object" && error.code === "ENOENT") {
+            return {
+                status: missingFileStatus,
+                text: "",
+                contextPath,
+                message: null,
+            };
+        }
+        return {
+            status: "failed",
+            text: "",
+            contextPath,
+            message: error instanceof Error ? error.message : "Unknown app context error",
+        };
     }
-    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/context-optimization.js

@@ -1,5 +1,5 @@
 export const DEFAULT_CONTEXT_OPTIMIZATION_ENABLED = true;
-export const DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD = 30000;
+export const DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD = 20000;
 export const MIN_CONTEXT_OPTIMIZATION_THRESHOLD = 10000;
 export const MAX_CONTEXT_OPTIMIZATION_THRESHOLD = 900000;
 export const CONTEXT_OPTIMIZATION_ENABLED_ENV = "DROID_CUA_CONTEXT_OPTIMIZATION_ENABLED";

package/build/src/core/cua-models.js

@@ -0,0 +1,9 @@
+export const CUA_MODELS = ["gpt-5.4", "gpt-5.4-mini"];
+export const DEFAULT_CUA_MODEL = "gpt-5.4";
+const VALID_CUA_MODELS = new Set(CUA_MODELS);
+export function isValidCuaModel(value) {
+    return VALID_CUA_MODELS.has(value);
+}
+export function resolveCuaModel(value) {
+    return isValidCuaModel(value) ? value : DEFAULT_CUA_MODEL;
+}