@nuanu-ai/agentbrowse 0.2.7 → 0.2.8

package/dist/commands/fill-secret.js

@@ -0,0 +1,371 @@
+/**
+ * browse fill-secret <fillRef> <intentId> — Fill protected fields from a cached one-time secret payload
+ * using the persisted plan and deterministic browser execution.
+ */
+import { outputFailure, outputJSON } from '../output.js';
+import { getFillableForm, getSecretIntentSnapshot, saveProtectedExposure, saveSecretIntentSnapshot, } from '../runtime-state.js';
+import { deleteCachedTransientSecret, getCachedTransientSecret, saveSession } from '../session.js';
+import { connectPlaywright, disconnectPlaywright, resolvePageByRef, syncSessionPage, } from '../playwright-runtime.js';
+import { tryResolveCatalogHost } from '../secrets/catalog-sync.js';
+import { describeSecretIntentStatus, serializeSecretIntentContext, } from '../secrets/intent-output.js';
+import { executeProtectedFill } from '../secrets/protected-fill.js';
+function persistIntentSnapshot(session, snapshot) {
+    const persisted = saveSecretIntentSnapshot(session, snapshot);
+    saveSession(session);
+    return persisted;
+}
+function completeIntent(session, intentId) {
+    const current = getSecretIntentSnapshot(session, intentId);
+    if (!current) {
+        throw new Error('secret_intent_not_found');
+    }
+    if (current.status === 'completed') {
+        return current;
+    }
+    return persistIntentSnapshot(session, {
+        ...current,
+        status: 'completed',
+        completedAt: new Date().toISOString(),
+    });
+}
+function activateProtectedExposure(session, fillableForm, intentId, reason) {
+    saveProtectedExposure(session, {
+        pageRef: fillableForm.pageRef,
+        scopeRef: fillableForm.scopeRef,
+        fillRef: fillableForm.fillRef,
+        intentId,
+        activatedAt: new Date().toISOString(),
+        reason,
+    });
+    saveSession(session);
+}
+function restrictFormToCandidateFields(fillableForm, storedSecretCandidate) {
+    if (!storedSecretCandidate?.fieldKeys || storedSecretCandidate.fieldKeys.length === 0) {
+        return fillableForm;
+    }
+    const allowedFieldKeys = new Set(storedSecretCandidate.fieldKeys);
+    const filteredFields = fillableForm.fields.filter((field) => allowedFieldKeys.has(field.fieldKey));
+    if (filteredFields.length === fillableForm.fields.length || filteredFields.length === 0) {
+        return filteredFields.length === 0 ? fillableForm : { ...fillableForm, fields: filteredFields };
+    }
+    return {
+        ...fillableForm,
+        fields: filteredFields,
+    };
+}
+function nextActionForNonApprovedIntent(status) {
+    switch (status) {
+        case 'pending':
+        case 'checking':
+        case 'notify':
+        case 'confirmation':
+            return 'wait-for-approval';
+        case 'denied':
+            return 'ask-user';
+        case 'timed_out':
+        case 'completed':
+            return 'ask-user';
+        default:
+            return 'ask-user';
+    }
+}
+function messageForNonApprovedIntent(status) {
+    switch (status) {
+        case 'pending':
+        case 'checking':
+        case 'notify':
+        case 'confirmation':
+            return 'Protected fill is waiting for user approval in AgentPay Cabinet.';
+        case 'denied':
+            return 'Protected fill is blocked because the user denied this intent in AgentPay Cabinet.';
+        case 'timed_out':
+        case 'completed':
+            return 'Protected fill requires a new intent because this intent is no longer usable.';
+        default:
+            return 'Protected fill cannot continue because the intent is not approved.';
+    }
+}
+function outcomeTypeForNonApprovedIntent(status) {
+    return describeSecretIntentStatus(status).outcomeType;
+}
+function reasonForNonApprovedIntent(status) {
+    return describeSecretIntentStatus(status).reason;
+}
+export async function fillSecret(session, fillRef, intentId) {
+    const fillableForm = getFillableForm(session, fillRef);
+    if (!fillableForm) {
+        return outputFailure({
+            error: 'unknown_fill_ref',
+            outcomeType: 'blocked',
+            message: 'Protected fill was not started because the requested fill reference is unknown.',
+            reason: 'The provided fillRef does not match any currently observed protected fill target.',
+            fillRef,
+            intentId,
+        });
+    }
+    const intent = getSecretIntentSnapshot(session, intentId);
+    if (!intent) {
+        return outputFailure({
+            error: 'secret_intent_not_found',
+            outcomeType: 'blocked',
+            message: 'Protected fill was not started because the requested intent does not exist.',
+            reason: 'The provided intentId was not found in AgentPay Cabinet.',
+            fillRef,
+            intentId,
+        });
+    }
+    const latestIntent = persistIntentSnapshot(session, intent);
+    if (latestIntent.fillRef !== fillRef) {
+        return outputFailure({
+            error: 'secret_intent_fill_mismatch',
+            outcomeType: 'blocked',
+            message: 'Protected fill was blocked because the approved intent belongs to a different fill target.',
+            reason: `The approved intent belongs to fillRef ${latestIntent.fillRef}, not ${fillRef}.`,
+            fillRef,
+            intentId,
+            ...serializeSecretIntentContext(latestIntent),
+            intentFillRef: latestIntent.fillRef,
+            intentStatus: latestIntent.status,
+            nextAction: 'reobserve',
+        });
+    }
+    if (!(latestIntent.status === 'approved' || latestIntent.status === 'completed')) {
+        return outputFailure({
+            error: 'secret_intent_not_approved',
+            ...(outcomeTypeForNonApprovedIntent(latestIntent.status)
+                ? { outcomeType: outcomeTypeForNonApprovedIntent(latestIntent.status) }
+                : {}),
+            message: messageForNonApprovedIntent(latestIntent.status),
+            reason: reasonForNonApprovedIntent(latestIntent.status),
+            fillRef,
+            intentId,
+            ...serializeSecretIntentContext(latestIntent),
+            intentStatus: latestIntent.status,
+            nextAction: nextActionForNonApprovedIntent(latestIntent.status),
+        });
+    }
+    const cachedSecret = getCachedTransientSecret(session, intentId);
+    if (!cachedSecret) {
+        const missingCacheReason = latestIntent.status === 'completed'
+            ? 'This one-time intent has already delivered its protected payload, but the current session no longer has it cached.'
+            : 'Run poll-intent after approval so AgentBrowse can cache the transient protected values before fill-secret.';
+        const missingCacheNextAction = latestIntent.status === 'completed' ? 'ask-user' : 'poll-intent';
+        const missingCacheMessage = latestIntent.status === 'completed'
+            ? 'Protected fill could not continue because the one-time secret payload is no longer cached in the current session.'
+            : 'Protected fill could not continue because the approved secret payload is not cached in the current session.';
+        return outputFailure({
+            error: 'transient_secret_not_cached',
+            outcomeType: 'blocked',
+            message: missingCacheMessage,
+            reason: missingCacheReason,
+            fillRef,
+            intentId,
+            ...serializeSecretIntentContext(latestIntent),
+            intentStatus: latestIntent.status,
+            nextAction: missingCacheNextAction,
+        });
+    }
+    if (cachedSecret.fillRef !== fillRef ||
+        cachedSecret.storedSecretRef !== latestIntent.storedSecretRef) {
+        deleteCachedTransientSecret(session, intentId);
+        saveSession(session);
+        return outputFailure({
+            error: 'transient_secret_context_mismatch',
+            outcomeType: 'blocked',
+            message: 'Protected fill was blocked because the cached transient secret no longer matches this approved intent.',
+            reason: 'The cached transient payload belongs to a different fill target or stored secret reference.',
+            fillRef,
+            intentId,
+            ...serializeSecretIntentContext(latestIntent),
+            intentStatus: latestIntent.status,
+            nextAction: 'poll-intent',
+        });
+    }
+    let browser = null;
+    try {
+        browser = await connectPlaywright(session.cdpUrl);
+    }
+    catch (error) {
+        deleteCachedTransientSecret(session, intentId);
+        saveSession(session);
+        return outputFailure({
+            error: 'browser_connection_failed',
+            message: 'Protected fill could not connect to the browser.',
+            fillRef,
+            intentId,
+            ...serializeSecretIntentContext(latestIntent),
+            reason: error instanceof Error ? error.message : String(error),
+        });
+    }
+    const connectedBrowser = browser;
+    let finalResult = null;
+    try {
+        const page = await resolvePageByRef(connectedBrowser, session, fillableForm.pageRef);
+        const syncedPage = await syncSessionPage(session, fillableForm.pageRef, page);
+        const observedHost = tryResolveCatalogHost(syncedPage.url);
+        const contextMismatchReasons = [];
+        if (latestIntent.host && observedHost && latestIntent.host !== observedHost) {
+            contextMismatchReasons.push('host');
+        }
+        if (latestIntent.scopeRef && latestIntent.scopeRef !== fillableForm.scopeRef) {
+            contextMismatchReasons.push('scope');
+        }
+        if (contextMismatchReasons.length > 0) {
+            const completedIntent = completeIntent(session, intentId);
+            finalResult = {
+                success: false,
+                payload: {
+                    error: 'secret_intent_context_mismatch',
+                    outcomeType: 'blocked',
+                    message: 'Protected fill was blocked because the page or protected surface no longer matches the approved intent context.',
+                    reason: 'The current page host or protected surface no longer matches the context that was approved for this intent.',
+                    fillRef,
+                    intentId,
+                    ...serializeSecretIntentContext(completedIntent),
+                    intentStatus: completedIntent.status,
+                    nextAction: 'reobserve',
+                    intentReusable: false,
+                    mismatchReasons: contextMismatchReasons,
+                    ...(latestIntent.host ? { expectedHost: latestIntent.host } : {}),
+                    ...(observedHost ? { observedHost } : {}),
+                    ...(latestIntent.scopeRef ? { expectedScopeRef: latestIntent.scopeRef } : {}),
+                    ...(fillableForm.scopeRef ? { observedScopeRef: fillableForm.scopeRef } : {}),
+                },
+            };
+        }
+        else {
+            const protectedValues = { ...cachedSecret.values };
+            const storedSecretCandidate = fillableForm.storedSecretCandidates.find((candidate) => candidate.storedSecretRef === latestIntent.storedSecretRef);
+            const executableForm = restrictFormToCandidateFields(fillableForm, storedSecretCandidate);
+            try {
+                const execution = await executeProtectedFill({
+                    session,
+                    page,
+                    fillableForm: executableForm,
+                    protectedValues,
+                    fieldPolicies: storedSecretCandidate?.fieldPolicies,
+                });
+                if (execution.kind === 'success') {
+                    const completedIntent = completeIntent(session, intentId);
+                    activateProtectedExposure(session, fillableForm, intentId, 'protected_fill_success');
+                    finalResult = {
+                        success: true,
+                        payload: {
+                            fillRef,
+                            intentId,
+                            ...serializeSecretIntentContext(completedIntent),
+                            filledFields: execution.filledFields,
+                            intentStatus: completedIntent.status,
+                            message: 'Protected fill completed successfully.',
+                            reason: 'AgentBrowse filled the protected fields using the one-time secret payload.',
+                        },
+                    };
+                }
+                else if (execution.kind === 'binding_stale') {
+                    const completedIntent = completeIntent(session, intentId);
+                    activateProtectedExposure(session, fillableForm, intentId, 'protected_fill_binding_stale');
+                    finalResult = {
+                        success: false,
+                        payload: {
+                            error: 'secret_fill_binding_stale',
+                            outcomeType: 'binding_stale',
+                            message: 'Protected fill was blocked because the stored field bindings are no longer valid on the page.',
+                            fillRef,
+                            intentId,
+                            ...serializeSecretIntentContext(completedIntent),
+                            intentStatus: completedIntent.status,
+                            nextAction: 'reobserve',
+                            targetRef: execution.targetRef,
+                            fieldKeys: execution.fieldKeys,
+                            reason: execution.reason,
+                            attempts: execution.attempts,
+                        },
+                    };
+                }
+                else if (execution.kind === 'validation_failed') {
+                    const completedIntent = completeIntent(session, intentId);
+                    activateProtectedExposure(session, fillableForm, intentId, 'protected_fill_validation_failed');
+                    finalResult = {
+                        success: false,
+                        payload: {
+                            error: 'secret_validation_failed',
+                            outcomeType: 'blocked',
+                            message: 'Protected fill stopped because the stored data did not pass client-side validation.',
+                            reason: 'Protected execution reported client-side validation errors for one or more filled fields.',
+                            fillRef,
+                            intentId,
+                            ...serializeSecretIntentContext(completedIntent),
+                            intentStatus: completedIntent.status,
+                            executionResult: 'validation_failed',
+                            nextAction: 'ask-user',
+                            manualOverrideAllowed: true,
+                            filledFields: execution.filledFields,
+                            fieldErrors: execution.fieldErrors,
+                        },
+                    };
+                }
+                else {
+                    const completedIntent = completeIntent(session, intentId);
+                    activateProtectedExposure(session, fillableForm, intentId, 'protected_fill_unexpected_error');
+                    finalResult = {
+                        success: false,
+                        payload: {
+                            error: 'protected_fill_execution_failed',
+                            outcomeType: 'blocked',
+                            message: 'Protected fill failed during protected execution, so this approved intent must not be reused.',
+                            fillRef,
+                            intentId,
+                            ...serializeSecretIntentContext(completedIntent),
+                            intentStatus: completedIntent.status,
+                            nextAction: 'ask-user',
+                            reason: execution.reason,
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                const completedIntent = completeIntent(session, intentId);
+                activateProtectedExposure(session, fillableForm, intentId, 'protected_fill_unexpected_error');
+                finalResult = {
+                    success: false,
+                    payload: {
+                        error: 'protected_fill_execution_failed',
+                        outcomeType: 'blocked',
+                        message: 'Protected fill failed during protected execution, so this approved intent must not be reused.',
+                        fillRef,
+                        intentId,
+                        ...serializeSecretIntentContext(completedIntent),
+                        intentStatus: completedIntent.status,
+                        nextAction: 'ask-user',
+                        reason: error instanceof Error ? error.message : String(error),
+                    },
+                };
+            }
+        }
+    }
+    finally {
+        deleteCachedTransientSecret(session, intentId);
+        saveSession(session);
+        if (browser) {
+            disconnectPlaywright(browser);
+        }
+    }
+    if (!finalResult) {
+        return outputFailure({
+            error: 'protected_fill_execution_failed',
+            outcomeType: 'blocked',
+            message: 'Protected fill did not produce a final result.',
+            reason: 'Protected execution finished without returning a terminal success or failure payload.',
+            fillRef,
+            intentId,
+            ...serializeSecretIntentContext(latestIntent),
+        });
+    }
+    if (!finalResult.success) {
+        return outputFailure(finalResult.payload);
+    }
+    return outputJSON({
+        success: true,
+        ...finalResult.payload,
+    });
+}

package/dist/commands/get-secrets-catalog.d.ts

@@ -0,0 +1,6 @@
+/**
+ * browse get-secrets-catalog [url] — Refresh stored-secret catalog metadata for a host.
+ */
+import type { BrowseSession } from '../session.js';
+export declare function getSecretsCatalog(session: BrowseSession, urlOrHost?: string): Promise<void>;
+//# sourceMappingURL=get-secrets-catalog.d.ts.map

package/dist/commands/get-secrets-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-secrets-catalog.d.ts","sourceRoot":"","sources":["../../src/commands/get-secrets-catalog.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAKnD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBjG"}

package/dist/commands/get-secrets-catalog.js

@@ -0,0 +1,23 @@
+/**
+ * browse get-secrets-catalog [url] — Refresh stored-secret catalog metadata for a host.
+ */
+import { saveSession } from '../session.js';
+import { outputContractFailure, outputJSON } from '../output.js';
+import { getCurrentSessionPageUrl, syncSecretCatalogForUrl } from '../secrets/catalog-sync.js';
+export async function getSecretsCatalog(session, urlOrHost) {
+    const syncInput = urlOrHost ?? getCurrentSessionPageUrl(session);
+    if (!syncInput) {
+        return outputContractFailure({
+            error: 'secret_sync_missing_url',
+            outcomeType: 'blocked',
+            message: 'Stored-secret sync could not start because there is no current URL.',
+            reason: 'Provide a URL explicitly or create page context first by navigating or observing.',
+        });
+    }
+    const snapshot = await syncSecretCatalogForUrl(session, syncInput);
+    saveSession(session);
+    outputJSON({
+        success: true,
+        ...snapshot,
+    });
+}

package/dist/commands/launch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"launch.d.ts","sourceRoot":"","sources":["../../src/commands/launch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAkBH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,wBAAsB,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQjF"}
+{"version":3,"file":"launch.d.ts","sourceRoot":"","sources":["../../src/commands/launch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAsBH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,wBAAsB,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQjF"}

package/dist/commands/launch.js

@@ -7,8 +7,10 @@ import { ensureProfile } from '../solver/profile-manager.js';
 import { launchSolver } from '../solver/browser-launcher.js';
 import { saveSession } from '../session.js';
 import { findChromePid } from '../stagehand.js';
-import { outputJSON, outputError } from '../output.js';
+import { outputContractFailure, outputJSON } from '../output.js';
 import { applyAgentpayGatewayEnv, tryResolveAgentpayGatewayConfig } from '../agentpay-gateway.js';
+import { connectPlaywright, disconnectPlaywright, syncLaunchPage } from '../playwright-runtime.js';
+import { summarizeSecretCatalog, syncSecretCatalogForUrl } from '../secrets/catalog-sync.js';
 const CDP_PORT = 9222;
 const DEFAULT_PROFILE = 'default';
 const COMPACT_WINDOW = {
@@ -50,6 +52,8 @@ async function killChromeOnPort(port) {
 }
 async function launchManaged(url, profileName, headless, compact) {
     let session;
+    let browser = null;
+    let secretCatalogSummary;
     try {
         const profile = ensureProfile(profileName);
         const config = readConfig();
@@ -72,10 +76,15 @@ async function launchManaged(url, profileName, headless, compact) {
         });
     }
     catch (err) {
-        outputError(`Failed to launch browser: ${formatUnknownError(err)}`);
+        outputContractFailure({
+            error: 'browser_launch_failed',
+            outcomeType: 'blocked',
+            message: 'Browser launch failed.',
+            reason: formatUnknownError(err),
+        });
     }
     const chromePid = findChromePid(CDP_PORT) ?? process.pid;
-    saveSession({
+    const persistedSession = {
         cdpUrl: session.cdpUrl,
         pid: chromePid,
         port: CDP_PORT,
@@ -84,10 +93,34 @@ async function launchManaged(url, profileName, headless, compact) {
         capabilities: {
             captchaSolve: true,
         },
-    });
-    const currentUrl = session.page.url();
-    const title = await session.page.title();
-    await session.disconnect();
+    };
+    saveSession(persistedSession);
+    let currentUrl = session.page.url();
+    let title = await session.page.title().catch(() => '');
+    try {
+        browser = await connectPlaywright(session.cdpUrl);
+        const syncedPage = await syncLaunchPage(persistedSession, browser, {
+            requestedUrl: url,
+            fallbackUrl: currentUrl,
+            fallbackTitle: title,
+        });
+        currentUrl = syncedPage.url;
+        title = syncedPage.title;
+    }
+    catch {
+        // Preserve the successful launch and fall back to the launcher snapshot.
+    }
+    finally {
+        if (browser) {
+            disconnectPlaywright(browser);
+        }
+        await session.disconnect();
+    }
+    if (url) {
+        const snapshot = await syncSecretCatalogForUrl(persistedSession, currentUrl || url);
+        secretCatalogSummary = summarizeSecretCatalog(snapshot);
+    }
+    saveSession(persistedSession);
     outputJSON({
         success: true,
         runtime: 'managed',
@@ -96,6 +129,7 @@ async function launchManaged(url, profileName, headless, compact) {
         cdpUrl: session.cdpUrl,
         url: currentUrl,
         title,
+        secretCatalog: secretCatalogSummary,
     });
 }
 function getPidsOnPort(port) {

package/dist/commands/navigate.d.ts

@@ -1,5 +1,6 @@
 /**
  * browse navigate <url> — Navigate the current tab to a URL.
  */
-export declare function navigate(cdpUrl: string, targetUrl: string): Promise<void>;
+import type { BrowseSession } from '../session.js';
+export declare function navigate(session: BrowseSession, targetUrl: string): Promise<void>;
 //# sourceMappingURL=navigate.d.ts.map

package/dist/commands/navigate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigate.d.ts","sourceRoot":"","sources":["../../src/commands/navigate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB/E"}
+{"version":3,"file":"navigate.d.ts","sourceRoot":"","sources":["../../src/commands/navigate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAiBnD,wBAAsB,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyDvF"}

package/dist/commands/navigate.js

@@ -1,26 +1,63 @@
 /**
  * browse navigate <url> — Navigate the current tab to a URL.
  */
-import { connectStagehand, getPageInfo } from '../stagehand.js';
-import { outputJSON, outputError, info } from '../output.js';
-export async function navigate(cdpUrl, targetUrl) {
-    let stagehand;
+import { clearProtectedExposure } from '../runtime-state.js';
+import { saveSession } from '../session.js';
+import { outputContractFailure, outputJSON, info } from '../output.js';
+import { summarizeSecretCatalog, syncSecretCatalogForUrl, tryResolveCatalogHost, } from '../secrets/catalog-sync.js';
+import { connectPlaywright, disconnectPlaywright, listPages, resolvePageByRef, syncSessionPage, } from '../playwright-runtime.js';
+export async function navigate(session, targetUrl) {
+    let browser = null;
+    let failureMessage = null;
+    let secretCatalogSummary;
     try {
-        stagehand = await connectStagehand(cdpUrl);
+        browser = await connectPlaywright(session.cdpUrl);
     }
     catch (err) {
-        outputError(`Failed to connect to browser: ${err instanceof Error ? err.message : String(err)}`);
+        return outputContractFailure({
+            error: 'browser_connection_failed',
+            outcomeType: 'blocked',
+            message: 'Navigation could not start because AgentBrowse failed to connect to the browser.',
+            reason: err instanceof Error ? err.message : String(err),
+        });
     }
     try {
-        const page = stagehand.context.pages()[0];
+        const pageRef = session.runtime?.currentPageRef ?? 'p0';
+        const previousUrl = session.runtime?.pages?.[pageRef]?.url;
+        const previousHost = tryResolveCatalogHost(previousUrl);
+        const pages = listPages(browser);
+        const page = session.runtime?.pages[pageRef] || pages.length > 1
+            ? await resolvePageByRef(browser, session, pageRef)
+            : pages[0];
+        if (!page) {
+            throw new Error('no_open_pages');
+        }
         await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
+        const { url, title } = await syncSessionPage(session, pageRef, page);
+        clearProtectedExposure(session, pageRef);
+        const nextHost = tryResolveCatalogHost(url);
+        if (nextHost && nextHost !== previousHost) {
+            const snapshot = await syncSecretCatalogForUrl(session, url);
+            secretCatalogSummary = summarizeSecretCatalog(snapshot);
+        }
+        saveSession(session);
         info(`Navigated to: ${targetUrl}`);
+        outputJSON({ success: true, pageRef, url, title, secretCatalog: secretCatalogSummary });
     }
     catch (err) {
-        await stagehand.close();
-        outputError(`Navigation failed: ${err instanceof Error ? err.message : String(err)}`);
+        failureMessage = `Navigation failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    finally {
+        if (browser) {
+            disconnectPlaywright(browser);
+        }
+    }
+    if (failureMessage) {
+        outputContractFailure({
+            error: 'navigation_failed',
+            outcomeType: 'blocked',
+            message: 'Navigation failed.',
+            reason: failureMessage.replace(/^Navigation failed:\s*/, ''),
+        });
     }
-    const { url, title } = await getPageInfo(stagehand);
-    await stagehand.close();
-    outputJSON({ success: true, url, title });
 }