autokap 1.1.4 → 1.1.5

package/dist/cli-runner.js

@@ -27,6 +27,8 @@ import { callLLM } from './llm-provider.js';
 import { APP_VERSION } from './version.js';
 import { normalizeAllowedOrigins, normalizeHttpOrigin, verifySignedExecutionProgramEnvelope, } from './program-signing.js';
 const MAX_CLIP_CAPTURE_DEVICE_SCALE_FACTOR = 1;
+const FETCH_PROGRAM_MAX_ATTEMPTS = 4;
+const FETCH_PROGRAM_RETRY_DELAYS_MS = [1000, 3000, 5000];
 const HEALER_SYSTEM_PROMPT = 'You repair failed deterministic browser opcodes. Respond only with JSON.';
 // ── Main entry point ────────────────────────────────────────────────
 export async function runCapture(options) {
@@ -184,22 +186,55 @@ export async function runCapture(options) {
 }
 // ── Server communication ────────────────────────────────────────────
 async function fetchProgram(config, presetId, environmentName) {
-    try {
-        const url = new URL(`${config.apiBaseUrl}/api/cli/programs/${presetId}`);
-        if (environmentName) {
-            url.searchParams.set('env', environmentName);
+    const url = new URL(`${config.apiBaseUrl}/api/cli/programs/${presetId}`);
+    if (environmentName) {
+        url.searchParams.set('env', environmentName);
+    }
+    const requestedUrl = url.toString();
+    for (let attempt = 1; attempt <= FETCH_PROGRAM_MAX_ATTEMPTS; attempt += 1) {
+        let response;
+        try {
+            response = await fetch(requestedUrl, {
+                headers: {
+                    'Authorization': `Bearer ${config.apiKey}`,
+                    'Content-Type': 'application/json',
+                    [CLI_VERSION_HEADER]: APP_VERSION,
+                },
+            });
+        }
+        catch (err) {
+            const error = `failed to fetch program: ${err instanceof Error ? err.message : String(err)}`;
+            if (attempt < FETCH_PROGRAM_MAX_ATTEMPTS) {
+                await retryProgramFetch(attempt, error);
+                continue;
+            }
+            return { success: false, error };
         }
-        const response = await fetch(url.toString(), {
-            headers: {
-                'Authorization': `Bearer ${config.apiKey}`,
-                'Content-Type': 'application/json',
-                [CLI_VERSION_HEADER]: APP_VERSION,
-            },
-        });
         if (!response.ok) {
-            return { success: false, error: await formatServerError(response, url.toString()) };
+            const error = await formatServerError(response, requestedUrl);
+            if (shouldRetryProgramFetch(response.status, error) && attempt < FETCH_PROGRAM_MAX_ATTEMPTS) {
+                await retryProgramFetch(attempt, error);
+                continue;
+            }
+            return { success: false, error };
+        }
+        const contentType = response.headers?.get?.('content-type') ?? '';
+        let data;
+        try {
+            if (contentType.includes('text/html')) {
+                const htmlPreview = (await response.text()).replace(/\s+/g, ' ').trim().slice(0, 120);
+                throw new Error(`unexpected HTML response from ${requestedUrl}${htmlPreview ? `: ${htmlPreview}` : ''}`);
+            }
+            data = await response.json();
+        }
+        catch (err) {
+            const error = `failed to fetch program: ${err instanceof Error ? err.message : String(err)}`;
+            if (attempt < FETCH_PROGRAM_MAX_ATTEMPTS) {
+                await retryProgramFetch(attempt, error);
+                continue;
+            }
+            return { success: false, error };
         }
-        const data = await response.json();
         const envelope = verifySignedExecutionProgramEnvelope({
             apiKey: config.apiKey,
             envelope: data,
@@ -210,9 +245,29 @@ async function fetchProgram(config, presetId, environmentName) {
         }
         return { success: true, program: envelope.program, security: envelope.security };
     }
-    catch (err) {
-        return { success: false, error: `failed to fetch program: ${err instanceof Error ? err.message : String(err)}` };
+    return { success: false, error: 'failed to fetch program: retry attempts exhausted' };
+}
+function shouldRetryProgramFetch(status, error) {
+    if ([408, 429, 500, 502, 503, 504].includes(status)) {
+        return true;
     }
+    return status >= 500 && error.includes('unexpected HTML response');
+}
+async function retryProgramFetch(attempt, error) {
+    const delayMs = getProgramFetchRetryDelayMs(attempt);
+    logger.warn(`[capture] Program fetch failed (attempt ${attempt}/${FETCH_PROGRAM_MAX_ATTEMPTS}): ${error}. Retrying in ${delayMs}ms...`);
+    if (delayMs > 0) {
+        await sleep(delayMs);
+    }
+}
+function getProgramFetchRetryDelayMs(attempt) {
+    if (process.env.NODE_ENV === 'test' || process.env.VITEST === 'true') {
+        return 0;
+    }
+    return FETCH_PROGRAM_RETRY_DELAYS_MS[Math.max(0, attempt - 1)] ?? FETCH_PROGRAM_RETRY_DELAYS_MS.at(-1) ?? 0;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function uploadResults(config, program, result) {
     const runId = randomUUID();

package/dist/clip-capture-loop.d.ts

@@ -35,6 +35,10 @@ export interface ClipCaptureLoopOptions {
 export interface ClipCaptureLoopResult {
     framesDir: string;
     frameCount: number;
+    /** Configured capture attempt ceiling. Actual FPS may be lower when CDP is slow. */
+    targetFps: number;
+    /** Minimum idle time yielded after each CDP screenshot. */
+    minRestMs: number;
     /** (frameCount - 1) * 1000 / (lastTs - firstTs); 0 if < 2 frames. */
     measuredFps: number;
     actualDurationMs: number;
@@ -48,11 +52,18 @@ export interface ClipCaptureLoopResult {
      * loop keeps trying, producing bursts and gaps).
      */
     frameOffsetsMs: number[];
+    /** CDP Page.captureScreenshot wall time in milliseconds. */
+    captureTimingMs: {
+        p50: number;
+        p95: number;
+        max: number;
+    };
 }
 export declare class ClipCaptureLoop {
     private readonly page;
     private readonly framesDir;
     private readonly jpegQuality;
+    private readonly targetFps;
     private readonly targetFrameIntervalMs;
     private readonly minRestMs;
     private cdp;
@@ -60,6 +71,7 @@ export declare class ClipCaptureLoop {
     private loopPromise;
     private frames;
     private frameTimestamps;
+    private frameCaptureDurationsMs;
     private startedAt;
     private firstFrameAt;
     private lastFrameAt;

package/dist/clip-capture-loop.js

@@ -18,6 +18,7 @@ export class ClipCaptureLoop {
     page;
     framesDir;
     jpegQuality;
+    targetFps;
     targetFrameIntervalMs;
     minRestMs;
     cdp = null;
@@ -25,6 +26,7 @@ export class ClipCaptureLoop {
     loopPromise = null;
     frames = [];
     frameTimestamps = [];
+    frameCaptureDurationsMs = [];
     startedAt = 0;
     firstFrameAt = 0;
     lastFrameAt = 0;
@@ -33,6 +35,7 @@ export class ClipCaptureLoop {
         this.framesDir = opts.framesDir;
         this.jpegQuality = opts.jpegQuality ?? 80;
         const targetFps = Math.max(1, Math.min(30, opts.targetFps ?? (process.platform === 'linux' ? 8 : 15)));
+        this.targetFps = targetFps;
         this.targetFrameIntervalMs = 1000 / targetFps;
         this.minRestMs = Math.max(0, Math.min(250, opts.minRestMs ?? (process.platform === 'linux' ? 50 : 16)));
     }
@@ -69,16 +72,21 @@ export class ClipCaptureLoop {
         const trimStartMs = this.firstFrameAt > 0 ? Math.max(0, this.firstFrameAt - this.startedAt) : 0;
         // Snapshot offsets (ms from first frame) for VFR encoding downstream.
         const frameOffsetsMs = this.frameTimestamps.map(ts => ts - this.firstFrameAt);
+        const captureTimingMs = summarizeTiming(this.frameCaptureDurationsMs);
         // Release memory — the caller owns framesDir from here on.
         this.frames = [];
         this.frameTimestamps = [];
+        this.frameCaptureDurationsMs = [];
         return {
             framesDir: this.framesDir,
             frameCount,
+            targetFps: this.targetFps,
+            minRestMs: this.minRestMs,
             measuredFps,
             actualDurationMs,
             trimStartMs,
             frameOffsetsMs,
+            captureTimingMs,
         };
     }
     async loop() {
@@ -112,6 +120,7 @@ export class ClipCaptureLoop {
             this.frames.push(data);
             this.frameTimestamps.push(ts);
             const elapsed = performance.now() - frameStartedAt;
+            this.frameCaptureDurationsMs.push(elapsed);
             const restMs = Math.max(this.minRestMs, this.targetFrameIntervalMs - elapsed);
             if (restMs > 0 && this.running) {
                 await new Promise(resolve => setTimeout(resolve, restMs));
@@ -119,4 +128,21 @@ export class ClipCaptureLoop {
         }
     }
 }
+function summarizeTiming(values) {
+    if (values.length === 0)
+        return { p50: 0, p95: 0, max: 0 };
+    const sorted = [...values].sort((a, b) => a - b);
+    return {
+        p50: roundMs(percentile(sorted, 0.5)),
+        p95: roundMs(percentile(sorted, 0.95)),
+        max: roundMs(sorted[sorted.length - 1] ?? 0),
+    };
+}
+function percentile(sorted, ratio) {
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * ratio) - 1));
+    return sorted[index] ?? 0;
+}
+function roundMs(value) {
+    return Math.round(value * 10) / 10;
+}
 //# sourceMappingURL=clip-capture-loop.js.map

package/dist/web-playwright-local.js

@@ -311,7 +311,10 @@ export class WebPlaywrightLocal {
         }
         const result = await this.recording.loop.stop();
         logger.info(`[capture] Clip frame capture: ${result.frameCount} frame(s), ` +
-            `${result.measuredFps.toFixed(1)} fps over ${(result.actualDurationMs / 1000).toFixed(2)}s`);
+            `${result.measuredFps.toFixed(1)} fps over ${(result.actualDurationMs / 1000).toFixed(2)}s ` +
+            `(target ${result.targetFps} fps, rest >= ${result.minRestMs}ms; ` +
+            `CDP frame time p50=${result.captureTimingMs.p50}ms ` +
+            `p95=${result.captureTimingMs.p95}ms max=${result.captureTimingMs.max}ms)`);
         await this.browser.closeContext();
         await assembleMp4FromFrames({
             framesDir: this.recording.framesDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",

package/dist/agent-action-recovery.d.ts

@@ -1,45 +0,0 @@
-/**
- * Action recovery, guard inference, and login detection utilities for the capture agent.
- * Extracted from agent.ts — these are pure functions with no closure dependencies.
- */
-import type { ExecutedAction, ActionType } from './types.js';
-export declare const META_ACTIONS: Set<ActionType>;
-export declare const BOOTSTRAP_ACTIONS: Set<ActionType>;
-export declare const REPLAYABLE_ACTIONS: ReadonlyArray<ActionType>;
-export declare function isNoEffectAction(action: ExecutedAction): boolean;
-export declare function isBootstrapStabilizationAction(action: ExecutedAction): boolean;
-export declare function hasMeaningfulBrowserAction(actionHistory: ExecutedAction[]): boolean;
-export declare function buildRecoveryActionSignature(action: ExecutedAction): string;
-export declare function isExplicitLoginAction(action: ExecutedAction): boolean;
-export declare function hasRecentExplicitLoginAction(previousActions: ExecutedAction[]): boolean;
-export declare function isLoginAction(action: ExecutedAction, previousActions?: ExecutedAction[]): boolean;
-export declare function compactReplayActions(recordedActions: ExecutedAction[], params?: {
-    currentUrl?: string;
-    targetUrl?: string;
-    currentViewport?: {
-        width: number;
-        height: number;
-    } | null;
-    isAuthenticated?: boolean;
-    ignoreRecordedViewport?: boolean;
-}): ExecutedAction[];
-export declare function countRecentNoEffectActions(actionHistory: ExecutedAction[]): number;
-export declare function shouldTriggerRecovery(actionHistory: ExecutedAction[]): boolean;
-export declare function inferPrematureGiveUpCorrection(params: {
-    reason: string;
-    actionHistory: ExecutedAction[];
-    lastVerificationFailure?: string;
-    iteration: number;
-    maxIterations: number;
-}): string | null;
-export declare function inferSearchScrollLoopGuard(params: {
-    actionHistory: ExecutedAction[];
-    action: ActionType;
-    args: Record<string, unknown>;
-}): string | null;
-export declare function inferRepeatedActionGuard(params: {
-    actionHistory: ExecutedAction[];
-    action: ActionType;
-    args: Record<string, unknown>;
-    currentUrl?: string;
-}): string | null;

package/dist/agent-action-recovery.js

@@ -1,370 +0,0 @@
-/**
- * Action recovery, guard inference, and login detection utilities for the capture agent.
- * Extracted from agent.ts — these are pure functions with no closure dependencies.
- */
-import { urlsRoughlyMatch, buildClickGuardSignature, } from './agent-url-utils.js';
-// -- Constants --
-export const META_ACTIONS = new Set(['note', 'begin_subgoal', 'focus', 'capture', 'analyze_screenshot']);
-export const BOOTSTRAP_ACTIONS = new Set(['wait']);
-const REPEAT_GUARD_ACTIONS = new Set([
-    'tap',
-    'press_key',
-]);
-export const REPLAYABLE_ACTIONS = [
-    'navigate_to', 'tap', 'type', 'scroll',
-    'press_key', 'wait',
-];
-const LOGIN_URL_RE = /\b(login|log-in|signin|sign-in|auth|session|connexion|connect)\b/i;
-const LOGIN_FIELD_RE = /\b(password|mot de passe|passcode|otp|verification.?code)\b/i;
-const LOGIN_CLICK_RE = /\b(login|log-in|signin|sign-in|auth|session|connexion|connect|password|mot de passe|passcode|otp|verification.?code|email|e-mail)\b/i;
-const AUTH_SUBMIT_RE = /\b(continue|next|submit|verify|unlock|access|enter|continuer|suivant|soumettre|verifier|v[eé]rifier|acc[eé]der|entrer)\b/i;
-const HARD_GIVE_UP_RE = /\b(5xx|500\b|404\b|page not found|not found|http error|server error|js crash|javascript crash|browser crashed|connection refused|dns|net::|ssl|certificate|blank page|white page|no content|infinite spinner)\b/i;
-const RECOVERABLE_GIVE_UP_RE = /\b(verification|ready_to_capture|dialog|modal|overlay|gallery|editor|route|navigation|assistant|conversation|wrong page|duplicate capture|capture target)\b/i;
-// -- Internal helpers --
-export function isNoEffectAction(action) {
-    return (action.success === false
-        || action.stateChanged === false
-        || action.outcome === 'No visible state change detected after the action.');
-}
-export function isBootstrapStabilizationAction(action) {
-    if (BOOTSTRAP_ACTIONS.has(action.action))
-        return true;
-    return action.action === 'press_key' && String(action.params.key || '').toLowerCase() === 'escape';
-}
-export function hasMeaningfulBrowserAction(actionHistory) {
-    return actionHistory.some((action) => !META_ACTIONS.has(action.action) && !isBootstrapStabilizationAction(action));
-}
-export function buildRecoveryActionSignature(action) {
-    const parts = [action.action];
-    if (typeof action.params.nodeId === 'string' && action.params.nodeId.trim()) {
-        parts.push(`nodeId:${action.params.nodeId.trim()}`);
-    }
-    else if (typeof action.params.selector === 'string' && action.params.selector.trim()) {
-        parts.push(`selector:${action.params.selector.trim()}`);
-    }
-    else if (action.params.index !== undefined) {
-        parts.push(`index:${String(action.params.index)}`);
-    }
-    else if (typeof action.params.url === 'string' && action.params.url.trim()) {
-        parts.push(`url:${action.params.url.trim().slice(0, 160)}`);
-    }
-    else if (action.params.x !== undefined && action.params.y !== undefined) {
-        parts.push(`xy:${String(action.params.x)},${String(action.params.y)}`);
-    }
-    if (typeof action.params.text === 'string' && action.params.text.trim()) {
-        parts.push(`text:${action.params.text.trim().slice(0, 80)}`);
-    }
-    if (typeof action.params.key === 'string' && action.params.key.trim()) {
-        parts.push(`key:${action.params.key.trim()}`);
-    }
-    return parts.join('|');
-}
-function getMeaningfulBrowserActions(actionHistory) {
-    return actionHistory.filter(action => !META_ACTIONS.has(action.action) && !isBootstrapStabilizationAction(action));
-}
-function countDistinctActionSignatures(actionHistory) {
-    return new Set(getMeaningfulBrowserActions(actionHistory).map(action => buildRecoveryActionSignature(action))).size;
-}
-// -- Login detection --
-export function isExplicitLoginAction(action) {
-    if (action.action === 'navigate_to' && typeof action.params.url === 'string' && LOGIN_URL_RE.test(action.params.url)) {
-        return true;
-    }
-    if ((action.action === 'type_text' || action.action === 'type') && typeof action.params.selector === 'string' && LOGIN_FIELD_RE.test(action.params.selector)) {
-        return true;
-    }
-    if ((action.action === 'type_text' || action.action === 'type') && typeof action.params.text === 'string' && /\{\{credential\./i.test(action.params.text)) {
-        return true;
-    }
-    if (action.action === 'click' || action.action === 'tap') {
-        const haystack = [
-            action.params.selector,
-            action.params.elementLabel,
-            action.params.href,
-            action.params.nodeId,
-        ]
-            .filter((value) => typeof value === 'string')
-            .join(' ');
-        if (LOGIN_CLICK_RE.test(haystack)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function hasRecentExplicitLoginAction(previousActions) {
-    return previousActions.slice(-3).some(isExplicitLoginAction);
-}
-export function isLoginAction(action, previousActions = []) {
-    if (isExplicitLoginAction(action)) {
-        return true;
-    }
-    if (action.action === 'click' || action.action === 'tap') {
-        const haystack = [
-            action.params.selector,
-            action.params.elementLabel,
-            action.params.href,
-            action.params.nodeId,
-        ]
-            .filter((value) => typeof value === 'string')
-            .join(' ');
-        if (AUTH_SUBMIT_RE.test(haystack) && hasRecentExplicitLoginAction(previousActions)) {
-            return true;
-        }
-    }
-    if (action.action === 'press_key'
-        && action.params.key === 'Enter'
-        && hasRecentExplicitLoginAction(previousActions)) {
-        return true;
-    }
-    return false;
-}
-export function compactReplayActions(recordedActions, params = {}) {
-    let replayable = recordedActions.filter(a => REPLAYABLE_ACTIONS.includes(a.action));
-    if (params.ignoreRecordedViewport) {
-        replayable = replayable.filter((action) => action.action !== 'resize_viewport');
-    }
-    if (params.isAuthenticated) {
-        const authAwareReplayable = replayable;
-        replayable = authAwareReplayable.filter((action, index) => !isLoginAction(action, authAwareReplayable.slice(0, index)));
-    }
-    let startIndex = 0;
-    while (startIndex < replayable.length) {
-        const action = replayable[startIndex];
-        if (action.action === 'wait') {
-            startIndex += 1;
-            continue;
-        }
-        if (action.action === 'dismiss_overlays') {
-            startIndex += 1;
-            continue;
-        }
-        if (action.action === 'resize_viewport'
-            && params.currentViewport
-            && Number(action.params.width) === params.currentViewport.width
-            && Number(action.params.height) === params.currentViewport.height) {
-            startIndex += 1;
-            continue;
-        }
-        if (action.action === 'navigate_to'
-            && typeof action.params.url === 'string'
-            && (urlsRoughlyMatch(action.params.url, params.currentUrl)
-                || urlsRoughlyMatch(action.params.url, params.targetUrl))) {
-            startIndex += 1;
-            continue;
-        }
-        break;
-    }
-    return replayable.slice(startIndex);
-}
-// -- Recovery --
-export function countRecentNoEffectActions(actionHistory) {
-    let count = 0;
-    for (let index = actionHistory.length - 1; index >= 0; index -= 1) {
-        const action = actionHistory[index];
-        if (META_ACTIONS.has(action.action))
-            continue;
-        if (isNoEffectAction(action)) {
-            count += 1;
-            continue;
-        }
-        break;
-    }
-    return count;
-}
-export function shouldTriggerRecovery(actionHistory) {
-    const browserActions = actionHistory.filter(a => !META_ACTIONS.has(a.action));
-    if (browserActions.length < 2)
-        return false;
-    if (!hasMeaningfulBrowserAction(browserActions))
-        return false;
-    const last = browserActions[browserActions.length - 1];
-    const previous = browserActions[browserActions.length - 2];
-    const sameFailureSignature = !last.success
-        && !previous.success
-        && buildRecoveryActionSignature(last) === buildRecoveryActionSignature(previous)
-        && String(last.error || '').slice(0, 120) === String(previous.error || '').slice(0, 120);
-    if (browserActions.length >= 4) {
-        const [a, b, c, d] = browserActions.slice(-4);
-        const sigA = buildRecoveryActionSignature(a);
-        const sigB = buildRecoveryActionSignature(b);
-        const sigC = buildRecoveryActionSignature(c);
-        const sigD = buildRecoveryActionSignature(d);
-        if ([a, b, c, d].every(isNoEffectAction)
-            && sigA === sigC
-            && sigB === sigD
-            && sigA !== sigB) {
-            return true;
-        }
-    }
-    return sameFailureSignature || countRecentNoEffectActions(actionHistory) >= 2;
-}
-// -- Guard inference --
-export function inferPrematureGiveUpCorrection(params) {
-    const reason = params.reason.trim();
-    const lastVerificationFailure = params.lastVerificationFailure?.trim();
-    if (HARD_GIVE_UP_RE.test(reason) || (lastVerificationFailure && HARD_GIVE_UP_RE.test(lastVerificationFailure))) {
-        return null;
-    }
-    const recentCaptureFailures = params.actionHistory
-        .filter(a => a.action === 'ready_to_capture' && !a.success && a.error)
-        .slice(-6);
-    if (recentCaptureFailures.length >= 3) {
-        const distinctReasons = new Set(recentCaptureFailures.map(a => (a.error || '').replace(/^Verification failed:\s*/i, '').trim().slice(0, 120)));
-        if (distinctReasons.size >= 2 && distinctReasons.size <= 3) {
-            return null;
-        }
-    }
-    if (countRecentNoEffectActions(params.actionHistory) >= 8) {
-        return null;
-    }
-    if (lastVerificationFailure && RECOVERABLE_GIVE_UP_RE.test(lastVerificationFailure)) {
-        return `Do not give up yet. The last verification failure is still recoverable: ${lastVerificationFailure}. Try a materially different navigation or repair step first.`;
-    }
-    const hasTriedSearch = params.actionHistory.some(a => a.action === 'search_text');
-    const hasTriedNavigate = params.actionHistory.some(a => a.action === 'navigate_to');
-    if (!hasTriedSearch && !hasTriedNavigate) {
-        return 'Do not give up yet. You have not tried search_text or navigate_to. Use search_text to find the element by text, or navigate_to to go directly to the target URL.';
-    }
-    const meaningfulActions = getMeaningfulBrowserActions(params.actionHistory);
-    const distinctActionCount = countDistinctActionSignatures(params.actionHistory);
-    const hasTriedEnoughStrategies = meaningfulActions.length >= 4 && distinctActionCount >= 3;
-    const nearingBudget = params.iteration >= Math.max(6, params.maxIterations - 2);
-    if (!hasTriedEnoughStrategies && !nearingBudget) {
-        return 'Do not give up yet. You have not tried enough materially different actions. Change strategy before giving up.';
-    }
-    if (/click.*no effect|no.*effect.*click|clicking.*no/i.test(reason) && !hasTriedNavigate) {
-        return 'Clicking has no effect, but you have not tried navigate_to. Use navigate_to to go directly to the target URL instead of clicking.';
-    }
-    if (RECOVERABLE_GIVE_UP_RE.test(reason) && !nearingBudget) {
-        return 'Do not give up yet. The current issue still looks recoverable. Try a different navigation, search, or repair approach first.';
-    }
-    return null;
-}
-function normalizeSearchLoopQuery(value) {
-    return typeof value === 'string'
-        ? value.trim().toLowerCase().replace(/\s+/g, ' ')
-        : '';
-}
-function getTrailingSearchScrollActions(actionHistory) {
-    const trailing = [];
-    for (let index = actionHistory.length - 1; index >= 0; index -= 1) {
-        const action = actionHistory[index];
-        if (META_ACTIONS.has(action.action))
-            continue;
-        if (action.action !== 'search_text' && action.action !== 'scroll')
-            break;
-        trailing.unshift(action);
-    }
-    return trailing;
-}
-export function inferSearchScrollLoopGuard(params) {
-    if (params.action !== 'search_text' && params.action !== 'scroll')
-        return null;
-    const candidate = {
-        iteration: 0,
-        action: params.action,
-        params: params.args,
-        success: params.action === 'scroll',
-        stateChanged: params.action === 'scroll',
-    };
-    const trailingLoopActions = [...getTrailingSearchScrollActions(params.actionHistory), candidate];
-    if (trailingLoopActions.length < 4)
-        return null;
-    if (!trailingLoopActions.every((action) => action.action === 'search_text' || action.action === 'scroll')) {
-        return null;
-    }
-    const repeatedQueries = new Map();
-    for (const action of trailingLoopActions) {
-        if (action.action !== 'search_text')
-            continue;
-        const query = normalizeSearchLoopQuery(action.params.query);
-        if (!query)
-            continue;
-        repeatedQueries.set(query, (repeatedQueries.get(query) ?? 0) + 1);
-    }
-    const repeatedQueryEntry = Array.from(repeatedQueries.entries())
-        .sort((a, b) => b[1] - a[1])[0];
-    if (!repeatedQueryEntry || repeatedQueryEntry[1] < 2)
-        return null;
-    const [repeatedQuery, repeatedCount] = repeatedQueryEntry;
-    if (params.action === 'search_text') {
-        const candidateQuery = normalizeSearchLoopQuery(params.args.query);
-        if (candidateQuery !== repeatedQuery || repeatedCount < 3)
-            return null;
-        return `BLOCKED: You have already searched for "${repeatedQuery}" repeatedly and only scrolled around without interacting. Stop looping on the same query. Try a different search term, navigate_to the target page, or interact with a concrete result instead.`;
-    }
-    return `BLOCKED: You are stuck in a search_text/scroll loop around "${repeatedQuery}" without acting on a result. Stop scrolling blindly. Try a different query, navigate_to the correct page, or interact with a specific matching control.`;
-}
-export function inferRepeatedActionGuard(params) {
-    if (params.action === 'navigate_to' && typeof params.args.url === 'string' && params.currentUrl) {
-        const targetUrl = params.args.url.replace(/\/$/, '');
-        const recentNavigations = params.actionHistory
-            .filter(a => !META_ACTIONS.has(a.action) && a.success !== false)
-            .slice(-5);
-        if (urlsRoughlyMatch(params.currentUrl, targetUrl)) {
-            return 'WARNING: You are already on this URL. No navigation needed. Focus on interacting with the current page instead.';
-        }
-        const recentAllActions = params.actionHistory
-            .filter(a => !META_ACTIONS.has(a.action))
-            .slice(-4);
-        const hasRecentNoEffect = recentAllActions.some(a => isNoEffectAction(a));
-        if (!hasRecentNoEffect) {
-            const recentUrls = recentNavigations
-                .filter(a => typeof a.params.href === 'string' || typeof a.params.url === 'string')
-                .slice(-3)
-                .map(a => String(a.params.href || a.params.url || '').replace(/\/$/, ''));
-            const wasRecentlyOnTarget = recentUrls.some(url => urlsRoughlyMatch(url, targetUrl));
-            if (wasRecentlyOnTarget && !urlsRoughlyMatch(params.currentUrl, targetUrl)) {
-                return `WARNING: You just navigated away from ${targetUrl} — going back suggests you are confused about the goal. Re-read the <task>/<goal> and <variant_manifest> carefully. If you need a modal, open it from the current page instead of navigating back.`;
-            }
-        }
-    }
-    if (!REPEAT_GUARD_ACTIONS.has(params.action))
-        return null;
-    const recentBrowserActions = params.actionHistory
-        .filter(action => !META_ACTIONS.has(action.action))
-        .slice(-2);
-    if (recentBrowserActions.length < 2)
-        return null;
-    const candidateSignature = buildRecoveryActionSignature({
-        iteration: 0,
-        action: params.action,
-        params: params.args,
-        success: false,
-    });
-    const candidateClickSignature = params.action === 'click'
-        ? buildClickGuardSignature(params.args, params.currentUrl)
-        : null;
-    const repeatedNoEffect = recentBrowserActions.every(action => isNoEffectAction(action)
-        && (candidateClickSignature && action.action === 'click'
-            ? buildClickGuardSignature(action.params, params.currentUrl) === candidateClickSignature
-            : buildRecoveryActionSignature(action) === candidateSignature));
-    if (repeatedNoEffect) {
-        return 'BLOCKED: The previous attempts on this same target had no effect. Try a different control, search_text, scrolling, or a repair step instead of repeating it.';
-    }
-    const recentInteractions = params.actionHistory
-        .filter(action => REPEAT_GUARD_ACTIONS.has(action.action)
-        && !META_ACTIONS.has(action.action)
-        && !(typeof action.error === 'string' && action.error.startsWith('BLOCKED:')))
-        .slice(-4);
-    if (recentInteractions.length >= 4 && recentInteractions.every(a => isNoEffectAction(a))) {
-        return 'BLOCKED: The last 4 interaction actions all failed or had no visible effect. You are stuck. Step back and reconsider: verify the current URL, check if you are on the right page, try navigate_to to reach the correct page, or call give_up if this capture is impossible.';
-    }
-    if (params.action === 'click') {
-        const sig = buildClickGuardSignature(params.args, params.currentUrl);
-        if (sig) {
-            const candidateTarget = String((typeof params.args.elementLabel === 'string' && params.args.elementLabel.trim())
-                ? params.args.elementLabel
-                : params.args.selector ?? params.args.index ?? 'this target');
-            const recentClicks = params.actionHistory
-                .filter(a => a.action === 'click' && !META_ACTIONS.has(a.action))
-                .slice(-6);
-            const sameTargetCount = recentClicks.filter(a => buildClickGuardSignature(a.params, params.currentUrl) === sig).length;
-            if (sameTargetCount >= 3) {
-                return `BLOCKED: You have clicked "${candidateTarget}" ${sameTargetCount} times recently without progress. This is likely a toggle/multi-select control. Press Escape to close any open dropdown, then look for a DIFFERENT button (e.g., an edit/settings icon) to achieve your goal.`;
-            }
-        }
-    }
-    return null;
-}
-//# sourceMappingURL=agent-action-recovery.js.map