newmark-agent 0.6.3 → 0.6.7

package/dist/server.js

@@ -59,6 +59,17 @@ const workEventCoalescer_1 = require("./core/workEventCoalescer");
 const conversationListEvent_1 = require("./core/conversationListEvent");
 const searchMcpPool_1 = require("./core/searchMcpPool");
 const PORT = 47890;
+/**
+ * Effective listen/advertised port. Production and every existing harness use
+ * `PORT` untouched (the isolated-server gates patch that literal); the
+ * `NEWMARK_MOBILE_PORT` override exists so a second, isolated dev/test instance
+ * can host a paired client without taking the production port away from the
+ * instance the user is already running. It stays in sync with the pairing
+ * URL/QR, which resolves the same override through `MOBILE_PORT`.
+ */
+const HOSTED_PORT = Number(process.env.NEWMARK_MOBILE_PORT) > 0
+    ? Math.trunc(Number(process.env.NEWMARK_MOBILE_PORT))
+    : PORT;
 let agent = null;
 let automation = null;
 let workspaceFileRouter = null;
@@ -104,7 +115,7 @@ function mobileAuthorized(req) {
     if (bearer.startsWith('Bearer '))
         return bearer.slice('Bearer '.length).trim() === mobileToken;
     try {
-        const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+        const url = new URL(req.url || '/', `http://localhost:${HOSTED_PORT}`);
         const queryToken = url.searchParams.get('token') || '';
         return queryToken === mobileToken;
     }
@@ -223,7 +234,7 @@ async function handleMobileWorkspaceUpload(req, res) {
         req.resume();
         return;
     }
-    const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+    const url = new URL(req.url || '/', `http://localhost:${HOSTED_PORT}`);
     const workspaceId = url.searchParams.get('workspaceId') || '';
     const directory = url.searchParams.get('directory') || '';
     const fileName = url.searchParams.get('fileName') || '';
@@ -392,13 +403,17 @@ function mobileScopedAgent(ws, conversationId) {
 }
 function mobileConversationRuntimeBusy(current, ws, conversationId) {
     const scoped = mobileScopedRuntimes.get(mobileRuntimeKey(String(ws.id || ''), conversationId));
-    if (scoped && scoped.agent.status !== 'idle')
+    // Only an in-flight run blocks a mobile mutation. `goal_paused` (a goal the
+    // user paused) and `error` (a terminal failure) are not running work, yet
+    // treating them as busy refused archiving the conversation the user is
+    // actually looking at, which is the common case for a paused goal.
+    if (scoped && scoped.agent.status === 'working')
         return true;
     const currentWs = current.workspace.current;
     return !!currentWs
         && path.resolve(currentWs.path) === path.resolve(ws.path)
         && current.activeConversationId === conversationId
-        && current.status !== 'idle';
+        && current.status === 'working';
 }
 function handleMobileEvents(req, res) {
     if (agent && !agent.config.getBool('remote', 'touch_enabled')) {
@@ -520,11 +535,7 @@ function applyConfigPatch(cfg) {
                 agent.config.set('models', 'fallback_on_unavailable', value === true || value === 'on');
                 break;
             case 'switchTendency':
-                agent.config.set('models', 'auto_switch_preference', value);
-                break;
-            case 'clearLearnedAutoPreferences':
-                if (value === true)
-                    agent.clearLearnedModelPreferences();
+                agent.config.set('models', 'auto_switch_preference', ['conservative', 'balanced', 'aggressive'].includes(String(value)) ? String(value) : 'balanced');
                 break;
             case 'openAIApiMode':
                 agent.config.set('models', 'openai_api_mode', ['chat_stream', 'chat', 'responses'].includes(String(value)) ? value : 'chat_stream');
@@ -594,7 +605,7 @@ function jsonResponse(res, data, code = 200) {
     res.end(body);
 }
 async function handleApi(req, res, body) {
-    const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+    const url = new URL(req.url || '/', `http://localhost:${HOSTED_PORT}`);
     const pathname = url.pathname;
     if (pathname.startsWith('/api/mobile/')) {
         if (agent && !agent.config.getBool('remote', 'touch_enabled')) {
@@ -616,6 +627,7 @@ async function handleApi(req, res, body) {
                 jsonResponse(res, {
                     mode: agent.mode, model: agent.modelSelectionValue(), modelLabel: agent.modelLabel(),
                     resolvedDeployment: agent.activeDeployment(), routeDecision: agent.lastRouteDecision,
+                    jevDecisionModel: agent.jevDecisionModelState(),
                     intelligence: agent.intelligence, status: agent.status, goal: agent.goal,
                     models: agent.allModelNames(), inputMode: agent.inputMode,
                     conversationId: agent.activeConversationId,
@@ -1769,7 +1781,7 @@ function startServer(root, options = {}) {
             res.end();
             return;
         }
-        const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+        const url = new URL(req.url || '/', `http://localhost:${HOSTED_PORT}`);
         if (url.pathname === '/api/mobile/events') {
             handleMobileEvents(req, res);
             return;
@@ -1824,15 +1836,15 @@ function startServer(root, options = {}) {
         if (hostedServer === server)
             hostedServer = null;
     });
-    server.listen(PORT, bindHost, () => {
+    server.listen(HOSTED_PORT, bindHost, () => {
         console.log(`\n  Newmark Agent v1.0 - Server Mode`);
-        console.log(`  Bind: ${bindHost}:${PORT}`);
-        console.log(`  GUI: http://localhost:${PORT}`);
+        console.log(`  Bind: ${bindHost}:${HOSTED_PORT}`);
+        console.log(`  GUI: http://localhost:${HOSTED_PORT}`);
         console.log(`  Tailscale IPv4: ${tailscale || 'not detected'}`);
         console.log(`  LAN IPv4: ${lan || 'not detected'}`);
-        console.log(`  Mobile endpoint: http://${accessHost}:${PORT}/api/mobile/hello?token=<token>`);
+        console.log(`  Mobile endpoint: http://${accessHost}:${HOSTED_PORT}/api/mobile/hello?token=<token>`);
         console.log(`  Mobile token file: ${tokenPath}`);
-        console.log(`  Mobile events (SSE): http://${accessHost}:${PORT}/api/mobile/events?token=<token>`);
+        console.log(`  Mobile events (SSE): http://${accessHost}:${HOSTED_PORT}/api/mobile/events?token=<token>`);
         console.log(`  Press Ctrl+C to stop\n`);
     });
     return server;
@@ -1868,7 +1880,7 @@ async function probeHostedServer(host) {
     return await new Promise(resolve => {
         const request = http.get({
             hostname: host,
-            port: PORT,
+            port: HOSTED_PORT,
             path: `/api/mobile/hello?token=${encodeURIComponent(mobileToken)}`,
             timeout: 1800,
         }, response => {
@@ -1935,7 +1947,7 @@ async function hostedServerStatus(enabled = true, probeHost = '') {
         reachable,
         state,
         host,
-        port: PORT,
+        port: HOSTED_PORT,
         error: state === 'error' ? (error || 'Mobile server is not reachable') : '',
         checkedAt: new Date().toISOString(),
         startedAt: hostedServerStartedAt,

package/dist/tools/computerUse.d.ts

@@ -30,6 +30,8 @@ export interface ComputerUseOptions {
     allowEphemeralVisionImage?: boolean;
     captureMaxWidth?: number;
     captureMaxHeight?: number;
+    sparseWaitMs?: number;
+    signal?: AbortSignal;
     gradientColors?: string[];
     gradientSpeed?: number;
     gradientWidth?: number;
@@ -50,10 +52,12 @@ declare function ephemeralScreenshotPath(kind: 'observe' | 'app', directory?: st
 declare function cleanupStaleScreenshots(options?: ScreenshotCleanupOptions): {
     removed: number;
 };
+declare function sparseMeasurementSampleBudget(waitMs: number): number;
 declare function stringifyComputerUseResult(result: Record<string, unknown>): string;
 export declare const computerUseInternals: {
     cleanupStaleScreenshots: typeof cleanupStaleScreenshots;
     ephemeralScreenshotPath: typeof ephemeralScreenshotPath;
+    sparseMeasurementSampleBudget: typeof sparseMeasurementSampleBudget;
     stringifyComputerUseResult: typeof stringifyComputerUseResult;
 };
 export declare function runComputerUse(options: ComputerUseOptions): Promise<string>;

package/dist/tools/computerUse.js

@@ -68,6 +68,7 @@ const DEFAULT_CAPTURE_MAX_HEIGHT = 960;
 const MIN_CAPTURE_MAX_WIDTH = 320;
 const MIN_CAPTURE_MAX_HEIGHT = 240;
 const MAX_CAPTURE_DIMENSION = 2048;
+const MAX_SPARSE_WAIT_MS = 5000;
 let lastScreenshotCleanupAt = 0;
 function ephemeralScreenshotPath(kind, directory = tempScreenshotDir(), createdAt = Date.now(), ownerPid = process.pid, suffix = crypto.randomBytes(4).toString('hex')) {
     const pid = Math.max(1, Math.floor(Number(ownerPid) || process.pid));
@@ -210,6 +211,172 @@ function jpegCaptureScript(outPath, boundsScript, requestedMaxWidth, requestedMa
         'Write-Output (@{ ok=$true; left=$x; top=$y; width=$w; height=$h; capture_max_width=$maxWidth; capture_max_height=$maxHeight; image_width=$imageWidth; image_height=$imageHeight; image_bytes=$fileSize; image_quality=$qualityUsed; image_available=$imageAvailable; image_mime="image/jpeg" } | ConvertTo-Json -Compress)',
     ].join('\r\n');
 }
+function boundedSparseWait(value) {
+    const requested = Number(value);
+    if (!Number.isFinite(requested) || requested <= 0)
+        return 0;
+    return Math.min(MAX_SPARSE_WAIT_MS, Math.floor(requested));
+}
+function sparseMeasurementSampleBudget(waitMs) {
+    const boundedWait = Math.max(1, Math.floor(Number(waitMs) || 1));
+    // A live PowerShell process handshake does not mean its first GDI capture,
+    // script execution and IPC response are warm. Reserve completion time on
+    // every call so the lane's own wait-elapsed result beats the outer fallback.
+    const completionMarginMs = Math.min(Math.max(0, boundedWait - 1), Math.min(1500, Math.max(500, Math.floor(boundedWait * 0.3))));
+    return Math.max(1, boundedWait - completionMarginMs);
+}
+function sparseMeasurementScript(waitMs) {
+    const boundedWait = Math.min(MAX_SPARSE_WAIT_MS, Math.max(1, Math.floor(waitMs)));
+    return [
+        '$ErrorActionPreference = "Stop"',
+        '$bounds = [System.Windows.Forms.SystemInformation]::VirtualScreen',
+        '$x=[int]$bounds.Left; $y=[int]$bounds.Top; $w=[int]$bounds.Width; $h=[int]$bounds.Height',
+        'if ($w -le 0 -or $h -le 0) { throw "Virtual screen geometry is unavailable." }',
+        '$gridWidth=32; $gridHeight=18; $pollMs=200; $cellThreshold=24; $strongThreshold=64',
+        '$watch = [System.Diagnostics.Stopwatch]::StartNew(); $sampleCount=0; $changedCells=0; $triggered=$false; $geometryChanged=$false',
+        '$thumbnail = [NewmarkSparseCapture]::CaptureScaled($x,$y,$w,$h,$gridWidth,$gridHeight)',
+        '$baseline = [byte[]]::new($gridWidth * $gridHeight)',
+        'try {',
+        '  for ($row=0; $row -lt $gridHeight; $row++) { for ($column=0; $column -lt $gridWidth; $column++) { $index=$row*$gridWidth+$column; $baseline[$index]=$thumbnail.GetLuma($column,$row) } }',
+        '  $sampleCount=1',
+        `  while ($watch.ElapsedMilliseconds -lt ${boundedWait}) {`,
+        `    $remaining=[Math]::Max(1, ${boundedWait} - [int]$watch.ElapsedMilliseconds); Start-Sleep -Milliseconds ([Math]::Min($pollMs,$remaining))`,
+        '    $nextBounds=[System.Windows.Forms.SystemInformation]::VirtualScreen',
+        '    if ($nextBounds.Left -ne $x -or $nextBounds.Top -ne $y -or $nextBounds.Width -ne $w -or $nextBounds.Height -ne $h) { $geometryChanged=$true; break }',
+        '    $nextThumbnail=[NewmarkSparseCapture]::CaptureScaled($x,$y,$w,$h,$gridWidth,$gridHeight); $thumbnail.Dispose(); $thumbnail=$nextThumbnail',
+        '    $changedCells=0; $strongCells=0',
+        '    for ($row=0; $row -lt $gridHeight; $row++) { for ($column=0; $column -lt $gridWidth; $column++) { $index=$row*$gridWidth+$column; $luma=[int]$thumbnail.GetLuma($column,$row); $delta=[Math]::Abs($luma-$baseline[$index]); if ($delta -ge $cellThreshold) { $changedCells++ }; if ($delta -ge $strongThreshold) { $strongCells++ } } }',
+        '    $sampleCount++',
+        '    if ($changedCells -ge 4 -or $strongCells -ge 2) { $triggered=$true; break }',
+        '  }',
+    ].join('\r\n') + [
+        '} finally { $watch.Stop(); $thumbnail.Dispose() }',
+        '$reason = if ($geometryChanged) { "screen_geometry_changed" } elseif ($triggered) { "coarse_change" } else { "wait_elapsed" }',
+        'Write-Output (@{ ok=$true; triggered=$triggered; geometry_changed=$geometryChanged; sample_count=$sampleCount; changed_cells=$changedCells; elapsed_ms=[int]$watch.ElapsedMilliseconds; reason=$reason } | ConvertTo-Json -Compress)',
+    ].join('\r\n');
+}
+function sparseAbortError(signal) {
+    if (signal.reason instanceof Error)
+        return signal.reason;
+    return new Error(signal.reason ? String(signal.reason) : 'Computer Use sparse observation was cancelled.');
+}
+async function waitForSparseChange(waitMs, signal) {
+    if (signal?.aborted)
+        throw sparseAbortError(signal);
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        let phase = 'preparing';
+        const deadlineAt = Date.now() + waitMs;
+        let deadlineTimer;
+        const cleanup = () => {
+            if (deadlineTimer)
+                clearTimeout(deadlineTimer);
+            signal?.removeEventListener('abort', onAbort);
+        };
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            (0, computerUsePowerShellHost_1.stopComputerUsePowerShellLane)('sparse');
+            reject(sparseAbortError(signal));
+        };
+        deadlineTimer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            // A normal wait deadline during helper startup must not kill the shared
+            // lane. Its initialization can finish in the background and serve the
+            // next observation. Once a sample has actually been submitted, however,
+            // stop a worker that failed to return before its bounded sampling window.
+            if (phase === 'sampling')
+                (0, computerUsePowerShellHost_1.stopComputerUsePowerShellLane)('sparse');
+            const error = phase === 'preparing'
+                ? 'Sparse helper did not become ready before the observation deadline; its startup continues for the next observation.'
+                : 'Sparse sample did not return before the observation deadline; continuing with a fresh full observation.';
+            resolve({ ok: false, triggered: false, geometryChanged: false, sampleCount: null, changedCells: null, elapsedMs: waitMs, reason: 'wait_elapsed', error });
+        }, waitMs);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        if (signal?.aborted) {
+            onAbort();
+            return;
+        }
+        const parseResult = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (!result.ok) {
+                resolve({ ok: false, triggered: false, geometryChanged: false, sampleCount: null, changedCells: null, elapsedMs: result.elapsedMs, reason: 'sampling_failed', error: result.output.slice(0, 500) });
+                return;
+            }
+            try {
+                const parsed = JSON.parse(result.output);
+                resolve({
+                    ok: parsed.ok === true,
+                    triggered: parsed.triggered === true,
+                    geometryChanged: parsed.geometry_changed === true,
+                    sampleCount: Math.max(0, Number(parsed.sample_count) || 0),
+                    changedCells: Math.max(0, Number(parsed.changed_cells) || 0),
+                    elapsedMs: Math.max(0, Number(parsed.elapsed_ms) || result.elapsedMs),
+                    reason: String(parsed.reason || 'sampling_failed'),
+                    ...(parsed.ok === true ? {} : { error: 'Sparse measurement returned an invalid result.' }),
+                });
+            }
+            catch {
+                resolve({ ok: false, triggered: false, geometryChanged: false, sampleCount: null, changedCells: null, elapsedMs: result.elapsedMs, reason: 'sampling_failed', error: 'Sparse measurement result was not valid JSON.' });
+            }
+        };
+        const prepareAndSample = async () => {
+            const preparation = await (0, computerUsePowerShellHost_1.prepareComputerUsePowerShellLane)('sparse', waitMs);
+            if (settled)
+                return;
+            if (!preparation.ready) {
+                settled = true;
+                cleanup();
+                resolve({
+                    ok: false,
+                    triggered: false,
+                    geometryChanged: false,
+                    sampleCount: null,
+                    changedCells: null,
+                    elapsedMs: Math.max(preparation.elapsedMs, Date.now() - (deadlineAt - waitMs)),
+                    reason: 'wait_elapsed',
+                    error: 'Sparse helper initialization exceeded the observation deadline; the lane remains available to finish startup.',
+                });
+                return;
+            }
+            const remainingMs = Math.max(0, deadlineAt - Date.now());
+            if (remainingMs < 100) {
+                settled = true;
+                cleanup();
+                resolve({ ok: false, triggered: false, geometryChanged: false, sampleCount: null, changedCells: null, elapsedMs: waitMs, reason: 'wait_elapsed', error: 'Sparse helper became ready without enough time left to capture a bounded sample.' });
+                return;
+            }
+            const sampleBudgetMs = sparseMeasurementSampleBudget(remainingMs);
+            phase = 'sampling';
+            try {
+                const result = await (0, computerUsePowerShellHost_1.runPersistentPowerShell)(sparseMeasurementScript(sampleBudgetMs), remainingMs, 'sparse');
+                parseResult(result);
+            }
+            catch (error) {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve({ ok: false, triggered: false, geometryChanged: false, sampleCount: null, changedCells: null, elapsedMs: Date.now() - (deadlineAt - waitMs), reason: 'sampling_failed', error: error instanceof Error ? error.message.slice(0, 500) : String(error).slice(0, 500) });
+            }
+        };
+        void prepareAndSample().catch(error => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve({ ok: false, triggered: false, geometryChanged: false, sampleCount: null, changedCells: null, elapsedMs: Date.now() - (deadlineAt - waitMs), reason: 'sampling_failed', error: error instanceof Error ? error.message.slice(0, 500) : String(error).slice(0, 500) });
+        });
+    });
+}
 function gradientPalette(_input) {
     return ['#000000', '#ffffff', '#000000', '#ffffff'];
 }
@@ -901,8 +1068,28 @@ function resolveTarget(targetId, workspacePath, ownerId) {
         return { x: 0, y: 0, error: `target_id not found in latest observation: ${id}.` };
     return { x: target.center.x, y: target.center.y, target };
 }
-async function screenshot(workspacePath, ownerId, allowEphemeralVisionImage, includeRawUi = false, captureMaxWidth, captureMaxHeight) {
+async function screenshot(workspacePath, ownerId, allowEphemeralVisionImage, includeRawUi = false, captureMaxWidth, captureMaxHeight, sparseWaitMs, signal) {
     const totalStarted = Date.now();
+    const sparseDurationMs = boundedSparseWait(sparseWaitMs);
+    const sparseStarted = Date.now();
+    const sparse = sparseDurationMs > 0 ? await waitForSparseChange(sparseDurationMs, signal) : undefined;
+    const sparseWallMs = sparse ? Date.now() - sparseStarted : 0;
+    if (signal?.aborted)
+        throw sparseAbortError(signal);
+    const sparseDetails = sparse ? {
+        method: 'coarse-grid-luminance-change-wakeup',
+        grid_width: 32,
+        grid_height: 18,
+        sample_count: sparse.sampleCount,
+        changed_cells: sparse.changedCells,
+        triggered: sparse.triggered,
+        reason: sparse.reason,
+        elapsed_ms: sparse.elapsedMs,
+        wall_elapsed_ms: sparseWallMs,
+        fresh_full_observation_follows: true,
+        interpretation: 'Wake signal only. A timeout or no detected change is not evidence that the screen stayed unchanged; small, brief, or color-only changes can be missed.',
+        ...(sparse.error ? { warning: sparse.error } : {}),
+    } : undefined;
     const outPath = ephemeralScreenshotPath('observe');
     let retainedForVision = false;
     try {
@@ -916,14 +1103,16 @@ async function screenshot(workspacePath, ownerId, allowEphemeralVisionImage, inc
             observeUiAutomation(30000, foreground.handle, 750, 'uia_advisory'),
             observeAppWindows(30000, 750, 'windows_advisory'),
         ]);
+        if (signal?.aborted)
+            throw sparseAbortError(signal);
         if (!result.ok)
-            return captureFailure('observe');
+            return { ...captureFailure('observe'), ...(sparseDetails ? { sparse_measurement: sparseDetails } : {}) };
         let parsed = {};
         try {
             parsed = JSON.parse(result.output);
         }
         catch {
-            return captureFailure('observe');
+            return { ...captureFailure('observe'), ...(sparseDetails ? { sparse_measurement: sparseDetails } : {}) };
         }
         const screenWidth = Number(parsed.width || 1);
         const screenHeight = Number(parsed.height || 1);
@@ -947,6 +1136,7 @@ async function screenshot(workspacePath, ownerId, allowEphemeralVisionImage, inc
                 scene_generation: generation,
                 scene_summary: buildSceneSummary(objects, screenWidth, screenHeight),
                 objects: compactSemanticObjects(objects),
+                ...(sparseDetails ? { sparse_measurement: sparseDetails } : {}),
                 object_usage: 'Prefer target_id from scene_summary.high_priority_objects or objects for click/move/scroll when available; it resolves to the latest observed center coordinate and keeps actions tied to a semantic UI object.',
                 warning: foreground.error || ui.error || apps.error || undefined,
                 note: 'Inspired by capture-parse-decide-act and MCP-style Computer Control agents: screenshot capture plus native Windows UI Automation text/control bounding boxes, semantic target objects, stable target IDs, high-priority object summaries, normalized bboxes, allowed actions, and risk hints. It does not copy third-party code.',
@@ -959,6 +1149,13 @@ async function screenshot(workspacePath, ownerId, allowEphemeralVisionImage, inc
                 total_ms: Date.now() - totalStarted,
                 element_count: ui.elements.length,
                 visited_count: ui.visited,
+                ...(sparse ? {
+                    sparse_sampling_ms: sparse.elapsedMs,
+                    sparse_wall_ms: sparseWallMs,
+                    sparse_configured_wait_ms: sparseDurationMs,
+                    sparse_sample_count: sparse.sampleCount,
+                    sparse_triggered: sparse.triggered,
+                } : {}),
             },
             ...parsed,
         };
@@ -1207,6 +1404,7 @@ function stringifyComputerUseResult(result) {
 exports.computerUseInternals = {
     cleanupStaleScreenshots,
     ephemeralScreenshotPath,
+    sparseMeasurementSampleBudget,
     stringifyComputerUseResult,
 };
 async function runComputerUse(options) {
@@ -1230,7 +1428,7 @@ async function runComputerUse(options) {
         result = { ok: true, action: 'takeover_stop', takeover: false };
     }
     else if (action === 'observe') {
-        result = await screenshot(options.workspacePath, ownerId, !!options.allowEphemeralVisionImage, !!options.includeRawUi, options.captureMaxWidth, options.captureMaxHeight);
+        result = await screenshot(options.workspacePath, ownerId, !!options.allowEphemeralVisionImage, !!options.includeRawUi, options.captureMaxWidth, options.captureMaxHeight, options.sparseWaitMs, options.signal);
     }
     else if (action === 'app_list') {
         const first = await observeAppWindows(Number(options.maxChars || 60000));

package/dist/tools/computerUsePowerShellHost.d.ts

@@ -1,4 +1,4 @@
-type HelperLane = 'action' | 'uia' | 'windows' | 'uia_advisory' | 'windows_advisory';
+type HelperLane = 'action' | 'uia' | 'windows' | 'uia_advisory' | 'windows_advisory' | 'sparse';
 export interface PowerShellResult {
     ok: boolean;
     output: string;
@@ -6,6 +6,11 @@ export interface PowerShellResult {
 }
 export declare function runPersistentPowerShell(script: string, timeoutMs?: number, lane?: HelperLane): Promise<PowerShellResult>;
 export declare function computerUsePowerShellLaneReady(lane: HelperLane): boolean;
+export declare function prepareComputerUsePowerShellLane(lane: HelperLane, timeoutMs: number): Promise<{
+    ready: boolean;
+    elapsedMs: number;
+}>;
+export declare function stopComputerUsePowerShellLane(lane: HelperLane): void;
 export declare function stopComputerUsePowerShellHost(): void;
 export {};
 //# sourceMappingURL=computerUsePowerShellHost.d.ts.map