@loadmill/droid-cua 2.8.0 → 2.10.0

package/build/src/browser/playwright/welcome-page.js

@@ -0,0 +1,161 @@
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import os from "node:os";
+import { LOADMILL_MARK_PATHS } from "../../brand/loadmill-mark.js";
+const WELCOME_PAGE_DIR = path.join(os.homedir(), ".droid-cua", "browser-assets");
+const WELCOME_PAGE_PATH = path.join(WELCOME_PAGE_DIR, "loadmill-droid-cua-welcome.html");
+const WELCOME_PAGE_URL = pathToFileURL(WELCOME_PAGE_PATH).toString();
+let ensureWelcomePagePromise = null;
+let welcomePageTestHooks = null;
+function renderLogoSvg() {
+    const paths = LOADMILL_MARK_PATHS.map(({ d, fill }) => `<path d="${d}" fill="${fill}" />`).join("");
+    return `<svg viewBox="0 0 1035 1035" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">${paths}</svg>`;
+}
+function buildWelcomePageHtml() {
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Loadmill Droid CUA</title>
+    <style>
+      * { box-sizing: border-box; }
+      html, body { height: 100%; margin: 0; }
+
+      body {
+        font-family: "SF Pro Text", "Inter Tight", "Segoe UI", sans-serif;
+        background: linear-gradient(135deg, #f3f7fd 0%, #d4e2f3 55%, #b8cce8 100%);
+        color: #475569;
+        position: relative;
+        overflow-x: hidden;
+      }
+
+      body::before,
+      body::after {
+        content: "";
+        position: absolute;
+        width: 168px;
+        height: 132px;
+        background-image: radial-gradient(rgba(91, 142, 226, 0.36) 1.4px, transparent 1.6px);
+        background-size: 18px 18px;
+        pointer-events: none;
+      }
+
+      body::before { bottom: 7vh; left: 5vw; }
+      body::after { top: 7vh; right: 5vw; }
+
+      main {
+        position: relative;
+        min-height: 100vh;
+        display: flex;
+        align-items: flex-start;
+        justify-content: center;
+        padding: clamp(10vh, 13vh, 18vh) 32px 32px;
+      }
+
+      .content { width: min(100%, 720px); text-align: center; }
+
+      .brand { margin: 0 auto 32px; }
+      .logo { width: 72px; height: 72px; margin: 0 auto 14px; }
+      .wordmark {
+        font-size: 17px;
+        letter-spacing: 0.32em;
+        font-weight: 600;
+        color: #0f172a;
+        text-indent: 0.32em;
+      }
+
+      h1 {
+        margin: 0;
+        font-size: clamp(40px, 5.2vw, 56px);
+        line-height: 1.05;
+        letter-spacing: -0.035em;
+        color: #0f172a;
+        font-weight: 700;
+      }
+
+      p { margin: 0; }
+
+      .subhead { margin-top: 22px; font-size: 18px; line-height: 1.65; }
+
+      .divider {
+        width: 48px;
+        height: 2px;
+        margin: 28px auto;
+        background: #c7d3e5;
+        border-radius: 999px;
+      }
+
+      .pointer { font-size: 16px; line-height: 1.65; color: #64748b; }
+
+      .tip {
+        margin-top: 36px;
+        font-size: 13px;
+        line-height: 1.5;
+        color: #7c8aa0;
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+      }
+      .tip svg { width: 14px; height: 14px; flex-shrink: 0; opacity: 0.8; }
+
+      @media (max-width: 720px) {
+        main { padding: 10vh 24px 24px; }
+        body::before, body::after { width: 120px; height: 96px; }
+        body::before { bottom: 4vh; left: 4vw; }
+        body::after { top: 4vh; right: 4vw; }
+        .logo { width: 60px; height: 60px; }
+        .wordmark { font-size: 15px; }
+        .subhead { font-size: 16px; }
+        .pointer { font-size: 15px; }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <div class="content">
+        <div class="brand">
+          <div class="logo">${renderLogoSvg()}</div>
+          <div class="wordmark">LOADMILL</div>
+        </div>
+        <h1>Test Browser Ready</h1>
+        <p class="subhead">This is the browser the Loadmill Droid CUA agent will drive when you start a test.</p>
+        <div class="divider" role="presentation"></div>
+        <p class="pointer">Switch back to Loadmill Droid CUA to design or run a test — you should keep this window in the background.</p>
+        <p class="tip">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <circle cx="12" cy="12" r="10"></circle>
+            <line x1="12" y1="16" x2="12" y2="12"></line>
+            <line x1="12" y1="8" x2="12.01" y2="8"></line>
+          </svg>
+          Want to explore manually first? Use the address bar above.
+        </p>
+      </div>
+    </main>
+  </body>
+</html>`;
+}
+export async function getWelcomePageUrl() {
+    if (typeof welcomePageTestHooks?.getWelcomePageUrl === "function") {
+        return await welcomePageTestHooks.getWelcomePageUrl();
+    }
+    if (!ensureWelcomePagePromise) {
+        ensureWelcomePagePromise = (async () => {
+            await mkdir(WELCOME_PAGE_DIR, { recursive: true });
+            await writeFile(WELCOME_PAGE_PATH, buildWelcomePageHtml(), "utf8");
+            return WELCOME_PAGE_URL;
+        })();
+    }
+    return await ensureWelcomePagePromise;
+}
+export function isWelcomePageUrl(url) {
+    if (typeof welcomePageTestHooks?.isWelcomePageUrl === "function") {
+        return welcomePageTestHooks.isWelcomePageUrl(url);
+    }
+    return typeof url === "string" && url === WELCOME_PAGE_URL;
+}
+export function __setWelcomePageTestHooks(hooks = null) {
+    welcomePageTestHooks = hooks;
+    ensureWelcomePagePromise = null;
+}

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

@@ -1,9 +1,8 @@
 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 { AIM_ASSIST_MODES, DEFAULT_AIM_ASSIST_MODE } from "../core/aim-assist.js";
+import { CUA_MODELS, isValidCuaModel, resolveCuaModel } from "../core/cua-models.js";
 function createEmptyPromptCustomizations() {
     return {
         basePromptInstructions: "",
@@ -20,41 +19,19 @@ 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";
+function validateAimAssistMode(value, label) {
+    if (typeof value !== "string" || !AIM_ASSIST_MODES.includes(value)) {
+        throw new Error(`${label} must be one of: ${AIM_ASSIST_MODES.join(", ")}.`);
     }
-    return VALID_CUA_MODELS.has(rawValue) ? rawValue : "gpt-5.4";
-}
-function parseBooleanFlagState(args, key) {
-    return {
-        enabled: args[key] === true,
-        disabled: args[`no-${key}`] === true || args[key] === false,
-    };
+    return value;
 }
-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 readEnvDefaultCuaModel() {
+    return resolveCuaModel(process.env.OPENAI_CUA_MODEL);
 }
 function parseContextOptimizationThreshold(rawValue, label) {
     const numericValue = (() => {
@@ -131,17 +108,19 @@ async function loadConfigFromFile(configPath) {
     const normalized = {
         configPath: absoluteConfigPath,
         cuaModel: undefined,
+        aimAssistMode: undefined,
         promptCustomizations: createEmptyPromptCustomizations(),
         appContextEnabled: undefined,
-        appContextBudget: undefined,
         appContextPath: undefined,
         contextOptimizationEnabled: undefined,
         contextOptimizationThreshold: undefined,
-        strictMode: undefined,
     };
     if ("cuaModel" in rawConfig) {
         normalized.cuaModel = validateCuaModel(rawConfig.cuaModel, "config.cuaModel");
     }
+    if ("aimAssistMode" in rawConfig) {
+        normalized.aimAssistMode = validateAimAssistMode(rawConfig.aimAssistMode, "config.aimAssistMode");
+    }
     if ("promptCustomizations" in rawConfig) {
         normalized.promptCustomizations = normalizePromptCustomizations(rawConfig.promptCustomizations, "config.promptCustomizations");
     }
@@ -151,9 +130,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);
@@ -167,12 +143,7 @@ async function loadConfigFromFile(configPath) {
     if ("contextOptimizationThreshold" in rawConfig) {
         normalized.contextOptimizationThreshold = parseContextOptimizationThreshold(rawConfig.contextOptimizationThreshold, "config.contextOptimizationThreshold");
     }
-    if ("strictMode" in rawConfig) {
-        if (typeof rawConfig.strictMode !== "boolean") {
-            throw new Error("config.strictMode must be a boolean.");
-        }
-        normalized.strictMode = rawConfig.strictMode;
-    }
+    // Legacy strictMode is silently accepted and ignored.
     return normalized;
 }
 export async function resolveHeadlessExecutionConfig(args, options = {}) {
@@ -183,7 +154,6 @@ export async function resolveHeadlessExecutionConfig(args, options = {}) {
     const contextOptimizationEnabledByFlag = args["context-optimization"] === true;
     const noContextOptimization = args["no-context-optimization"] === true || args["context-optimization"] === false;
     const hasContextOptimizationThresholdFlag = args["context-optimization-threshold"] != null;
-    const { enabled: strictEnabledByFlag, disabled: strictDisabledByFlag } = parseBooleanFlagState(args, "strict");
     const basePromptText = typeof args["base-prompt"] === "string" ? args["base-prompt"] : null;
     const executionPromptText = typeof args["execution-prompt"] === "string" ? args["execution-prompt"] : null;
     const basePromptFilePath = typeof args["base-prompt-file"] === "string" ? path.resolve(cwd, args["base-prompt-file"]) : null;
@@ -191,9 +161,6 @@ export async function resolveHeadlessExecutionConfig(args, options = {}) {
     if (explicitContextPath && noContext) {
         throw new Error("--context and --no-context cannot be used together.");
     }
-    if (strictEnabledByFlag && strictDisabledByFlag) {
-        throw new Error("--strict and --no-strict cannot be used together.");
-    }
     if (contextOptimizationEnabledByFlag) {
         throw new Error("--context-optimization is not supported; Context Optimization is enabled by default.");
     }
@@ -208,19 +175,18 @@ export async function resolveHeadlessExecutionConfig(args, options = {}) {
     const resolved = {
         configPath: fileConfig?.configPath || null,
         cuaModel: fileConfig?.cuaModel || readEnvDefaultCuaModel(),
+        aimAssistMode: fileConfig?.aimAssistMode || DEFAULT_AIM_ASSIST_MODE,
         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,
-        strictMode: fileConfig?.strictMode ?? false,
     };
     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 (typeof args["aim-assist"] === "string") {
+        resolved.aimAssistMode = validateAimAssistMode(args["aim-assist"], "--aim-assist");
     }
     if (hasContextOptimizationThresholdFlag) {
         resolved.contextOptimizationEnabled = true;
@@ -249,11 +215,5 @@ export async function resolveHeadlessExecutionConfig(args, options = {}) {
     if (noContextOptimization) {
         resolved.contextOptimizationEnabled = false;
     }
-    if (strictEnabledByFlag) {
-        resolved.strictMode = true;
-    }
-    else if (strictDisabledByFlag) {
-        resolved.strictMode = false;
-    }
     return resolved;
 }

package/build/src/cli/headless-target.js

@@ -30,33 +30,24 @@ function hasNonEmptyString(value) {
 export function resolveHeadlessTarget(args = {}) {
     const target = normalizeTarget(args.target);
     const sessionMode = normalizeSessionMode(args["session-mode"]);
-    const url = hasNonEmptyString(args.url) ? args.url.trim() : null;
     const avdName = hasNonEmptyString(args.avd) ? args.avd.trim() : null;
     const platform = hasNonEmptyString(args.platform) ? args.platform.trim() : null;
     if (target === "web") {
-        if (!url) {
-            throw new Error("--target web requires --url.");
-        }
         if (avdName || platform) {
             throw new Error("--avd and --platform cannot be used with --target web.");
         }
         return {
             target,
-            url,
             sessionMode,
             avdName: null,
             platform: null,
         };
     }
-    if (hasNonEmptyString(args.url)) {
-        throw new Error("--url can only be used with --target web.");
-    }
     if (args["session-mode"] != null) {
         throw new Error("--session-mode can only be used with --target web.");
     }
     return {
         target,
-        url: null,
         sessionMode: null,
         avdName,
         platform,

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

@@ -14,19 +14,18 @@ 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, 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: '  --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' });
     addOutput({ type: 'info', text: '  --no-context-optimization Disable Context Optimization for headless execution' });
@@ -34,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: '' });
@@ -76,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/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);
     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/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;
+}