@loadmill/droid-cua 2.9.0 → 2.10.1-rc.8

package/README.md

@@ -188,8 +188,6 @@ Supported CLI options include:
 - `--execution-prompt`
 - `--base-prompt-file`
 - `--execution-prompt-file`
-- `--strict`
-- `--no-strict`
 - `--record`
 - `--debug`
 

package/build/index.js

@@ -32,11 +32,6 @@ const recordScreenshots = args["record"] || false;
 const instructionsFile = args.instructions || args.i || null;
 const appContextPath = typeof args.context === "string" ? args.context : null;
 const debugMode = args["debug"] || false;
-const strictFlag = args.strict === true;
-const noStrictFlag = args["no-strict"] === true || args.strict === false;
-if (strictFlag && noStrictFlag) {
-    throw new Error("--strict and --no-strict cannot be used together.");
-}
 const screenshotDir = path.join("droid-cua-recording-" + Date.now());
 if (recordScreenshots)
     await mkdir(screenshotDir, { recursive: true });
@@ -87,7 +82,6 @@ async function main() {
     let deviceInfo;
     if (isBrowserTarget) {
         targetId = await connectToBrowser({
-            url: targetConfig.url,
             headless: true,
             sessionMode: targetConfig.sessionMode
         });
@@ -115,10 +109,12 @@ async function main() {
         let instructions = [];
         let executionMode = null;
         try {
+            const headlessConfig = await resolveHeadlessExecutionConfig(args);
             await headlessDebug.startExecutionSession(runId, {
                 testName,
                 platform: deviceInfo.platform,
-                deviceName: deviceInfo.device_name
+                deviceName: deviceInfo.device_name,
+                aimAssistMode: headlessConfig.aimAssistMode
             });
             const currentLogFilePath = await headlessDebug.getCurrentLogFilePath();
             if (currentLogFilePath) {
@@ -126,7 +122,6 @@ async function main() {
             }
             console.log(`\nRunning test from: ${instructionsFile}\n`);
             instructions = await loadHeadlessInstructions(instructionsFile);
-            const headlessConfig = await resolveHeadlessExecutionConfig(args);
             const appContext = await resolveExecutionAppContext({
                 enabled: headlessConfig.appContextEnabled,
                 contextPath: headlessConfig.appContextPath,
@@ -134,7 +129,6 @@ async function main() {
             const appContextText = appContext.text;
             const runtimeContext = createCliRuntimeContext({
                 cuaModel: headlessConfig.cuaModel,
-                strictMode: headlessConfig.strictMode,
                 promptCustomizations: headlessConfig.promptCustomizations,
                 contextOptimizationEnabled: headlessConfig.contextOptimizationEnabled,
                 contextOptimizationThreshold: headlessConfig.contextOptimizationThreshold,
@@ -174,29 +168,44 @@ async function main() {
                     status: appContext.status
                 });
             }
-            const executionPrompt = buildExecutionModePrompt(deviceInfo, headlessConfig.promptCustomizations, appContextText, { strictMode: headlessConfig.strictMode });
+            const executionPrompt = buildExecutionModePrompt(deviceInfo, headlessConfig.promptCustomizations, appContextText, { aimAssistMode: headlessConfig.aimAssistMode });
             session.setSystemPrompt(executionPrompt);
             const screenshotRecorder = headlessDebug.createExecutionScreenshotRecorder({
                 runId,
                 recordScreenshots,
                 screenshotDir
             });
+            const executionEngineOptions = {
+                toolCapabilities: {
+                    assert: true,
+                    navigate: isBrowserTarget,
+                    loadmill: true,
+                },
+                baseSystemPrompt: executionPrompt,
+                isHeadlessMode: true,
+            };
             const engineOptions = screenshotRecorder
                 ? {
                     recordScreenshots: true,
                     screenshotRecorder,
-                    strictMode: runtimeContext.config.strictMode,
                     stepDelayMs: runtimeContext.config.stepDelayMs,
-                    sendCUARequest: runtimeContext.openAi.sendCUARequest,
+                    sendCUARequest: (requestArgs) => runtimeContext.openAi.sendCUARequest({
+                        ...requestArgs,
+                        aimAssistMode: headlessConfig.aimAssistMode,
+                    }),
                     reviseTestScript: runtimeContext.openAi.reviseTestScript,
+                    ...executionEngineOptions,
                 }
                 : {
                     recordScreenshots,
                     screenshotDir,
-                    strictMode: runtimeContext.config.strictMode,
                     stepDelayMs: runtimeContext.config.stepDelayMs,
-                    sendCUARequest: runtimeContext.openAi.sendCUARequest,
+                    sendCUARequest: (requestArgs) => runtimeContext.openAi.sendCUARequest({
+                        ...requestArgs,
+                        aimAssistMode: headlessConfig.aimAssistMode,
+                    }),
                     reviseTestScript: runtimeContext.openAi.reviseTestScript,
+                    ...executionEngineOptions,
                 };
             if (isBrowserTarget) {
                 engineOptions.getScreenshotAsBase64 = (browserSessionId, browserInfo) => getBrowserScreenshotAsBase64(browserSessionId, browserInfo);
@@ -255,13 +264,10 @@ async function main() {
             throw error;
         }
     }
-    const runtimeContext = createCliRuntimeContext({
-        strictMode: strictFlag,
-    });
+    const runtimeContext = createCliRuntimeContext();
     const engine = new ExecutionEngine(session, {
         recordScreenshots,
         screenshotDir,
-        strictMode: runtimeContext.config.strictMode,
         stepDelayMs: runtimeContext.config.stepDelayMs,
         sendCUARequest: runtimeContext.openAi.sendCUARequest,
         reviseTestScript: runtimeContext.openAi.reviseTestScript,

package/build/src/brand/loadmill-mark.js

@@ -0,0 +1,20 @@
+export const LOADMILL_MARK_PATHS = [
+    {
+        d: `M808.982 297.016 644.14 29.3c-1.484-2.012-5.587-8.153-11.234-8.488-7.747-.46-9.872 3.935-11.428
+7.151l-.029.06-111.354 457.775c-1.141 5.191.769 9.126 4.5 12.835 3.731 3.709 10.086 1.879
+12.796.5l275.123-180.566c2.845-1.478 8.763-5.472 9.675-9.625.912-4.153-1.758-9.681-3.207-11.926ZM221.403
+695.361l265.91-167.74c2.219-1.152 8.607-4.858 13.825-2.672 7.156 3 7.129 7.881 7.109 11.453v.067L406.583
+996.493c-1.262 5.167-4.71 7.857-9.694 9.537-4.983 1.69-9.882-2.75-11.708-5.18L217.718 717.557c-1.903-2.58-5.457-8.772-4.447-12.902
+1.01-4.131 5.843-7.917 8.132-9.294Z`,
+        fill: "#52BAD3"
+    },
+    {
+        d: `M282.079 171.043 8.876 355.76c-1.948 1.568-7.91 5.926-8.008 11.582-.133 7.758 4.346 9.697 7.625
+11.116l.062.027 452.431 99.593c5.234.922 9.086-1.152 12.634-5.036 3.549-3.884 1.453-10.156-.039-12.806L303.882
+176.598c-1.596-2.78-5.835-8.525-10.023-9.261-4.188-.737-9.598 2.163-11.78 3.706ZM769.31 811.501
+554.939 562.32c-1.503-1.998-6.214-7.686-4.919-13.193 1.775-7.554 6.594-8.334 10.12-8.904l.066-.011
+462.134 22.113c5.3.392 8.52 3.347 11.01 7.984 2.49 4.636-1.08 10.201-3.18 12.405L791.81 811.468c-2.23
+2.303-7.75 6.832-11.99 6.518-4.241-.314-8.774-4.454-10.51-6.485Z`,
+        fill: "#5691E2"
+    }
+];

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

@@ -6,8 +6,10 @@ import { emitDesktopDebug } from "../../utils/desktop-debug.js";
 import { requireInstalledBrowser } from "./installed-browser.js";
 import { clearActiveBrowserSession, getActiveBrowserSession, setActiveBrowserSession } from "./session-state.js";
 import { normalizeAutomationUrl, normalizeOptionalAutomationUrl } from "./url.js";
+import { getWelcomePageUrl, isWelcomePageUrl } from "./welcome-page.js";
 const DEFAULT_VIEWPORT = { width: 1440, height: 900 };
 let browserConnectionTestHooks = null;
+let pendingBrowserSessionShutdown = null;
 async function gotoWithTimeoutTolerance(page, url) {
     try {
         await page.goto(url, { waitUntil: "load" });
@@ -20,7 +22,7 @@ async function gotoWithTimeoutTolerance(page, url) {
     }
 }
 function normalizeKnownPageUrl(url) {
-    if (typeof url !== "string" || url.trim().length === 0 || url.trim() === "about:blank") {
+    if (typeof url !== "string" || url.trim().length === 0 || url.trim() === "about:blank" || isWelcomePageUrl(url.trim())) {
         return null;
     }
     try {
@@ -30,6 +32,125 @@ function normalizeKnownPageUrl(url) {
         return null;
     }
 }
+async function closeExtraPages(context, primaryPage) {
+    for (const page of context.pages()) {
+        if (page === primaryPage) {
+            continue;
+        }
+        try {
+            await page.close();
+        }
+        catch {
+            // Best-effort cleanup for restored tabs.
+        }
+    }
+}
+async function cleanupClosedSession(session) {
+    if (!session.cleanupOnDisconnect) {
+        return;
+    }
+    try {
+        await rm(session.userDataDir, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort cleanup when the browser disappears outside normal disconnect flow.
+    }
+}
+function isBenignCloseError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const message = `${error.name} ${error.message}`.toLowerCase();
+    return (message.includes("target page, context or browser has been closed") ||
+        message.includes("browser has been closed") ||
+        message.includes("context closed") ||
+        message.includes("target closed") ||
+        message.includes("session closed") ||
+        message.includes("closed") ||
+        message.includes("disconnected"));
+}
+function isCurrentSession(session) {
+    try {
+        return getActiveBrowserSession().sessionId === session.sessionId;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForPendingBrowserSessionShutdown() {
+    if (!pendingBrowserSessionShutdown) {
+        return;
+    }
+    try {
+        await pendingBrowserSessionShutdown;
+    }
+    catch {
+        // Ignore teardown failures here. A follow-up launch attempt can surface the next actionable error.
+    }
+}
+async function closeBrowserSession(session, options = {}) {
+    if (session.shutdownPromise) {
+        return await session.shutdownPromise;
+    }
+    const { externalReason = null, clearActive = true } = options;
+    session.disconnecting = true;
+    const shutdownPromise = (async () => {
+        try {
+            await session.context.close();
+        }
+        catch (error) {
+            if (!isBenignCloseError(error)) {
+                throw error;
+            }
+        }
+        finally {
+            if (clearActive && isCurrentSession(session)) {
+                clearActiveBrowserSession();
+            }
+            await cleanupClosedSession(session);
+        }
+        if (externalReason && !session.externalDisconnectNotified && typeof session.onDisconnected === "function") {
+            session.externalDisconnectNotified = true;
+            await session.onDisconnected({
+                sessionId: session.sessionId,
+                browserName: session.installedBrowser?.browserName || "Browser",
+                browserFamily: session.installedBrowser?.browserFamily || null,
+                reason: externalReason,
+            });
+        }
+    })();
+    session.shutdownPromise = shutdownPromise;
+    pendingBrowserSessionShutdown = shutdownPromise.finally(() => {
+        if (pendingBrowserSessionShutdown === session.shutdownPromise) {
+            pendingBrowserSessionShutdown = null;
+        }
+    });
+    return await session.shutdownPromise;
+}
+function handleExternalSessionClosed(session, reason) {
+    if (session.disconnecting) {
+        return;
+    }
+    void closeBrowserSession(session, {
+        externalReason: reason,
+        clearActive: true,
+    });
+}
+async function launchPersistentContextWithRetry(chromium, userDataDir, launchOptions, sessionMode) {
+    try {
+        return await chromium.launchPersistentContext(userDataDir, launchOptions);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const isProfileLockError = sessionMode === "persistent" && message.includes("ProcessSingleton");
+        if (!isProfileLockError) {
+            throw error;
+        }
+        await waitForPendingBrowserSessionShutdown();
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        return await chromium.launchPersistentContext(userDataDir, launchOptions);
+    }
+}
 function buildSessionBrowserInfo(url, installedBrowser) {
     const currentUrl = normalizeKnownPageUrl(url);
     const browserInfo = {
@@ -63,6 +184,7 @@ function normalizeConnectOptions(targetOrOptions) {
         url: normalizeOptionalAutomationUrl(options.url),
         headless: options.headless === true,
         sessionMode: options.sessionMode === "persistent" ? "persistent" : "fresh",
+        onDisconnected: typeof options.onDisconnected === "function" ? options.onDisconnected : null,
         persistentProfileDir: typeof options.persistentProfileDir === "string" && options.persistentProfileDir.trim().length > 0
             ? path.resolve(options.persistentProfileDir)
             : null,
@@ -115,6 +237,7 @@ export async function connectToBrowser(targetOrOptions) {
     const options = normalizeConnectOptions(targetOrOptions);
     const installedBrowser = await resolveInstalledBrowserForLaunch();
     const chromium = await loadChromium();
+    await waitForPendingBrowserSessionShutdown();
     try {
         getActiveBrowserSession();
         await disconnect();
@@ -123,16 +246,20 @@ export async function connectToBrowser(targetOrOptions) {
         // no active session to close
     }
     const { userDataDir, cleanupOnDisconnect } = await buildUserDataDir(options);
-    const context = await chromium.launchPersistentContext(userDataDir, {
+    const launchOptions = {
         executablePath: installedBrowser.executablePath,
         headless: options.headless,
         viewport: DEFAULT_VIEWPORT,
         screen: DEFAULT_VIEWPORT,
         acceptDownloads: false,
-    });
+    };
+    const context = await launchPersistentContextWithRetry(chromium, userDataDir, launchOptions, options.sessionMode);
     const primaryPage = context.pages()[0] ?? (await context.newPage());
     const sessionId = `browser-${randomUUID()}`;
     const normalizedUrl = options.url;
+    const welcomePageUrl = await getWelcomePageUrl();
+    const initialUrl = normalizedUrl || welcomePageUrl;
+    await closeExtraPages(context, primaryPage);
     context.on("page", (page) => {
         if (page === primaryPage) {
             return;
@@ -143,18 +270,28 @@ export async function connectToBrowser(targetOrOptions) {
             url: page.url() || null,
         });
     });
-    if (normalizedUrl) {
-        await gotoWithTimeoutTolerance(primaryPage, normalizedUrl);
-    }
-    setActiveBrowserSession({
+    await gotoWithTimeoutTolerance(primaryPage, initialUrl);
+    const session = {
         sessionId,
         context,
         page: primaryPage,
         url: normalizedUrl,
+        welcomePageUrl,
         sessionMode: options.sessionMode,
         userDataDir,
         cleanupOnDisconnect,
         installedBrowser,
+        onDisconnected: options.onDisconnected,
+        disconnecting: false,
+        externalDisconnectNotified: false,
+        shutdownPromise: null,
+    };
+    setActiveBrowserSession(session);
+    primaryPage.on?.("close", () => {
+        handleExternalSessionClosed(session, "page_closed");
+    });
+    context.on?.("close", () => {
+        handleExternalSessionClosed(session, "context_closed");
     });
     emitDesktopDebug("browser.connect", "device", {}, {
         platform: "browser",
@@ -194,13 +331,13 @@ export async function disconnect() {
         session = getActiveBrowserSession();
     }
     catch {
+        await waitForPendingBrowserSessionShutdown();
         return;
     }
     clearActiveBrowserSession();
-    await session.context.close();
-    if (session.cleanupOnDisconnect) {
-        await rm(session.userDataDir, { recursive: true, force: true });
-    }
+    await closeBrowserSession(session, {
+        clearActive: false,
+    });
 }
 export function __setBrowserConnectionTestHooks(hooks = null) {
     browserConnectionTestHooks = hooks;

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,6 +1,7 @@
 import path from "path";
 import { readFile } from "fs/promises";
 import { DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, MAX_CONTEXT_OPTIMIZATION_THRESHOLD, MIN_CONTEXT_OPTIMIZATION_THRESHOLD, } from "../core/context-optimization.js";
+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 {
@@ -23,15 +24,15 @@ function validateCuaModel(value, label) {
     }
     return value;
 }
+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 value;
+}
 function readEnvDefaultCuaModel() {
     return resolveCuaModel(process.env.OPENAI_CUA_MODEL);
 }
-function parseBooleanFlagState(args, key) {
-    return {
-        enabled: args[key] === true,
-        disabled: args[`no-${key}`] === true || args[key] === false,
-    };
-}
 function parseContextOptimizationThreshold(rawValue, label) {
     const numericValue = (() => {
         if (typeof rawValue === "number") {
@@ -107,16 +108,19 @@ async function loadConfigFromFile(configPath) {
     const normalized = {
         configPath: absoluteConfigPath,
         cuaModel: undefined,
+        aimAssistMode: undefined,
         promptCustomizations: createEmptyPromptCustomizations(),
         appContextEnabled: 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");
     }
@@ -139,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 = {}) {
@@ -155,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;
@@ -163,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.");
     }
@@ -180,16 +175,19 @@ 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,
         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 (typeof args["aim-assist"] === "string") {
+        resolved.aimAssistMode = validateAimAssistMode(args["aim-assist"], "--aim-assist");
+    }
     if (hasContextOptimizationThresholdFlag) {
         resolved.contextOptimizationEnabled = true;
         resolved.contextOptimizationThreshold = parseContextOptimizationThreshold(args["context-optimization-threshold"], "--context-optimization-threshold");
@@ -217,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;
 }