@mercuryo-ai/agentbrowse 0.2.60 → 0.2.61

package/dist/commands/act.js

@@ -21,8 +21,10 @@ import { isLocatorUserActionable } from './user-actionable.js';
 import { resolveSurfaceScopeRoot } from './target-resolution.js';
 import { buildProtectedArtifactsSuppressed } from '../secrets/protected-artifact-guard.js';
 import { scrubProtectedExactValues } from '../secrets/protected-exact-value-redaction.js';
-import { connectPlaywright, disconnectPlaywright, listPages, resolvePageByRef, syncSessionPage, } from '../playwright-runtime.js';
+import { listPages, resolvePageByRef, syncSessionPage } from '../playwright-runtime.js';
 import { withApiTraceContext } from '../command-api-tracing.js';
+import { describeBrowserConnectionFailure } from './browser-connection-failure.js';
+import { withStickyOwnerBrowser } from '../sticky-owner.js';
 function ensureValue(action, value) {
     if (action === 'click')
         return undefined;
@@ -504,7 +506,6 @@ export async function actBrowser(session, targetRef, action, value) {
             attempts.push(`action.alias:${requestedAction}->${action}`);
         }
         const startedAt = Date.now();
-        let browser = null;
         let failureMessage = null;
         let failureArtifacts;
         let currentPage = null;
@@ -525,580 +526,583 @@ export async function actBrowser(session, targetRef, action, value) {
             finishFailure: async (_artifactDir) => undefined,
         };
         try {
-            browser = await connectPlaywright(session.cdpUrl);
-        }
-        catch (err) {
-            return buildActPreflightFailureResult({
-                session,
-                step: actStep,
-                error: 'browser_connection_failed',
-                outcomeType: 'blocked',
-                message: 'The action could not start because AgentBrowse failed to connect to the browser.',
-                reason: err instanceof Error ? err.message : String(err),
-                targetRef,
-                action,
-            });
-        }
-        try {
-            const page = await resolvePageByRef(browser, session, target.pageRef);
-            currentPage = page;
-            setCurrentPage(session, target.pageRef);
-            const { url } = await syncSessionPage(session, target.pageRef, page);
-            trace = await startActionTrace(page, {
-                suppressSensitiveArtifacts: Boolean(protectedExposureAtStart),
-            });
-            if (liveTarget.pageSignature && normalizePageSignature(url) !== liveTarget.pageSignature) {
-                staleReason = 'page-signature-mismatch';
-                throw new Error('stale_target_page_signature_changed');
-            }
-            const tryRebindMutableFieldTarget = async (resolvedLocator, strategy) => {
-                if (!liveTarget.domSignature) {
-                    return false;
-                }
-                for (let attemptIndex = 0; attemptIndex < MUTABLE_FIELD_REBIND_RETRY_DELAYS_MS.length; attemptIndex += 1) {
-                    const delayMs = MUTABLE_FIELD_REBIND_RETRY_DELAYS_MS[attemptIndex] ?? 0;
-                    if (attemptIndex > 0) {
-                        attempts.push(`domSignature.rebind.retry:${strategy}:${attemptIndex + 1}`);
-                        await new Promise((resolve) => setTimeout(resolve, delayMs));
-                    }
-                    const snapshot = await readLocatorBindingSnapshot(resolvedLocator).catch(() => null);
-                    if (!snapshot?.domSignature) {
-                        continue;
+            return await withStickyOwnerBrowser(session, async (browser) => {
+                try {
+                    const page = await resolvePageByRef(browser, session, target.pageRef);
+                    currentPage = page;
+                    setCurrentPage(session, target.pageRef);
+                    const { url } = await syncSessionPage(session, target.pageRef, page);
+                    trace = await startActionTrace(page, {
+                        suppressSensitiveArtifacts: Boolean(protectedExposureAtStart),
+                    });
+                    if (liveTarget.pageSignature &&
+                        normalizePageSignature(url) !== liveTarget.pageSignature) {
+                        staleReason = 'page-signature-mismatch';
+                        throw new Error('stale_target_page_signature_changed');
                     }
-                    if (snapshot.domSignature === liveTarget.domSignature) {
+                    const tryRebindMutableFieldTarget = async (resolvedLocator, strategy) => {
+                        if (!liveTarget.domSignature) {
+                            return false;
+                        }
+                        for (let attemptIndex = 0; attemptIndex < MUTABLE_FIELD_REBIND_RETRY_DELAYS_MS.length; attemptIndex += 1) {
+                            const delayMs = MUTABLE_FIELD_REBIND_RETRY_DELAYS_MS[attemptIndex] ?? 0;
+                            if (attemptIndex > 0) {
+                                attempts.push(`domSignature.rebind.retry:${strategy}:${attemptIndex + 1}`);
+                                await new Promise((resolve) => setTimeout(resolve, delayMs));
+                            }
+                            const snapshot = await readLocatorBindingSnapshot(resolvedLocator).catch(() => null);
+                            if (!snapshot?.domSignature) {
+                                continue;
+                            }
+                            if (snapshot.domSignature === liveTarget.domSignature) {
+                                return false;
+                            }
+                            if (!isCompatibleMutableFieldBinding(liveTarget, snapshot)) {
+                                continue;
+                            }
+                            attempts.push(`domSignature.rebound:${strategy}`);
+                            const updatedTarget = updateTarget(session, targetRef, {
+                                domSignature: snapshot.domSignature,
+                                label: snapshot.label ?? liveTarget.label,
+                                lifecycle: 'live',
+                                lifecycleReason: undefined,
+                                availability: { state: 'available' },
+                                semantics: {
+                                    ...liveTarget.semantics,
+                                    name: snapshot.label ?? liveTarget.semantics?.name,
+                                    role: snapshot.role ?? liveTarget.semantics?.role,
+                                },
+                            });
+                            if (updatedTarget) {
+                                liveTarget = updatedTarget;
+                            }
+                            return true;
+                        }
                         return false;
+                    };
+                    const assertResolvedTargetStillValid = async (resolvedLocator, stage) => {
+                        await assertStoredBindingStillValid(page, resolvedLocator, liveTarget, stage, {
+                            onReason: async (reason, staleStage) => {
+                                switch (reason) {
+                                    case 'page_signature_mismatch':
+                                        attempts.push(`stale.page-signature:${staleStage}`);
+                                        staleReason = 'page-signature-mismatch';
+                                        return false;
+                                    case 'locator_resolution_failed':
+                                        attempts.push(`stale.locator:${staleStage}`);
+                                        staleReason = 'locator-resolution-failed';
+                                        return false;
+                                    case 'dom_signature_mismatch': {
+                                        const rebound = await tryRebindMutableFieldTarget(resolvedLocator, staleStage);
+                                        if (rebound) {
+                                            return true;
+                                        }
+                                        attempts.push(`stale.dom-signature:${staleStage}`);
+                                        staleReason = 'dom-signature-mismatch';
+                                        return false;
+                                    }
+                                }
+                            },
+                            errorForReason: (reason) => {
+                                switch (reason) {
+                                    case 'page_signature_mismatch':
+                                        return 'stale_target_page_signature_changed';
+                                    case 'locator_resolution_failed':
+                                        return 'stale_target_locator_resolution_failed';
+                                    case 'dom_signature_mismatch':
+                                        return 'stale_target_dom_signature_changed';
+                                }
+                            },
+                        });
+                    };
+                    let resolvedBy = null;
+                    const beforePages = listPages(browser);
+                    const shouldCheckProgress = shouldVerifyObservableProgress(target, action);
+                    const beforePageObservation = shouldCheckProgress
+                        ? await capturePageObservation(page)
+                        : null;
+                    const deferSurfaceResolution = shouldDeferSurfaceResolutionForEditablePress(target, action);
+                    let baseRoot = page;
+                    let locatorRoot = baseRoot;
+                    let surfaceRoot = null;
+                    if (!deferSurfaceResolution) {
+                        ({ baseRoot, locatorRoot, surfaceRoot } = await resolveInteractionRoots(page, target, surface, attempts, {
+                            recordSelfTargetReuse: true,
+                        }));
                     }
-                    if (!isCompatibleMutableFieldBinding(liveTarget, snapshot)) {
-                        continue;
-                    }
-                    attempts.push(`domSignature.rebound:${strategy}`);
-                    const updatedTarget = updateTarget(session, targetRef, {
-                        domSignature: snapshot.domSignature,
-                        label: snapshot.label ?? liveTarget.label,
-                        lifecycle: 'live',
-                        lifecycleReason: undefined,
-                        availability: { state: 'available' },
-                        semantics: {
-                            ...liveTarget.semantics,
-                            name: snapshot.label ?? liveTarget.semantics?.name,
-                            role: snapshot.role ?? liveTarget.semantics?.role,
-                        },
-                    });
-                    if (updatedTarget) {
-                        liveTarget = updatedTarget;
-                    }
-                    return true;
-                }
-                return false;
-            };
-            const assertResolvedTargetStillValid = async (resolvedLocator, stage) => {
-                await assertStoredBindingStillValid(page, resolvedLocator, liveTarget, stage, {
-                    onReason: async (reason, staleStage) => {
-                        switch (reason) {
-                            case 'page_signature_mismatch':
-                                attempts.push(`stale.page-signature:${staleStage}`);
-                                staleReason = 'page-signature-mismatch';
+                    let lastError = null;
+                    let sawDomSignatureMismatch = false;
+                    let sawDisabledTarget = false;
+                    let sawReadonlyTarget = false;
+                    const attemptResolvedLocator = async (resolvedLocator, strategy, options) => {
+                        if (!options?.skipDomSignature && liveTarget.domSignature) {
+                            const rebound = await tryRebindMutableFieldTarget(resolvedLocator, strategy);
+                            if (!rebound) {
+                                const liveSignature = await readLocatorDomSignature(resolvedLocator);
+                                if (liveSignature && liveSignature !== liveTarget.domSignature) {
+                                    attempts.push(`domSignature.mismatch:${strategy}`);
+                                    sawDomSignatureMismatch = true;
+                                    return false;
+                                }
+                            }
+                        }
+                        let acceptanceProbe = null;
+                        const tryRecoverActionErrorAcceptance = async () => {
+                            if (!acceptanceProbe) {
                                 return false;
-                            case 'locator_resolution_failed':
-                                attempts.push(`stale.locator:${staleStage}`);
-                                staleReason = 'locator-resolution-failed';
+                            }
+                            const acceptance = await waitForAcceptanceProbe(acceptanceProbe).catch(() => null);
+                            if (acceptance?.polls && acceptance.polls > 1) {
+                                attempts.push(`acceptance.polled:${acceptance.polls}`);
+                            }
+                            if (!acceptance?.accepted) {
                                 return false;
-                            case 'dom_signature_mismatch': {
-                                const rebound = await tryRebindMutableFieldTarget(resolvedLocator, staleStage);
-                                if (rebound) {
+                            }
+                            if (acceptanceProbe.policy === 'submit') {
+                                const submitResolution = await resolveSubmitResult(acceptanceProbe, acceptance.afterPageObservation);
+                                if (!submitResolution.acceptAsProgress) {
+                                    return false;
+                                }
+                                attempts.push(`submit-resolution:${submitResolution.finalVerdict}`);
+                                if (submitResolution.claims.some((claim) => claim.kind === 'soft_result_candidate')) {
+                                    attempts.push('submit-resolution:soft-result-candidate');
+                                }
+                            }
+                            attempts.push(`acceptance.recovered:${acceptanceProbe.policy}`);
+                            incrementMetric(session, 'fallbackActions');
+                            resolvedBy = 'playwright-locator';
+                            locatorStrategy = strategy;
+                            recoveredProgressProbe = acceptanceProbe;
+                            progressProbe = null;
+                            lastError = null;
+                            recoveredAfterError = true;
+                            recoveredAcceptancePolicy = acceptanceProbe.policy;
+                            setTargetAvailability(session, targetRef, 'available');
+                            return true;
+                        };
+                        try {
+                            const valueProjection = await projectActionValue({
+                                target,
+                                action,
+                                actionValue,
+                                locator: resolvedLocator,
+                                attempts,
+                            });
+                            const executionValue = valueProjection?.executionValue ?? actionValue;
+                            const acceptanceValue = valueProjection?.acceptanceValue ?? actionValue;
+                            acceptanceProbe = await createAcceptanceProbe({
+                                session,
+                                page,
+                                target,
+                                action,
+                                actionValue: acceptanceValue,
+                                locator: resolvedLocator,
+                                beforePageObservation,
+                            });
+                            attempts.push(`resolve:${strategy}`);
+                            const usedFallback = await applyActionWithFallbacks(page, locatorRoot, resolvedLocator, action, executionValue, attempts, target.controlFamily, {
+                                clickActivationStrategy: clickActivationStrategyForTarget(target, action),
+                                guards: {
+                                    assertStillValid: async (stage) => {
+                                        await assertResolvedTargetStillValid(resolvedLocator, stage);
+                                    },
+                                },
+                            });
+                            if (usedFallback) {
+                                incrementMetric(session, 'fallbackActions');
+                            }
+                            resolvedBy = 'playwright-locator';
+                            locatorStrategy = strategy;
+                            progressProbe = acceptanceProbe;
+                            setTargetAvailability(session, targetRef, 'available');
+                            return true;
+                        }
+                        catch (err) {
+                            lastError = err instanceof Error ? err : new Error(String(err));
+                            const shouldAttemptAcceptanceRecovery = acceptanceProbe !== null &&
+                                (acceptanceProbe.policy === 'value-change' ||
+                                    acceptanceProbe.policy === 'selection' ||
+                                    acceptanceProbe.policy === 'date-selection' ||
+                                    acceptanceProbe.policy === 'navigation' ||
+                                    acceptanceProbe.policy === 'submit');
+                            if (shouldAttemptAcceptanceRecovery && (await tryRecoverActionErrorAcceptance())) {
+                                return true;
+                            }
+                            if (staleReason) {
+                                throw lastError;
+                            }
+                            try {
+                                await assertResolvedTargetStillValid(resolvedLocator, `after-error:${strategy}`);
+                            }
+                            catch (validationError) {
+                                if ((acceptanceProbe?.policy === 'navigation' ||
+                                    acceptanceProbe?.policy === 'submit') &&
+                                    validationError instanceof Error &&
+                                    validationError.message === 'stale_target_page_signature_changed' &&
+                                    (await tryRecoverActionErrorAcceptance())) {
                                     return true;
                                 }
-                                attempts.push(`stale.dom-signature:${staleStage}`);
-                                staleReason = 'dom-signature-mismatch';
-                                return false;
+                                throw validationError;
                             }
+                            return false;
                         }
-                    },
-                    errorForReason: (reason) => {
-                        switch (reason) {
-                            case 'page_signature_mismatch':
-                                return 'stale_target_page_signature_changed';
-                            case 'locator_resolution_failed':
-                                return 'stale_target_locator_resolution_failed';
-                            case 'dom_signature_mismatch':
-                                return 'stale_target_dom_signature_changed';
+                    };
+                    const watchForNewPage = shouldWatchForNewPageAfterAction(target, action);
+                    const popupPromise = watchForNewPage
+                        ? waitForPopup(page.context())
+                        : Promise.resolve(null);
+                    const tryRankedCandidates = async () => {
+                        const resolution = await resolvePreparedLocatorCandidates({
+                            target,
+                            action,
+                            baseRoot,
+                            locatorRoot,
+                            surfaceRoot,
+                            attempts,
+                            prepareOptions: {
+                                allowReadonlyFallback: action === 'fill' && target.controlFamily === 'datepicker',
+                                allowDescendantPressFallback: action === 'press' &&
+                                    (target.controlFamily === 'text-input' ||
+                                        target.controlFamily === 'select' ||
+                                        target.controlFamily === 'datepicker'),
+                                isUserActionable: isLocatorUserActionable,
+                            },
+                            onPreparedLocator: async (resolvedLocator, strategy) => attemptResolvedLocator(resolvedLocator, strategy),
+                        });
+                        if (resolution.sawDisabledTarget) {
+                            sawDisabledTarget = true;
                         }
-                    },
-                });
-            };
-            let resolvedBy = null;
-            const beforePages = listPages(browser);
-            const shouldCheckProgress = shouldVerifyObservableProgress(target, action);
-            const beforePageObservation = shouldCheckProgress
-                ? await capturePageObservation(page)
-                : null;
-            const deferSurfaceResolution = shouldDeferSurfaceResolutionForEditablePress(target, action);
-            let baseRoot = page;
-            let locatorRoot = baseRoot;
-            let surfaceRoot = null;
-            if (!deferSurfaceResolution) {
-                ({ baseRoot, locatorRoot, surfaceRoot } = await resolveInteractionRoots(page, target, surface, attempts, {
-                    recordSelfTargetReuse: true,
-                }));
-            }
-            let lastError = null;
-            let sawDomSignatureMismatch = false;
-            let sawDisabledTarget = false;
-            let sawReadonlyTarget = false;
-            const attemptResolvedLocator = async (resolvedLocator, strategy, options) => {
-                if (!options?.skipDomSignature && liveTarget.domSignature) {
-                    const rebound = await tryRebindMutableFieldTarget(resolvedLocator, strategy);
-                    if (!rebound) {
-                        const liveSignature = await readLocatorDomSignature(resolvedLocator);
-                        if (liveSignature && liveSignature !== liveTarget.domSignature) {
-                            attempts.push(`domSignature.mismatch:${strategy}`);
-                            sawDomSignatureMismatch = true;
-                            return false;
+                        if (resolution.sawReadonlyTarget) {
+                            sawReadonlyTarget = true;
+                        }
+                    };
+                    await tryRankedCandidates();
+                    if (!resolvedBy && !lastError && deferSurfaceResolution && surface) {
+                        const deferredSurfaceRoot = await resolveSurfaceScopeRoot(page, surface, attempts);
+                        if (deferredSurfaceRoot) {
+                            surfaceRoot = deferredSurfaceRoot;
+                            locatorRoot = targetUsesSurfaceAsPrimaryLocator(target, surface)
+                                ? baseRoot
+                                : surfaceRoot;
+                            await tryRankedCandidates();
                         }
                     }
-                }
-                let acceptanceProbe = null;
-                const tryRecoverActionErrorAcceptance = async () => {
-                    if (!acceptanceProbe) {
-                        return false;
+                    if (!resolvedBy && !lastError && surfaceRoot) {
+                        const recoveredLocator = await recoverLocatorFromSurfaceRoot(surfaceRoot, target, action, attempts);
+                        if (recoveredLocator) {
+                            await attemptResolvedLocator(recoveredLocator, 'surface-descendant', {
+                                skipDomSignature: true,
+                            });
+                        }
+                    }
+                    if (!resolvedBy) {
+                        if (sawDomSignatureMismatch) {
+                            staleReason = 'dom-signature-mismatch';
+                            throw new Error('stale_target_dom_signature_changed');
+                        }
+                        if (sawDisabledTarget) {
+                            setTargetAvailability(session, targetRef, 'gated', 'disabled');
+                            throw new Error('target_disabled');
+                        }
+                        if (sawReadonlyTarget && (action === 'fill' || action === 'type')) {
+                            setTargetAvailability(session, targetRef, 'gated', 'readonly');
+                            throw new Error('target_readonly');
+                        }
+                        if (!lastError &&
+                            target.surfaceRef &&
+                            (target.acceptancePolicy === 'selection' ||
+                                target.acceptancePolicy === 'date-selection')) {
+                            setTargetAvailability(session, targetRef, 'surface-inactive', 'surface-not-active');
+                            throw new Error('target_surface_inactive');
+                        }
+                        if (!resolvedBy) {
+                            if (!lastError &&
+                                (target.controlFamily === 'text-input' ||
+                                    target.controlFamily === 'select' ||
+                                    target.controlFamily === 'datepicker')) {
+                                staleReason = 'locator-resolution-failed';
+                                throw new Error('stale_target_locator_resolution_failed');
+                            }
+                            if (lastError) {
+                                throw lastError;
+                            }
+                            throw new Error('deterministic_target_resolution_failed');
+                        }
                     }
-                    const acceptance = await waitForAcceptanceProbe(acceptanceProbe).catch(() => null);
-                    if (acceptance?.polls && acceptance.polls > 1) {
-                        attempts.push(`acceptance.polled:${acceptance.polls}`);
+                    const popup = await popupPromise;
+                    const latePage = !popup && watchForNewPage ? await waitForLatePage(browser, beforePages) : null;
+                    if (latePage) {
+                        attempts.push('late-page-captured');
                     }
-                    if (!acceptance?.accepted) {
-                        return false;
+                    const discoveredPage = popup ?? latePage;
+                    const afterPages = discoveredPage
+                        ? [...beforePages, discoveredPage]
+                        : listPages(browser);
+                    const capturedPopup = await capturePopupIfOpened(session, beforePages, afterPages, target.pageRef, attempts);
+                    let finalPageRef = target.pageRef;
+                    if (capturedPopup) {
+                        await syncSessionPage(session, capturedPopup.page.pageRef, capturedPopup.popup, {
+                            settleTimeoutMs: 1_500,
+                        });
+                        setCurrentPage(session, capturedPopup.page.pageRef);
+                        finalPageRef = capturedPopup.page.pageRef;
+                        currentPageRef = finalPageRef;
                     }
-                    if (acceptanceProbe.policy === 'submit') {
-                        const submitResolution = await resolveSubmitResult(acceptanceProbe, acceptance.afterPageObservation);
-                        if (!submitResolution.acceptAsProgress) {
-                            return false;
+                    else {
+                        const syncedPage = await syncSessionPage(session, target.pageRef, page);
+                        currentPageRef = target.pageRef;
+                        if (startingPageUrl && syncedPage.url && syncedPage.url !== startingPageUrl) {
+                            clearProtectedExposure(session, target.pageRef);
+                            markFillableFormsAbsentForPage(session, target.pageRef);
+                        }
+                        const progressProbeForVerification = progressProbe;
+                        if (progressProbeForVerification) {
+                            const finalProgressProbe = progressProbeForVerification;
+                            const acceptance = await waitForAcceptanceProbe(finalProgressProbe);
+                            const afterPageObservation = acceptance.afterPageObservation;
+                            const accepted = acceptance.accepted;
+                            const submitResolution = finalProgressProbe.policy === 'submit'
+                                ? await resolveSubmitResult(finalProgressProbe, afterPageObservation)
+                                : null;
+                            if (acceptance.polls > 1) {
+                                attempts.push(`acceptance.polled:${acceptance.polls}`);
+                            }
+                            if (submitResolution?.finalVerdict === 'blocked') {
+                                attempts.push(`acceptance.failed:${finalProgressProbe.policy}`);
+                                noProgressObservations = await diagnoseNoObservableProgress(page, finalProgressProbe.locator);
+                                attempts.push('submit-resolution:blocked');
+                                throw new Error('validation_blocked');
+                            }
+                            if (!accepted) {
+                                if (finalProgressProbe.policy === 'value-change') {
+                                    attempts.push(`acceptance.failed:${finalProgressProbe.policy}`);
+                                    throw new Error('action_postcondition_failed:value-change');
+                                }
+                                if ((finalProgressProbe.policy === 'selection' ||
+                                    finalProgressProbe.policy === 'date-selection') &&
+                                    finalProgressProbe.expectedValue !== null) {
+                                    attempts.push(`acceptance.failed:${finalProgressProbe.policy}`);
+                                    throw new Error(`action_postcondition_failed:${finalProgressProbe.policy}`);
+                                }
+                                if (finalProgressProbe.policy === 'submit' && submitResolution) {
+                                    if (submitResolution.acceptAsProgress) {
+                                        attempts.push(`submit-resolution:${submitResolution.finalVerdict}`);
+                                        if (submitResolution.claims.some((claim) => claim.kind === 'soft_result_candidate')) {
+                                            attempts.push('submit-resolution:soft-result-candidate');
+                                        }
+                                    }
+                                    else {
+                                        attempts.push(`acceptance.failed:${finalProgressProbe.policy}`);
+                                        noProgressObservations = await diagnoseNoObservableProgress(page, finalProgressProbe.locator);
+                                        if (hasValidationBlockedObservations(noProgressObservations)) {
+                                            attempts.push('submit-resolution:blocked');
+                                            throw new Error('validation_blocked');
+                                        }
+                                        attempts.push('no-progress.detected');
+                                        throw new Error('no_observable_progress');
+                                    }
+                                }
+                                else {
+                                    const afterLocatorObservation = finalProgressProbe.trackedStateKeys.length > 0
+                                        ? await captureLocatorState(finalProgressProbe.locator, finalProgressProbe.trackedStateKeys)
+                                        : null;
+                                    const afterContextHash = await captureLocatorContextHash(finalProgressProbe.locator);
+                                    const hasComparableSignal = finalProgressProbe.trackedStateKeys.length > 0 ||
+                                        Boolean(finalProgressProbe.beforeContextHash || afterContextHash) ||
+                                        Boolean(finalProgressProbe.beforePage || afterPageObservation);
+                                    const pageProgressChanged = finalProgressProbe.policy === 'generic-click'
+                                        ? genericClickObservationChanged(finalProgressProbe.beforePage, afterPageObservation)
+                                        : pageObservationChanged(finalProgressProbe.beforePage, afterPageObservation);
+                                    if (hasComparableSignal &&
+                                        !pageProgressChanged &&
+                                        finalProgressProbe.beforeContextHash === afterContextHash &&
+                                        !locatorStateChanged(finalProgressProbe.beforeLocator, afterLocatorObservation)) {
+                                        attempts.push('no-progress.detected');
+                                        noProgressObservations = await diagnoseNoObservableProgress(page, finalProgressProbe.locator);
+                                        throw new Error('no_observable_progress');
+                                    }
+                                }
+                            }
+                            else {
+                                partialProgressResult = await partialProgressForAliasedSelection({
+                                    requestedAction,
+                                    probe: finalProgressProbe,
+                                });
+                            }
                         }
-                        attempts.push(`submit-resolution:${submitResolution.finalVerdict}`);
-                        if (submitResolution.claims.some((claim) => claim.kind === 'soft_result_candidate')) {
-                            attempts.push('submit-resolution:soft-result-candidate');
+                        else if (recoveredProgressProbe) {
+                            partialProgressResult = await partialProgressForAliasedSelection({
+                                requestedAction,
+                                probe: recoveredProgressProbe,
+                            });
                         }
                     }
-                    attempts.push(`acceptance.recovered:${acceptanceProbe.policy}`);
-                    incrementMetric(session, 'fallbackActions');
-                    resolvedBy = 'playwright-locator';
-                    locatorStrategy = strategy;
-                    recoveredProgressProbe = acceptanceProbe;
-                    progressProbe = null;
-                    lastError = null;
-                    recoveredAfterError = true;
-                    recoveredAcceptancePolicy = acceptanceProbe.policy;
-                    setTargetAvailability(session, targetRef, 'available');
-                    return true;
-                };
-                try {
-                    const valueProjection = await projectActionValue({
-                        target,
-                        action,
-                        actionValue,
-                        locator: resolvedLocator,
-                        attempts,
-                    });
-                    const executionValue = valueProjection?.executionValue ?? actionValue;
-                    const acceptanceValue = valueProjection?.acceptanceValue ?? actionValue;
-                    acceptanceProbe = await createAcceptanceProbe({
+                    if (resolvedBy === 'playwright-locator') {
+                        incrementMetric(session, 'deterministicActions');
+                    }
+                    bumpPageScopeEpoch(session, target.pageRef);
+                    recordActionResult(session, true, Date.now() - startedAt);
+                    await trace.finishSuccess();
+                    captureDiagnosticSnapshotBestEffort({
                         session,
-                        page,
-                        target,
-                        action,
-                        actionValue: acceptanceValue,
-                        locator: resolvedLocator,
-                        beforePageObservation,
+                        step: actStep,
+                        phase: 'after',
+                        pageRef: finalPageRef,
                     });
-                    attempts.push(`resolve:${strategy}`);
-                    const usedFallback = await applyActionWithFallbacks(page, locatorRoot, resolvedLocator, action, executionValue, attempts, target.controlFamily, {
-                        clickActivationStrategy: clickActivationStrategyForTarget(target, action),
-                        guards: {
-                            assertStillValid: async (stage) => {
-                                await assertResolvedTargetStillValid(resolvedLocator, stage);
-                            },
+                    recordCommandLifecycleEventBestEffort({
+                        step: actStep,
+                        phase: 'completed',
+                        attributes: {
+                            outcomeType: partialProgressResult?.outcomeType ?? 'action_completed',
+                            targetRef,
+                            action: requestedAction,
+                            pageRef: finalPageRef,
                         },
                     });
-                    if (usedFallback) {
-                        incrementMetric(session, 'fallbackActions');
-                    }
-                    resolvedBy = 'playwright-locator';
-                    locatorStrategy = strategy;
-                    progressProbe = acceptanceProbe;
-                    setTargetAvailability(session, targetRef, 'available');
-                    return true;
+                    await finalizeActStepBestEffort(actStep, {
+                        success: true,
+                        outcomeType: partialProgressResult?.outcomeType ?? 'action_completed',
+                        message: partialProgressResult?.message ?? 'The requested action completed successfully.',
+                    });
+                    return scrubProtectedExactValues(session, {
+                        success: true,
+                        targetRef,
+                        action: requestedAction,
+                        ...(action !== requestedAction ? { executedAs: action } : {}),
+                        value: actionValue,
+                        resolvedBy,
+                        locatorStrategy,
+                        pageRef: finalPageRef,
+                        attempts: sanitizePublicAttempts(attempts),
+                        popup: Boolean(capturedPopup),
+                        overlayHandled: attempts.includes('overlay.dismissed'),
+                        iframe: Boolean(target.framePath?.length),
+                        jsFallback: attempts.some((attempt) => attempt.startsWith('locator.evaluate.')),
+                        ...(recoveredAfterError
+                            ? {
+                                recoveredAfterError: true,
+                                recoveredAcceptancePolicy: recoveredAcceptancePolicy ?? undefined,
+                            }
+                            : {}),
+                        ...(partialProgressResult ?? {}),
+                        durationMs: Date.now() - startedAt,
+                        metrics: session.runtime?.metrics,
+                    });
                 }
                 catch (err) {
-                    lastError = err instanceof Error ? err : new Error(String(err));
-                    const shouldAttemptAcceptanceRecovery = acceptanceProbe !== null &&
-                        (acceptanceProbe.policy === 'value-change' ||
-                            acceptanceProbe.policy === 'selection' ||
-                            acceptanceProbe.policy === 'date-selection' ||
-                            acceptanceProbe.policy === 'navigation' ||
-                            acceptanceProbe.policy === 'submit');
-                    if (shouldAttemptAcceptanceRecovery && (await tryRecoverActionErrorAcceptance())) {
-                        return true;
-                    }
+                    failureMessage = `Act failed: ${err instanceof Error ? err.message : String(err)}`;
+                    recordActionResult(session, false, Date.now() - startedAt);
                     if (staleReason) {
-                        throw lastError;
-                    }
-                    try {
-                        await assertResolvedTargetStillValid(resolvedLocator, `after-error:${strategy}`);
-                    }
-                    catch (validationError) {
-                        if ((acceptanceProbe?.policy === 'navigation' ||
-                            acceptanceProbe?.policy === 'submit') &&
-                            validationError instanceof Error &&
-                            validationError.message === 'stale_target_page_signature_changed' &&
-                            (await tryRecoverActionErrorAcceptance())) {
-                            return true;
-                        }
-                        throw validationError;
-                    }
-                    return false;
-                }
-            };
-            const watchForNewPage = shouldWatchForNewPageAfterAction(target, action);
-            const popupPromise = watchForNewPage
-                ? waitForPopup(page.context())
-                : Promise.resolve(null);
-            const tryRankedCandidates = async () => {
-                const resolution = await resolvePreparedLocatorCandidates({
-                    target,
-                    action,
-                    baseRoot,
-                    locatorRoot,
-                    surfaceRoot,
-                    attempts,
-                    prepareOptions: {
-                        allowReadonlyFallback: action === 'fill' && target.controlFamily === 'datepicker',
-                        allowDescendantPressFallback: action === 'press' &&
-                            (target.controlFamily === 'text-input' ||
-                                target.controlFamily === 'select' ||
-                                target.controlFamily === 'datepicker'),
-                        isUserActionable: isLocatorUserActionable,
-                    },
-                    onPreparedLocator: async (resolvedLocator, strategy) => attemptResolvedLocator(resolvedLocator, strategy),
-                });
-                if (resolution.sawDisabledTarget) {
-                    sawDisabledTarget = true;
-                }
-                if (resolution.sawReadonlyTarget) {
-                    sawReadonlyTarget = true;
-                }
-            };
-            await tryRankedCandidates();
-            if (!resolvedBy && !lastError && deferSurfaceResolution && surface) {
-                const deferredSurfaceRoot = await resolveSurfaceScopeRoot(page, surface, attempts);
-                if (deferredSurfaceRoot) {
-                    surfaceRoot = deferredSurfaceRoot;
-                    locatorRoot = targetUsesSurfaceAsPrimaryLocator(target, surface)
-                        ? baseRoot
-                        : surfaceRoot;
-                    await tryRankedCandidates();
-                }
-            }
-            if (!resolvedBy && !lastError && surfaceRoot) {
-                const recoveredLocator = await recoverLocatorFromSurfaceRoot(surfaceRoot, target, action, attempts);
-                if (recoveredLocator) {
-                    await attemptResolvedLocator(recoveredLocator, 'surface-descendant', {
-                        skipDomSignature: true,
-                    });
-                }
-            }
-            if (!resolvedBy) {
-                if (sawDomSignatureMismatch) {
-                    staleReason = 'dom-signature-mismatch';
-                    throw new Error('stale_target_dom_signature_changed');
-                }
-                if (sawDisabledTarget) {
-                    setTargetAvailability(session, targetRef, 'gated', 'disabled');
-                    throw new Error('target_disabled');
-                }
-                if (sawReadonlyTarget && (action === 'fill' || action === 'type')) {
-                    setTargetAvailability(session, targetRef, 'gated', 'readonly');
-                    throw new Error('target_readonly');
-                }
-                if (!lastError &&
-                    target.surfaceRef &&
-                    (target.acceptancePolicy === 'selection' ||
-                        target.acceptancePolicy === 'date-selection')) {
-                    setTargetAvailability(session, targetRef, 'surface-inactive', 'surface-not-active');
-                    throw new Error('target_surface_inactive');
-                }
-                if (!resolvedBy) {
-                    if (!lastError &&
-                        (target.controlFamily === 'text-input' ||
-                            target.controlFamily === 'select' ||
-                            target.controlFamily === 'datepicker')) {
-                        staleReason = 'locator-resolution-failed';
-                        throw new Error('stale_target_locator_resolution_failed');
+                        markTargetLifecycle(session, targetRef, 'stale', staleReason);
                     }
-                    if (lastError) {
-                        throw lastError;
-                    }
-                    throw new Error('deterministic_target_resolution_failed');
-                }
-            }
-            const popup = await popupPromise;
-            const latePage = !popup && watchForNewPage ? await waitForLatePage(browser, beforePages) : null;
-            if (latePage) {
-                attempts.push('late-page-captured');
-            }
-            const discoveredPage = popup ?? latePage;
-            const afterPages = discoveredPage ? [...beforePages, discoveredPage] : listPages(browser);
-            const capturedPopup = await capturePopupIfOpened(session, beforePages, afterPages, target.pageRef, attempts);
-            let finalPageRef = target.pageRef;
-            if (capturedPopup) {
-                await syncSessionPage(session, capturedPopup.page.pageRef, capturedPopup.popup, {
-                    settleTimeoutMs: 1_500,
-                });
-                setCurrentPage(session, capturedPopup.page.pageRef);
-                finalPageRef = capturedPopup.page.pageRef;
-                currentPageRef = finalPageRef;
-            }
-            else {
-                const syncedPage = await syncSessionPage(session, target.pageRef, page);
-                currentPageRef = target.pageRef;
-                if (startingPageUrl && syncedPage.url && syncedPage.url !== startingPageUrl) {
-                    clearProtectedExposure(session, target.pageRef);
-                    markFillableFormsAbsentForPage(session, target.pageRef);
-                }
-                const progressProbeForVerification = progressProbe;
-                if (progressProbeForVerification) {
-                    const finalProgressProbe = progressProbeForVerification;
-                    const acceptance = await waitForAcceptanceProbe(finalProgressProbe);
-                    const afterPageObservation = acceptance.afterPageObservation;
-                    const accepted = acceptance.accepted;
-                    const submitResolution = finalProgressProbe.policy === 'submit'
-                        ? await resolveSubmitResult(finalProgressProbe, afterPageObservation)
-                        : null;
-                    if (acceptance.polls > 1) {
-                        attempts.push(`acceptance.polled:${acceptance.polls}`);
-                    }
-                    if (submitResolution?.finalVerdict === 'blocked') {
-                        attempts.push(`acceptance.failed:${finalProgressProbe.policy}`);
-                        noProgressObservations = await diagnoseNoObservableProgress(page, finalProgressProbe.locator);
-                        attempts.push('submit-resolution:blocked');
-                        throw new Error('validation_blocked');
-                    }
-                    if (!accepted) {
-                        if (finalProgressProbe.policy === 'value-change') {
-                            attempts.push(`acceptance.failed:${finalProgressProbe.policy}`);
-                            throw new Error('action_postcondition_failed:value-change');
-                        }
-                        if ((finalProgressProbe.policy === 'selection' ||
-                            finalProgressProbe.policy === 'date-selection') &&
-                            finalProgressProbe.expectedValue !== null) {
-                            attempts.push(`acceptance.failed:${finalProgressProbe.policy}`);
-                            throw new Error(`action_postcondition_failed:${finalProgressProbe.policy}`);
-                        }
-                        if (finalProgressProbe.policy === 'submit' && submitResolution) {
-                            if (submitResolution.acceptAsProgress) {
-                                attempts.push(`submit-resolution:${submitResolution.finalVerdict}`);
-                                if (submitResolution.claims.some((claim) => claim.kind === 'soft_result_candidate')) {
-                                    attempts.push('submit-resolution:soft-result-candidate');
-                                }
+                    if (currentPage) {
+                        try {
+                            const protectedExposure = getProtectedExposure(session, currentPageRef);
+                            if (protectedExposure) {
+                                await trace.finishSuccess();
+                                failureArtifacts = buildProtectedArtifactsSuppressed(protectedExposure);
                             }
                             else {
-                                attempts.push(`acceptance.failed:${finalProgressProbe.policy}`);
-                                noProgressObservations = await diagnoseNoObservableProgress(page, finalProgressProbe.locator);
-                                if (hasValidationBlockedObservations(noProgressObservations)) {
-                                    attempts.push('submit-resolution:blocked');
-                                    throw new Error('validation_blocked');
-                                }
-                                attempts.push('no-progress.detected');
-                                throw new Error('no_observable_progress');
+                                failureArtifacts = await captureActionFailureArtifacts({
+                                    page: currentPage,
+                                    targetRef,
+                                    action: requestedAction,
+                                    pageRef: currentPageRef,
+                                    attempts,
+                                    locatorStrategy,
+                                    popup: attempts.includes('popup-captured'),
+                                    overlayHandled: attempts.includes('overlay.dismissed'),
+                                    iframe: Boolean(target.framePath?.length),
+                                    jsFallback: attempts.some((attempt) => attempt.startsWith('locator.evaluate.')),
+                                    durationMs: Date.now() - startedAt,
+                                    error: failureMessage,
+                                    finishTrace: (artifactDir) => trace.finishFailure(artifactDir),
+                                });
                             }
                         }
-                        else {
-                            const afterLocatorObservation = finalProgressProbe.trackedStateKeys.length > 0
-                                ? await captureLocatorState(finalProgressProbe.locator, finalProgressProbe.trackedStateKeys)
-                                : null;
-                            const afterContextHash = await captureLocatorContextHash(finalProgressProbe.locator);
-                            const hasComparableSignal = finalProgressProbe.trackedStateKeys.length > 0 ||
-                                Boolean(finalProgressProbe.beforeContextHash || afterContextHash) ||
-                                Boolean(finalProgressProbe.beforePage || afterPageObservation);
-                            const pageProgressChanged = finalProgressProbe.policy === 'generic-click'
-                                ? genericClickObservationChanged(finalProgressProbe.beforePage, afterPageObservation)
-                                : pageObservationChanged(finalProgressProbe.beforePage, afterPageObservation);
-                            if (hasComparableSignal &&
-                                !pageProgressChanged &&
-                                finalProgressProbe.beforeContextHash === afterContextHash &&
-                                !locatorStateChanged(finalProgressProbe.beforeLocator, afterLocatorObservation)) {
-                                attempts.push('no-progress.detected');
-                                noProgressObservations = await diagnoseNoObservableProgress(page, finalProgressProbe.locator);
-                                throw new Error('no_observable_progress');
-                            }
+                        catch {
+                            // Best effort only. Preserve the original action failure.
                         }
                     }
-                    else {
-                        partialProgressResult = await partialProgressForAliasedSelection({
-                            requestedAction,
-                            probe: finalProgressProbe,
-                        });
-                    }
                 }
-                else if (recoveredProgressProbe) {
-                    partialProgressResult = await partialProgressForAliasedSelection({
-                        requestedAction,
-                        probe: recoveredProgressProbe,
-                    });
+                if (!failureMessage) {
+                    throw new Error('unreachable_action_completion_state');
                 }
-            }
-            if (resolvedBy === 'playwright-locator') {
-                incrementMetric(session, 'deterministicActions');
-            }
-            bumpPageScopeEpoch(session, target.pageRef);
-            recordActionResult(session, true, Date.now() - startedAt);
-            await trace.finishSuccess();
-            captureDiagnosticSnapshotBestEffort({
-                session,
-                step: actStep,
-                phase: 'after',
-                pageRef: finalPageRef,
-            });
-            recordCommandLifecycleEventBestEffort({
-                step: actStep,
-                phase: 'completed',
-                attributes: {
-                    outcomeType: partialProgressResult?.outcomeType ?? 'action_completed',
+                const failureContract = describeActFailure({
+                    failureMessage,
+                    staleReason,
+                });
+                const outputObservations = hasMeaningfulNoObservableProgressObservations(noProgressObservations)
+                    ? noProgressObservations
+                    : undefined;
+                const artifactManifestId = await persistActArtifactManifestBestEffort(runId, actStep, actStep?.stepId, failureArtifacts ?? null);
+                captureDiagnosticSnapshotBestEffort({
+                    session,
+                    step: actStep,
+                    phase: 'point-in-time',
+                    pageRef: currentPageRef,
+                    artifactRefs: buildActSnapshotArtifactRefs(failureArtifacts ?? null),
+                });
+                recordCommandLifecycleEventBestEffort({
+                    step: actStep,
+                    phase: 'failed',
+                    attributes: {
+                        outcomeType: failureContract.outcomeType,
+                        targetRef,
+                        action: requestedAction,
+                        pageRef: currentPageRef,
+                        ...(artifactManifestId ? { artifactManifestId } : {}),
+                    },
+                });
+                await finalizeActStepBestEffort(actStep, {
+                    success: false,
+                    outcomeType: failureContract.outcomeType,
+                    message: failureContract.message,
+                    reason: failureContract.reason,
+                    artifactManifestId,
+                });
+                return scrubProtectedExactValues(session, {
+                    success: false,
+                    failureSurface: 'output',
+                    error: failureContract.error,
+                    outcomeType: failureContract.outcomeType,
+                    message: failureContract.message,
+                    reason: failureContract.reason,
                     targetRef,
                     action: requestedAction,
-                    pageRef: finalPageRef,
-                },
+                    ...(action !== requestedAction ? { executedAs: action } : {}),
+                    value: actionValue,
+                    pageRef: currentPageRef,
+                    locatorStrategy,
+                    attempts: sanitizePublicAttempts(attempts),
+                    popup: attempts.includes('popup-captured'),
+                    overlayHandled: attempts.includes('overlay.dismissed'),
+                    iframe: Boolean(target.framePath?.length),
+                    jsFallback: attempts.some((attempt) => attempt.startsWith('locator.evaluate.')),
+                    durationMs: Date.now() - startedAt,
+                    staleTarget: Boolean(staleReason),
+                    observations: outputObservations,
+                    artifacts: failureArtifacts,
+                    metrics: session.runtime?.metrics,
+                });
             });
-            await finalizeActStepBestEffort(actStep, {
-                success: true,
-                outcomeType: partialProgressResult?.outcomeType ?? 'action_completed',
-                message: partialProgressResult?.message ?? 'The requested action completed successfully.',
+        }
+        catch (err) {
+            const browserConnectionFailure = describeBrowserConnectionFailure(err, {
+                defaultMessage: 'The action could not start because AgentBrowse failed to connect to the browser.',
+                unrecoverableSessionMessage: 'The action could not start because the previous browser session is no longer reachable.',
             });
-            return scrubProtectedExactValues(session, {
-                success: true,
+            return buildActPreflightFailureResult({
+                session,
+                step: actStep,
+                error: 'browser_connection_failed',
+                outcomeType: 'blocked',
+                message: browserConnectionFailure.message,
+                reason: browserConnectionFailure.reason,
                 targetRef,
-                action: requestedAction,
-                ...(action !== requestedAction ? { executedAs: action } : {}),
-                value: actionValue,
-                resolvedBy,
-                locatorStrategy,
-                pageRef: finalPageRef,
-                attempts: sanitizePublicAttempts(attempts),
-                popup: Boolean(capturedPopup),
-                overlayHandled: attempts.includes('overlay.dismissed'),
-                iframe: Boolean(target.framePath?.length),
-                jsFallback: attempts.some((attempt) => attempt.startsWith('locator.evaluate.')),
-                ...(recoveredAfterError
-                    ? {
-                        recoveredAfterError: true,
-                        recoveredAcceptancePolicy: recoveredAcceptancePolicy ?? undefined,
-                    }
-                    : {}),
-                ...(partialProgressResult ?? {}),
-                durationMs: Date.now() - startedAt,
-                metrics: session.runtime?.metrics,
+                action,
             });
         }
-        catch (err) {
-            failureMessage = `Act failed: ${err instanceof Error ? err.message : String(err)}`;
-            recordActionResult(session, false, Date.now() - startedAt);
-            if (staleReason) {
-                markTargetLifecycle(session, targetRef, 'stale', staleReason);
-            }
-            if (currentPage) {
-                try {
-                    const protectedExposure = getProtectedExposure(session, currentPageRef);
-                    if (protectedExposure) {
-                        await trace.finishSuccess();
-                        failureArtifacts = buildProtectedArtifactsSuppressed(protectedExposure);
-                    }
-                    else {
-                        failureArtifacts = await captureActionFailureArtifacts({
-                            page: currentPage,
-                            targetRef,
-                            action: requestedAction,
-                            pageRef: currentPageRef,
-                            attempts,
-                            locatorStrategy,
-                            popup: attempts.includes('popup-captured'),
-                            overlayHandled: attempts.includes('overlay.dismissed'),
-                            iframe: Boolean(target.framePath?.length),
-                            jsFallback: attempts.some((attempt) => attempt.startsWith('locator.evaluate.')),
-                            durationMs: Date.now() - startedAt,
-                            error: failureMessage,
-                            finishTrace: (artifactDir) => trace.finishFailure(artifactDir),
-                        });
-                    }
-                }
-                catch {
-                    // Best effort only. Preserve the original action failure.
-                }
-            }
-        }
-        finally {
-            if (browser) {
-                await disconnectPlaywright(browser);
-            }
-        }
-        if (!failureMessage) {
-            throw new Error('unreachable_action_completion_state');
-        }
-        const failureContract = describeActFailure({
-            failureMessage,
-            staleReason,
-        });
-        const outputObservations = hasMeaningfulNoObservableProgressObservations(noProgressObservations)
-            ? noProgressObservations
-            : undefined;
-        const artifactManifestId = await persistActArtifactManifestBestEffort(runId, actStep, actStep?.stepId, failureArtifacts ?? null);
-        captureDiagnosticSnapshotBestEffort({
-            session,
-            step: actStep,
-            phase: 'point-in-time',
-            pageRef: currentPageRef,
-            artifactRefs: buildActSnapshotArtifactRefs(failureArtifacts ?? null),
-        });
-        recordCommandLifecycleEventBestEffort({
-            step: actStep,
-            phase: 'failed',
-            attributes: {
-                outcomeType: failureContract.outcomeType,
-                targetRef,
-                action: requestedAction,
-                pageRef: currentPageRef,
-                ...(artifactManifestId ? { artifactManifestId } : {}),
-            },
-        });
-        await finalizeActStepBestEffort(actStep, {
-            success: false,
-            outcomeType: failureContract.outcomeType,
-            message: failureContract.message,
-            reason: failureContract.reason,
-            artifactManifestId,
-        });
-        return scrubProtectedExactValues(session, {
-            success: false,
-            failureSurface: 'output',
-            error: failureContract.error,
-            outcomeType: failureContract.outcomeType,
-            message: failureContract.message,
-            reason: failureContract.reason,
-            targetRef,
-            action: requestedAction,
-            ...(action !== requestedAction ? { executedAs: action } : {}),
-            value: actionValue,
-            pageRef: currentPageRef,
-            locatorStrategy,
-            attempts: sanitizePublicAttempts(attempts),
-            popup: attempts.includes('popup-captured'),
-            overlayHandled: attempts.includes('overlay.dismissed'),
-            iframe: Boolean(target.framePath?.length),
-            jsFallback: attempts.some((attempt) => attempt.startsWith('locator.evaluate.')),
-            durationMs: Date.now() - startedAt,
-            staleTarget: Boolean(staleReason),
-            observations: outputObservations,
-            artifacts: failureArtifacts,
-            metrics: session.runtime?.metrics,
-        });
     });
 }
 export async function act(session, targetRef, action, value) {