pi-agent-browser-native 0.8.2 → 0.9.0

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output.js

@@ -15,7 +15,7 @@ import { buildToolPresentation } from "../../results/presentation.js";
 import { compactLargePresentationOutput } from "../../results/presentation/large-output.js";
 import { extractEnvelopeErrorText, getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { detectConfirmationRequired } from "../../results/confirmation.js";
-import { omitUpstreamLifecycle } from "../../results/presentation/common.js";
+import { extractAgentBrowserLifecycle, omitUpstreamLifecycle } from "../../results/presentation/common.js";
 import { getClipboardWritePayloadCandidates, redactClipboardPermissionEcho, redactClipboardPermissionErrorValue } from "../../results/presentation/errors.js";
 import { shouldCaptureSemanticActionNavigationSummary } from "../../results/presentation/semantic-action.js";
 import { buildPageTransitionRefSnapshotInvalidation, commandExplicitlyTargetsAboutBlank, getCommandRefSnapshotInvalidation, deriveSessionTabTarget, extractLatestRefSnapshotStateFromBatchResults, extractRefSnapshotFromData, extractSessionTabTargetFromBatchResults, extractSessionTabTargetFromCommandData, isAboutBlankSessionTabTarget, normalizeSessionTabTarget, } from "../../session-page-state.js";
@@ -23,10 +23,10 @@ import { isRecord } from "../../parsing.js";
 import { buildReadConfirmationNextActions, nextReadConfirmation } from "../../read-confirmation.js";
 import { pruneOwnedManagedSessionRestoreSnapshots } from "../../managed-session-restore.js";
 import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
-import { createFreshSessionName, extractUpstreamCommandTokens, resolveManagedSessionState } from "../../runtime.js";
+import { createFreshSessionName, extractUpstreamCommandTokens, redactInvocationArgs, resolveManagedSessionState } from "../../runtime.js";
 import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
 import { closeManagedSession, inspectManagedSessionDaemon } from "./managed-session-daemon-policy.js";
-import { applyOpenResultTabCorrection, buildAboutBlankRecoveryHint, buildAboutBlankWarning, buildElectronPostCommandHealthDiagnostic, buildElectronRefFreshnessDiagnostic, buildElectronSessionMismatch, buildManagedSessionOutcome, collectOpenResultTabCorrection, collectSessionTabSelection, collectSessionTabTarget, commandChoosesSessionTabTarget, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, formatElectronPostCommandHealthText, formatElectronSessionMismatchText, getSessionContextKey, getStaleRefArgs, mergeNavigationSummaryIntoData, runSessionCommandData, shouldCaptureNavigationSummary, shouldCorrectSessionTabAfterCommand, shouldInspectElectronPostCommandHealth, updateTraceOwnerState, } from "./session-state.js";
+import { applyOpenResultTabCorrection, applyBrowserRunStatePatch, buildAboutBlankRecoveryHint, buildAboutBlankWarning, buildElectronPostCommandHealthDiagnostic, buildElectronRefFreshnessDiagnostic, buildElectronSessionMismatch, buildManagedSessionOutcome, collectOpenResultTabCorrection, collectSessionTabSelection, collectSessionTabTarget, commandChoosesSessionTabTarget, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, formatElectronPostCommandHealthText, formatElectronSessionMismatchText, getSessionContextKey, getStaleRefArgs, mergeNavigationSummaryIntoData, runSessionCommandData, shouldCaptureNavigationSummary, shouldCorrectSessionTabAfterCommand, shouldInspectElectronPostCommandHealth, updateTraceOwnerState, } from "./session-state.js";
 import { collectClickDispatchDiagnostic } from "./click-dispatch.js";
 import { buildScrollNoopDiagnostic, collectComboboxFocusDiagnostic, collectElectronBroadGetTextScopeDiagnostics, collectElectronHandoff, collectFillVerificationDiagnostic, collectNavigationSummary, collectOverlayBlockerDiagnostic, collectQaAttachedTarget, collectSnapshotOverlayBlockerDiagnostic, collectRecordingDependencyWarning, collectScrollPositionSnapshot, collectSelectorTextVisibilityDiagnostics, collectTimeoutPartialProgress, sleepMs, formatQaAttachedTargetText, getArtifactCleanupGuidance, getEvalResultWarning, getEvalStdinHint, getSourceLookupElectronContext, } from "./diagnostics.js";
 import { repairScreenshotData } from "./prepare.js";
@@ -617,7 +617,7 @@ export async function processBrowserOutput(input) {
             networkRoutesBySession.delete(replacedSessionStateKey ?? replacedManagedSessionName);
             sessionPageState.clearSession(replacedSessionStateKey ?? replacedManagedSessionName);
             const replacedSessionKey = replacedSessionStateKey ?? replacedManagedSessionName;
-            const replacedCloseError = await closeManagedSession({ cwd: priorManagedSessionCwd, headedManagedAutosaveInterval: priorManagedSessionHeadedAutosaveInterval, namespace: priorManagedSessionNamespace, preserveAttachedBrowserSession: state.attachedSessionKeys.has(replacedSessionKey), restoreState: state.managedSessionRestoreState, sessionName: replacedManagedSessionName, timeoutMs: implicitSessionCloseTimeoutMs });
+            const replacedCloseError = await closeManagedSession({ cwd: priorManagedSessionCwd, headedManagedAutosaveInterval: priorManagedSessionHeadedAutosaveInterval, namespace: priorManagedSessionNamespace, preserveAttachedBrowserSession: state.attachedSessionKeys.has(replacedSessionKey), restoreState: state.managedSessionRestoreState, sessionName: replacedManagedSessionName, socketDir: state.ownedManagedSessions.get(replacedSessionKey)?.socketDir, timeoutMs: implicitSessionCloseTimeoutMs });
             if (managedSessionOutcome) {
                 managedSessionOutcome = {
                     ...managedSessionOutcome,
@@ -709,6 +709,30 @@ export async function processBrowserOutput(input) {
         }
         if (plainTextUpgrade && errorText)
             presentationEnvelope = { ...presentationEnvelope, success: false, error: errorText };
+        const resultRetainsPreparedManagedSession = !managedSessionOutcome || (managedSessionOutcome.activeAfter
+            && managedSessionOutcome.attemptedSessionName === managedSessionOutcome.currentSessionName);
+        const resultHeadedManagedAutosaveDisabled = prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled === true
+            && resultRetainsPreparedManagedSession
+            && !(commandClosesSession && succeeded);
+        const resultHeadedManagedAutosaveInterval = resultRetainsPreparedManagedSession && !(commandClosesSession && succeeded)
+            ? prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval
+            : undefined;
+        // Commit native lifecycle facts to the execution state before rendering/export can fail.
+        applyBrowserRunStatePatch(state, { artifactManifest, freshSessionOrdinal, managedSessionActive, managedSessionCompatibilityWorkaround, managedSessionHeadedAutosaveDisabled, managedSessionHeadedAutosaveInterval, managedSessionCwd, managedSessionName, managedSessionNamespace, networkRoutesBySession });
+        state.observedBrowserEffects = {
+            args: prepared.redactedArgs, command: prepared.executionPlan.commandInfo.command, subcommand: prepared.executionPlan.commandInfo.subcommand,
+            sessionName: prepared.executionPlan.sessionName, namespace: prepared.executionPlan.namespace, sessionMode: prepared.sessionMode,
+            usedImplicitSession: prepared.executionPlan.usedImplicitSession, agentBrowserStarted: processResult.agentBrowserStarted,
+            nativeSucceeded: succeeded, managedSessionOutcome, managedSessionCwd: prepared.ownedManagedSessionContext?.cwd ?? managedSessionCwd, compatibilityWorkaround: prepared.compatibilityWorkaround,
+            managedSessionHeadedAutosaveDisabled: resultHeadedManagedAutosaveDisabled, managedSessionHeadedAutosaveInterval: resultHeadedManagedAutosaveInterval,
+            managedSessionRestoreDisabled: state.managedSessionRestoreState.isDisabled(prepared.executionPlan.sessionName, prepared.executionPlan.namespace),
+            closeAllApplied, readConfirmation: readConfirmationEvent ?? prepared.readConfirmation,
+            electron: electronLaunchRecord ? { launch: electronLaunchRecord, cleanup: electronFailedConnectCleanup } : undefined,
+            batchSteps: Array.isArray(presentationEnvelope?.data) ? presentationEnvelope.data.filter(isRecord).map(row => ({
+                command: Array.isArray(row.command) && row.command.every(token => typeof token === "string") ? redactInvocationArgs(row.command) : undefined,
+                success: row.success, lifecycle: extractAgentBrowserLifecycle(row.result),
+            })) : undefined,
+        };
         let presentation = plainTextInspection ? { artifacts: undefined, batchFailure: undefined, batchSteps: undefined, content: [{ type: "text", text: inspectionText ?? "" }], data: undefined, fullOutputPath: undefined, fullOutputPaths: undefined, imagePath: undefined, imagePaths: undefined, savedFile: undefined, savedFilePath: undefined, summary: `${prepared.redactedArgs.join(" ")} completed` } : recordingStopRecovery && !recordingStopRecovery.batch ? recordingStopRecovery.presentation : await buildToolPresentation({ modelVisible: input.modelVisible, args: prepared.redactedProcessArgs, artifactManifest, artifactMaxUpdatedAtMs: Date.now(), artifactMinUpdatedAtMs: input.artifactRunStartedAtMs, artifactRequest: screenshotArtifactRequest, batchArtifactRequests: batchScreenshotArtifactRequests, commandInfo: prepared.executionPlan.commandInfo, compiledSemanticAction: prepared.compiledSemanticAction, cwd: operationCwd, envelope: presentationEnvelope, errorText, namespace: prepared.executionPlan.namespace, networkRouteDiagnostics, networkRoutes: activeNetworkRoutes, persistentArtifactStore, previousRecordingContactSheetPath: sessionStateKey ? state.activeRecordingReservations?.get(sessionStateKey)?.contactSheetPath : undefined, piCleanupOwnership: sessionStateKey && (state.ownedManagedSessions.has(sessionStateKey) || prepared.executionPlan.managedSessionName !== undefined) ? "wrapper-managed" : "caller-owned", sessionName: prepared.executionPlan.sessionName });
         if (recordingStopRecovery)
             presentation = mergeRecordingRecoveryPresentation(presentation, recordingStopRecovery);
@@ -794,13 +818,14 @@ export async function processBrowserOutput(input) {
             presentation.failureCategory = "qa-failure";
             presentation.summary = qaPreset.summary;
             const compactText = buildQaCompactFailureText({
-                batchStepCount: presentation.batchSteps?.length ?? prepared.compiledQaPreset.steps.length,
-                checks: prepared.compiledQaPreset.checks,
+                causalError: presentation.batchFailure?.failedStep.text,
+                executedStepCount: presentation.batchSteps?.length,
                 page: extractQaPageContext({
                     attachedTarget: qaAttachedTarget,
                     batchData: presentationEnvelope?.data,
                     compiled: prepared.compiledQaPreset,
                 }),
+                plannedStepCount: prepared.compiledQaPreset.steps.length,
                 qaPreset,
             });
             const nonTextContent = presentation.content.filter((item) => item.type !== "text");
@@ -829,7 +854,12 @@ export async function processBrowserOutput(input) {
         const qaAttachedBannerText = [qaAttachedTargetText, qaAttachedDiagnosticsText].filter((part) => typeof part === "string" && part.length > 0).join("\n");
         const skipAttachedTargetBanner = qaPreset?.passed && prepared.compiledQaPreset?.checks.attached;
         if (!skipAttachedTargetBanner && qaAttachedBannerText && presentation.content[0]?.type === "text")
-            presentation.content[0] = { ...presentation.content[0], text: `${qaAttachedBannerText}\n\n${presentation.content[0].text}` };
+            presentation.content[0] = {
+                ...presentation.content[0],
+                text: qaPreset?.passed === false
+                    ? `${presentation.content[0].text}\n\n${qaAttachedBannerText}`
+                    : `${qaAttachedBannerText}\n\n${presentation.content[0].text}`,
+            };
         else if (!skipAttachedTargetBanner && qaAttachedBannerText)
             presentation.content.unshift({ type: "text", text: qaAttachedBannerText });
         if (managedSessionOutcome && managedSessionOutcome.succeeded !== succeeded)
@@ -856,19 +886,24 @@ export async function processBrowserOutput(input) {
         currentRefSnapshot = finalRecoveryState.currentRefSnapshot;
         currentRefSnapshotInvalidation = finalRecoveryState.currentRefSnapshotInvalidation;
         const authoritativePageState = sessionStateKey ? sessionPageState.get(sessionStateKey) : undefined;
+        const newSnapshot = authoritativePageState?.refSnapshot && authoritativePageState.refSnapshot.snapshotId !== prepared.priorRefSnapshotState?.snapshotId;
+        const needsDaemonReceipt = prepared.ownedManagedSessionContext && !prepared.ownedManagedSessionContext.reuseOnly && !commandClosesSession && processResult.agentBrowserStarted
+            && (succeeded || managedSessionOutcome?.activeAfter === true && managedSessionOutcome.currentSessionName === prepared.executionPlan.sessionName)
+            && !state.managedSessionRestoreState.getDaemonReceipt(prepared.executionPlan.sessionName, prepared.executionPlan.namespace);
+        if (sessionStateKey && prepared.executionPlan.sessionName && (newSnapshot || needsDaemonReceipt)) {
+            const daemon = await inspectManagedSessionDaemon({ cwd, namespace: prepared.executionPlan.namespace, sessionName: prepared.executionPlan.sessionName, signal, includeGeneration: true, headedManagedAutosaveInterval: prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval ?? (prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled ? "0" : undefined), timeoutMs: prepared.processTimeoutMs });
+            if (newSnapshot) {
+                sessionPageState.bindSnapshotGeneration(sessionStateKey, daemon.status === "active" ? daemon.generation : undefined);
+                currentRefSnapshot = sessionPageState.get(sessionStateKey).refSnapshot;
+            }
+            if (prepared.ownedManagedSessionContext && daemon.status === "active" && daemon.generation) {
+                state.managedSessionRestoreState.recordDaemonRestoreKey(prepared.executionPlan.sessionName, prepared.executionPlan.namespace, daemon.restoreKey, daemon.generation);
+            }
+        }
         if (sessionStateKey)
             currentSessionTabTarget = authoritativePageState?.tabTarget;
         const currentSessionTabTargetUnknown = authoritativePageState?.tabTargetUnknown === true ? true : undefined;
-        const resultRetainsPreparedManagedSession = !managedSessionOutcome || (managedSessionOutcome.activeAfter
-            && managedSessionOutcome.attemptedSessionName === managedSessionOutcome.currentSessionName);
-        const resultHeadedManagedAutosaveDisabled = prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled === true
-            && !prepared.ownedManagedSessionContext.reuseOnly
-            && resultRetainsPreparedManagedSession
-            && !(commandClosesSession && succeeded);
-        const resultHeadedManagedAutosaveInterval = resultRetainsPreparedManagedSession && !prepared.ownedManagedSessionContext?.reuseOnly && !(commandClosesSession && succeeded)
-            ? prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval
-            : undefined;
-        const result = buildFinalAgentBrowserToolResult({ modelVisible: input.modelVisible, aboutBlankSessionMismatch, artifactCleanup, categoryDetails: finalRecoveryState.categoryDetails, clickDispatchDiagnostic, commandTokens: prepared.commandTokens, comboboxFocusDiagnostic, compiledNetworkSourceLookup: prepared.compiledNetworkSourceLookup, compiledSemanticAction: prepared.compiledSemanticAction, compatibilityWorkaround: prepared.compatibilityWorkaround, currentRefSnapshot, currentRefSnapshotInvalidation, currentSessionTabTarget, currentSessionTabTargetUnknown, electronBroadGetTextScopeDiagnostics, electronFailedConnectCleanup, electronHandoff, electronLaunch: prepared.electronLaunch, electronLaunchRecord, electronLaunchRecords, electronPostCommandHealth, electronProfileIsolationDetails: input.electronProfileIsolationDetails, electronRefFreshnessDiagnostic, electronSessionMismatch, errorText, evalResultWarning, evalStdinHint, exactSensitiveValues: prepared.exactSensitiveValues, executionPlan: prepared.executionPlan, fillVerificationDiagnostic, headedLaunch: prepared.headedLaunch, inspectionText, preserveAttachedBrowserSession: input.preserveAttachedBrowserSession === true, providerLaunch: prepared.providerLaunch, managedSessionHeadedAutosaveDisabled: resultHeadedManagedAutosaveDisabled || undefined, managedSessionHeadedAutosaveInterval: resultHeadedManagedAutosaveInterval, managedSessionOutcome, managedSessionRestoreDisabled: state.managedSessionRestoreState.isDisabled(prepared.executionPlan.sessionName, prepared.executionPlan.namespace), navigationSummary, networkSourceLookup, noActivePageSnapshotFailure: finalRecoveryState.noActivePageSnapshotFailure, openResultTabCorrection, overlayBlockerDiagnostic, parseError, parseFailureOutput, parseSucceeded, plainTextInspection, presentation, presentationEnvelope, priorSessionTabTarget: prepared.priorSessionTabTarget, processResult, qaAttachedTarget, qaPreset, recordingDependencyWarning, redactedArgs: prepared.redactedArgs, redactedCompiledElectron: prepared.redactedCompiledElectron, redactedCompiledJob: prepared.redactedCompiledJob, redactedCompiledNetworkSourceLookup: prepared.redactedCompiledNetworkSourceLookup, redactedCompiledQaPreset: prepared.redactedCompiledQaPreset, redactedCompiledSemanticAction: prepared.redactedCompiledSemanticAction, redactedCompiledSourceLookup: prepared.redactedCompiledSourceLookup, redactedContent, redactedProcessArgs: prepared.redactedProcessArgs, redactedRecoveryHint: prepared.redactedRecoveryHint, resultArtifactManifest, richInputRecoveryDiagnostic: finalRecoveryState.richInputRecoveryDiagnostic, scrollNoopDiagnostic, selectorTextVisibilityDiagnostics, sessionMode: prepared.sessionMode, sessionTabCorrection, sourceLookup, succeeded, timeoutPartialProgress, unsettledWebMcpMutation, userRequestedJson: prepared.userRequestedJson, visibleRefFallbackDiagnostic: finalRecoveryState.visibleRefFallbackDiagnostic, visibleRefFallbackSessionName: finalRecoveryState.visibleRefFallbackSessionName });
+        const result = buildFinalAgentBrowserToolResult({ modelVisible: input.modelVisible, aboutBlankSessionMismatch, artifactCleanup, categoryDetails: finalRecoveryState.categoryDetails, clickDispatchDiagnostic, commandTokens: prepared.commandTokens, comboboxFocusDiagnostic, compiledNetworkSourceLookup: prepared.compiledNetworkSourceLookup, compiledSemanticAction: prepared.compiledSemanticAction, compatibilityWorkaround: prepared.compatibilityWorkaround, currentRefSnapshot, currentRefSnapshotInvalidation, currentSessionTabTarget, currentSessionTabTargetUnknown, electronBroadGetTextScopeDiagnostics, electronFailedConnectCleanup, electronHandoff, electronLaunch: prepared.electronLaunch, electronLaunchRecord, electronLaunchRecords, electronPostCommandHealth, electronProfileIsolationDetails: input.electronProfileIsolationDetails, electronRefFreshnessDiagnostic, electronSessionMismatch, errorText, evalResultWarning, evalStdinHint, exactSensitiveValues: prepared.exactSensitiveValues, executionPlan: prepared.executionPlan, fillVerificationDiagnostic, headedLaunch: prepared.headedLaunch, inspectionText, preserveAttachedBrowserSession: input.preserveAttachedBrowserSession === true, providerLaunch: prepared.providerLaunch, managedSessionHeadedAutosaveDisabled: !prepared.ownedManagedSessionContext?.reuseOnly && resultHeadedManagedAutosaveDisabled || undefined, managedSessionHeadedAutosaveInterval: prepared.ownedManagedSessionContext?.reuseOnly ? undefined : resultHeadedManagedAutosaveInterval, managedSessionOutcome, managedSessionRestoreDisabled: state.managedSessionRestoreState.isDisabled(prepared.executionPlan.sessionName, prepared.executionPlan.namespace), navigationSummary, networkSourceLookup, noActivePageSnapshotFailure: finalRecoveryState.noActivePageSnapshotFailure, openResultTabCorrection, overlayBlockerDiagnostic, parseError, parseFailureOutput, parseSucceeded, plainTextInspection, presentation, presentationEnvelope, priorSessionTabTarget: prepared.priorSessionTabTarget, processResult, qaAttachedTarget, qaPreset, recordingDependencyWarning, redactedArgs: prepared.redactedArgs, redactedCompiledElectron: prepared.redactedCompiledElectron, redactedCompiledJob: prepared.redactedCompiledJob, redactedCompiledNetworkSourceLookup: prepared.redactedCompiledNetworkSourceLookup, redactedCompiledQaPreset: prepared.redactedCompiledQaPreset, redactedCompiledSemanticAction: prepared.redactedCompiledSemanticAction, redactedCompiledSourceLookup: prepared.redactedCompiledSourceLookup, redactedContent, redactedProcessArgs: prepared.redactedProcessArgs, redactedRecoveryHint: prepared.redactedRecoveryHint, resultArtifactManifest, richInputRecoveryDiagnostic: finalRecoveryState.richInputRecoveryDiagnostic, scrollNoopDiagnostic, selectorTextVisibilityDiagnostics, sessionMode: prepared.sessionMode, sessionTabCorrection, sourceLookup, succeeded, timeoutPartialProgress, unsettledWebMcpMutation, userRequestedJson: prepared.userRequestedJson, visibleRefFallbackDiagnostic: finalRecoveryState.visibleRefFallbackDiagnostic, visibleRefFallbackSessionName: finalRecoveryState.visibleRefFallbackSessionName });
         const resultWithCloseAll = closeAllApplied
             ? { ...result, details: { ...(isRecord(result.details) ? result.details : {}), closeAllApplied: true } }
             : result;

package/dist/extensions/agent-browser/lib/orchestration/electron-host/index.js

@@ -603,7 +603,7 @@ export async function cleanupTrackedElectronHostLaunches(options) {
         const sessionKey = getSessionPageStateKey(record.sessionName, record.namespace) ?? record.sessionName;
         const managedSessionOwner = sessionKey ? options.ownedManagedSessions.get(sessionKey) : undefined;
         const managedSessionCloseError = record.sessionName
-            ? await closeManagedSession({ cwd: options.cwd, headedManagedAutosaveInterval: managedSessionOwner?.headedManagedAutosaveInterval, namespace: record.namespace, preserveAttachedBrowserSession: options.attachedSessionKeys.has(sessionKey ?? record.sessionName), restoreState: options.managedSessionRestoreState, sessionName: record.sessionName, timeoutMs: options.timeoutMs })
+            ? await closeManagedSession({ cwd: options.cwd, headedManagedAutosaveInterval: managedSessionOwner?.headedManagedAutosaveInterval, namespace: record.namespace, preserveAttachedBrowserSession: options.attachedSessionKeys.has(sessionKey ?? record.sessionName), restoreState: options.managedSessionRestoreState, sessionName: record.sessionName, socketDir: managedSessionOwner?.socketDir, timeoutMs: options.timeoutMs })
             : undefined;
         const managedSessionStep = record.sessionName
             ? managedSessionCloseError

package/dist/extensions/agent-browser/lib/orchestration/script-mode.js

@@ -1,18 +1,22 @@
 import { stat } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES, createAgentBrowserScriptCloseArgs, isAgentBrowserScriptSessionName, } from "../input-modes/script.js";
 import { isRecord } from "../parsing.js";
+import { appendBrowserTransition, getBrowserRecord } from "../browser-transcript.js";
 import { redactSensitiveText } from "../runtime.js";
 import { attachInlineImage } from "../results/presentation/artifacts.js";
 import { projectAgentBrowserObservation } from "../results/presentation/content.js";
 import { redactPresentationData } from "../results/presentation/diagnostics.js";
-const SCRIPT_SESSION_ENTRY_TYPE = "agent-browser-script-session";
-// Retire outstanding pre-0.7 isolated-session leases when an old transcript resumes.
-export function getScriptSessionLeasesFromBranch(branch) {
+// The offline converter retains outstanding isolated-session cleanup facts in canonical events.
+export function getScriptSessionLeasesFromBranch(branch, ownerSessionId) {
     const leases = new Map();
     for (const entry of branch) {
-        if (!isRecord(entry) || entry.type !== "custom" || entry.customType !== SCRIPT_SESSION_ENTRY_TYPE || !isRecord(entry.data))
+        const lease = getBrowserRecord(entry)?.event.state.scriptLease;
+        if (!isRecord(lease))
             continue;
-        const { cleanup, closeCommandArgs, launchAttempted, sessionName } = entry.data;
+        if (ownerSessionId !== undefined && lease.ownerSessionId !== ownerSessionId)
+            continue;
+        const { cleanup, closeCommandArgs, launchAttempted, sessionName } = lease;
         if (!isAgentBrowserScriptSessionName(sessionName))
             continue;
         const expected = createAgentBrowserScriptCloseArgs(sessionName);
@@ -20,12 +24,13 @@ export function getScriptSessionLeasesFromBranch(branch) {
             || !Array.isArray(closeCommandArgs) || closeCommandArgs.length !== expected.length
             || !closeCommandArgs.every((token, index) => token === expected[index]))
             continue;
-        leases.set(sessionName, { cleanup, closeCommandArgs: expected, launchAttempted: true, sessionName });
+        leases.set(sessionName, { cleanup, closeCommandArgs: expected, launchAttempted: true, sessionName, ownerSessionId: typeof lease.ownerSessionId === "string" ? lease.ownerSessionId : undefined });
     }
     return leases;
 }
-export function appendScriptSessionLease(pi, sessionName, cleanup) {
-    pi.appendEntry(SCRIPT_SESSION_ENTRY_TYPE, { cleanup, closeCommandArgs: createAgentBrowserScriptCloseArgs(sessionName), launchAttempted: true, sessionName });
+export function appendScriptSessionLease(pi, sessionName, cleanup, ownerSessionId) {
+    appendBrowserTransition(pi, { event: { version: 1, phase: "state", operationId: randomUUID(), toolCallId: "cleanup", commandIndex: 0, isError: cleanup !== "closed",
+            state: { scriptLease: { cleanup, closeCommandArgs: createAgentBrowserScriptCloseArgs(sessionName), launchAttempted: true, sessionName, ownerSessionId } } } });
 }
 export function createBrowserCodeOutput() {
     const images = new Map();

package/dist/extensions/agent-browser/lib/pi-tool-rendering.js

@@ -1,5 +1,4 @@
 import { getKeybindings, Text, truncateToWidth } from "@earendil-works/pi-tui";
-import { BROWSER_RESULT_TOOLS } from "./browser-transcript.js";
 import { compileAgentBrowserElectron } from "./input-modes/electron.js";
 import { compileAgentBrowserQaPreset } from "./input-modes/job.js";
 import { compileAgentBrowserNetworkSourceLookup, compileAgentBrowserSourceLookup } from "./input-modes/lookups.js";
@@ -185,10 +184,10 @@ function formatModelVisibleFailureCategoryNotice(details) {
         : undefined;
     return `Result category: failure${failureCategory ? `; failureCategory: ${failureCategory}` : ""}; Pi tool isError: true.`;
 }
-function agentBrowserToolResultRequestedJson(event) {
-    const details = isRecord(event.details) ? event.details : undefined;
+function agentBrowserToolResultRequestedJson(result, input) {
+    const details = isRecord(result.details) ? result.details : undefined;
     const detailArgs = Array.isArray(details?.args) ? details.args : undefined;
-    const inputArgs = isRecord(event.input) && Array.isArray(event.input.args) ? event.input.args : undefined;
+    const inputArgs = isRecord(input) && Array.isArray(input.args) ? input.args : undefined;
     return detailArgs?.includes("--json") === true || inputArgs?.includes("--json") === true;
 }
 function agentBrowserToolResultHasParseableJsonContent(content) {
@@ -219,26 +218,41 @@ function appendModelVisibleFailureCategoryNotice(content, notice) {
         ? { ...item, text: `${textItem.text}\n\n${notice}` }
         : item);
 }
-export function buildAgentBrowserToolResultPatch(event) {
-    if (!BROWSER_RESULT_TOOLS.has(event.toolName))
-        return undefined;
-    const preservesParseableJson = (event.toolName === "agent_browser_code" || agentBrowserToolResultRequestedJson(event)) && agentBrowserToolResultHasParseableJsonContent(event.content);
-    const notice = preservesParseableJson ? undefined : formatModelVisibleFailureCategoryNotice(event.details);
-    const content = notice ? appendModelVisibleFailureCategoryNotice(event.content, notice) : undefined;
-    const shouldMarkError = isRecord(event.details) && event.details.resultCategory === "failure" && event.isError !== true;
-    if (!shouldMarkError && !content)
-        return undefined;
+export function finalizeAgentBrowserFailure(result, input) {
+    const failed = result.isError === true || (isRecord(result.details) && result.details.resultCategory === "failure");
+    const preservesParseableJson = (isRecord(input) && "code" in input || agentBrowserToolResultRequestedJson(result, input)) && agentBrowserToolResultHasParseableJsonContent(result.content);
+    const notice = preservesParseableJson ? undefined : formatModelVisibleFailureCategoryNotice(result.details);
+    const content = notice ? appendModelVisibleFailureCategoryNotice(result.content, notice) : undefined;
     return {
-        ...(content ? { content } : {}),
-        ...(shouldMarkError ? { isError: true } : {}),
+        ...result,
+        content: content ?? result.content,
+        isError: failed,
     };
 }
 export class AgentBrowserResultComponent {
     expanded = false;
     theme;
     text = new Text("", 0, 0);
+    value;
+    formatKey;
+    setResult(result, options, theme, isError) {
+        const details = isRecord(result.details) ? result.details : undefined;
+        // Theme is a stable proxy in Pi; its resolved colors identify theme/terminal-color changes.
+        const key = [getPrimaryTextContent(result), details?.summary, details?.resultCategory, details?.failureCategory, options.isPartial, isError, theme, theme.colors, theme.fg];
+        if (!this.formatKey || key.some((value, index) => value !== this.formatKey[index])) {
+            this.formatKey = key;
+            this.setState(formatAgentBrowserRenderResult(result, options, theme, isError), options.expanded, theme);
+        }
+        else {
+            this.expanded = options.expanded;
+            this.theme = theme;
+        }
+    }
     setState(value, expanded, theme) {
-        this.text.setText(value);
+        if (value !== this.value) {
+            this.text.setText(value);
+            this.value = value;
+        }
         this.expanded = expanded;
         this.theme = theme;
     }

package/dist/extensions/agent-browser/lib/playbook.js

@@ -12,7 +12,7 @@ export const QUICK_START_GUIDELINES = [
     "Use { args: [\"batch\", \"--bail\"], stdin: \"[[\\\"fill\\\",\\\"@e1\\\",\\\"text\\\"],[\\\"click\\\",\\\"@e2\\\"]]\" } for same-snapshot form fields followed by submit. Split if a fill rerenders later fields. Add native condition waits after navigation-prone actions; a click alone does not prove the destination loaded. Avoid blind mutation retries after timeout.",
     "agent_browser_code takes { code, session?, namespace?, timeoutMs?, outputPath? }. JavaScript globals are fresh for every call; the selected browser persists and is shared with agent_browser. Use await browser({ args, stdin?, timeoutMs? }), inspect result.success, and emit selected JSON instead of whole envelopes. Use emitImage(result.imageObservations[0]) only when image inspection is needed; image handles belong to the current code call. No imports or host filesystem/network/process APIs are exposed.",
     "Example agent_browser_code: { code: 'const result = await browser({args:[\"get\",\"title\"]}); if (!result.success) { emit(result); } else { emit({title:result.data}); }' }. Native batch still avoids extra CLI processes for fixed segments inside code. Explicit session/namespace controls select the browser for this cell without changing the default browser.",
-    "Call agent_browser_tools with no fields for inventory, or { enable: [\"action\", \"qa\", \"electron\", \"source\", \"network\"] } for advanced native tools. It adds agent_browser_action, agent_browser_qa, agent_browser_electron, agent_browser_source, and agent_browser_network_source without disabling other tools. Their specialized instructions appear when activated.",
+    "Call agent_browser_tools with no fields for inventory, or { enable: [\"action\", \"qa\", \"electron\", \"source\", \"network\"] } for advanced native tools. It adds agent_browser_action, agent_browser_qa, agent_browser_electron, agent_browser_source, and agent_browser_network_source without disabling other tools. The browser instructions cover these capabilities; activation reveals their selected tool declarations.",
     "Use read <url> for readable web text; get title/url, get text/html/value/count <selector>, or get attr <selector> <name> for targeted state. For eval --stdin, put JavaScript in stdin and return the desired value. outputPath saves result data and must differ from screenshot/download/recording paths. Use --json only when JSON text is needed.",
     "For artifacts, verify artifactVerification and artifacts before reporting success. A pending recording is not verified output; install ffmpeg before starting and pair start with stop. Native download owns the click and saves Blob/redirect downloads. Close keeps explicitly saved files. Save promptGuard-required paths before close. Screenshot pixels are not browser CSS coordinates: use imageObservations geometry (dimensions, viewport, crop/origin, scroll and DPR) before any visual-coordinate action; full-page and element captures are not current-viewport coordinates, and Pi resizing only maps sent pixels to original image pixels.",
     "Follow model-visible nextActions when present, including identity and stdin, instead of guessing commands. Treat native pending confirmations and unknown mutation outcomes as inspection boundaries. For dense snapshots, inspect Omitted high-value controls before reading a full spill.",
@@ -38,6 +38,13 @@ export const ADVANCED_TOOL_PROMPT_GUIDELINES = {
     ],
 };
 export const WEB_SEARCH_PROMPT_GUIDELINE = "Prefer agent_browser_web_search for current or external web facts and URL discovery over public search-engine forms that can hit anti-bot/CAPTCHA-gated pages. For research before implementation, pass searchType: deep-lite unless webSearch.defaultSearchType already does; omit it for everyday lookups so config/auto wins. Provider rank is not proof of authority: when correctness or version matters, prefer the vendor or project's primary current docs, inspect page-date and version clues, and constrain one follow-up after discovering the official domain (Exa includeDomains; Brave site: in query). Do not count URL aliases as independent sources. Use agent_browser after you have a target URL that needs interaction, screenshots, or DOM inspection.";
+export const WEB_SEARCH_TOOL_PROMPT_GUIDELINES = [
+    WEB_SEARCH_PROMPT_GUIDELINE,
+    "agent_browser_web_search chooses Exa or Brave from configured keys; when both are available, Exa is preferred by default unless webSearch.preferredProvider says otherwise. Use provider only when the user/config calls for a specific provider.",
+    "Use Exa deep only when deep-lite may miss angles, and deep-reasoning only for exhaustive or still-thin research. Do not run parallel agent_browser_web_search calls; make one high-signal query, inspect its results, then at most one follow-up.",
+    "If agent_browser_web_search returns HTTP 429, stop searching and tell the user the API plan/rate limit needs time or a plan change.",
+    "After using agent_browser_web_search, cite result URLs in the final answer when web evidence informed the answer.",
+];
 export const SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
     QUICK_START_GUIDELINES[0],
     QUICK_START_GUIDELINES[3],
@@ -96,7 +103,7 @@ export const WRAPPER_TAB_RECOVERY_BEHAVIOR = [
     "If a known session target unexpectedly reports about:blank, agent_browser best-effort re-selects the prior intended target when it still exists; if recovery fails, it records the observed about:blank target and reports exact recovery guidance instead of treating the prior page as active.",
     "If upstream reports tab_gone, the pinned bound tab is gone; use details.nextActions (tab list / tab new) instead of assuming another tab is yours.",
 ];
-/** Tier A: always-on tool promptGuidelines (keep small; Tier B lives in SHARED_BROWSER_PLAYBOOK_GUIDELINES and docs). */
+/** Concise orientation included alongside the full operating playbook. */
 export const RUNTIME_PROMPT_GUIDELINES = [
     "Use agent_browser for one native command; batch --bail with JSON-array stdin for fixed sequences; agent_browser_code for loops/branches/aggregation. Return to the model at judgment boundaries. Use agent_browser_tools to discover/enable action, qa, electron, source, or network tools.",
     "agent_browser_code runs fresh JavaScript against the persistent browser: await browser({args, stdin?, timeoutMs?}), check result.success, emit(selected JSON), or emitImage(result.imageObservations[0]). No host APIs/imports; globals do not persist. Explicit session/namespace selects this cell's browser without changing the default.",

package/dist/extensions/agent-browser/lib/prompt-policy.js

@@ -1,10 +1,3 @@
-const BROWSER_PROMPT_PATTERNS = [
-    /\b(?:agent[_ -]?browser|browser automation|eval\s+--stdin|screenshot|snapshot|tab\s+list)\b/i,
-    /\b(?:react\s+(?:tree|inspect|renders|suspense)|web\s+vitals|core\s+web\s+vitals|pushstate)\b/i,
-    /\b(?:live\s+docs?|online\s+research|research\s+(?:online|the\s+web)|search\s+(?:online|the\s+web)|web\s+research)\b/i,
-    /\bbrowser\b.*\b(?:automation|click|fill|navigate|open|page|screenshot|site|snapshot|tab|url|visit|web(?:site| page)?)\b/i,
-    /\b(?:browse|click|fill|login|navigate|open|visit)\b.*\b(?:https?:\/\/\S+|page|site|tab|url|web(?:site| page)?)\b/i,
-];
 const LEGACY_BASH_ALLOW_PATTERNS = [
     /\b(?:bash-oriented workflow|bash workflow)\b/i,
     /\b(?:use|via|through|with)\s+bash\b/i,
@@ -206,7 +199,7 @@ export function buildPromptPolicy(prompt) {
         requestedArtifacts: extractPromptRequestedArtifacts(prompt),
     };
 }
-function getMessageText(content) {
+export function getMessageText(content) {
     if (typeof content === "string")
         return content;
     if (!Array.isArray(content))
@@ -220,24 +213,21 @@ function getMessageText(content) {
         .filter((text) => text.length > 0)
         .join("\n");
 }
-export function shouldAppendBrowserSystemPrompt(prompt) {
-    const normalizedPrompt = prompt.trim();
-    if (normalizedPrompt.length === 0) {
-        return false;
-    }
-    return BROWSER_PROMPT_PATTERNS.some((pattern) => pattern.test(normalizedPrompt));
-}
-export function getLatestUserPrompt(branch) {
-    for (let index = branch.length - 1; index >= 0; index -= 1) {
-        const entry = branch[index];
-        if (typeof entry !== "object" || entry === null || !("type" in entry) || entry.type !== "message") {
-            continue;
-        }
-        const message = "message" in entry ? entry.message : undefined;
-        if (typeof message !== "object" || message === null || !("role" in message) || message.role !== "user") {
-            continue;
+/** Raw prompt intent survives compaction/context edits; only restoration walks ancestry. */
+export function getLatestUserMessage(manager) {
+    let id = manager.getLeafId();
+    const seen = new Set();
+    while (id !== null) {
+        if (typeof id !== "string" || seen.has(id))
+            throw new Error("Latest user prompt ancestry is invalid or cyclic.");
+        seen.add(id);
+        const entry = manager.getEntry(id);
+        if (!entry || entry.id !== id || entry.parentId !== null && typeof entry.parentId !== "string") {
+            throw new Error("Latest user prompt ancestry is incomplete.");
         }
-        return getMessageText("content" in message ? message.content : undefined);
+        if (entry.type === "message" && entry.message.role === "user")
+            return entry.message;
+        id = entry.parentId;
     }
-    return "";
+    return undefined;
 }

package/dist/extensions/agent-browser/lib/results/presentation/content.js

@@ -2,6 +2,7 @@ import { isRecord } from "../../parsing.js";
 import { redactSensitiveValue } from "../../runtime.js";
 import { omitUpstreamLifecycle } from "./common.js";
 import { redactTimeoutPartialProgress } from "../../orchestration/browser-run/diagnostics.js";
+export const OBSERVATION_INLINE_MAX_CHARS = 16_000;
 export function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
@@ -40,6 +41,9 @@ export function projectAgentBrowserObservation(details, succeeded) {
     }
     if (details.inspection === true && details.data === undefined && typeof details.stdout === "string")
         observation.data = details.stdout;
+    // Identical error/summary strings double-count large failure text against the observation bound; keep error.
+    if (typeof observation.error === "string" && observation.error === observation.summary)
+        observation.summary = undefined;
     if (isRecord(observation.data))
         observation.data = omitUpstreamLifecycle(observation.data);
     if (Array.isArray(details.batchSteps)) {

package/dist/extensions/agent-browser/lib/results/presentation/large-output.js

@@ -2,7 +2,7 @@ import { writePersistentSessionArtifactFile, writeSecureTempFile, } from "../../
 import { buildEvictedSessionArtifactEntries } from "../artifact-manifest.js";
 import { countLines, truncateText } from "../text.js";
 import { applyArtifactManifest } from "./artifacts.js";
-import { getPresentationText, projectAgentBrowserObservation } from "./content.js";
+import { getPresentationText, projectAgentBrowserObservation, OBSERVATION_INLINE_MAX_CHARS } from "./content.js";
 import { redactModelFacingText, stringifyModelFacing } from "./common.js";
 const LARGE_OUTPUT_INLINE_MAX_CHARS = 8_000;
 const LARGE_OUTPUT_INLINE_MAX_LINES = 120;
@@ -88,20 +88,22 @@ function buildSpillArtifactEntries(options) {
         ...buildEvictedSessionArtifactEntries(options.evictedArtifacts, nowMs),
     ];
 }
-export const OBSERVATION_INLINE_MAX_CHARS = 16_000;
+export { OBSERVATION_INLINE_MAX_CHARS } from "./content.js";
 /** Bound the final model-visible result, after recovery/diagnostic assembly. Never truncate executable actions. */
 export async function renderAgentBrowserObservation(options) {
     const observation = projectAgentBrowserObservation(options.details, options.succeeded);
+    let structuredContent = observation;
     const images = options.content.filter(part => part.type === "image");
     const prose = options.content.filter(part => part.type === "text").map(part => part.text).join("\n\n");
     const { data: _data, error: _error, summary: _summary, ...metadata } = observation;
     let text = options.json ? JSON.stringify(observation, null, 2) : `${prose}\n\nObservation: ${JSON.stringify(metadata)}`;
     let artifactManifest = options.details.artifactManifest;
-    if (text.length > OBSERVATION_INLINE_MAX_CHARS) {
+    if (text.length > OBSERVATION_INLINE_MAX_CHARS || JSON.stringify(observation).length > OBSERVATION_INLINE_MAX_CHARS) {
         let spill;
         let spillError;
         try {
-            spill = await writeLargeOutputSpillFile({ data: { ...observation, ...(!options.json ? { text: prose } : {}) }, persistentArtifactStore: options.persistentArtifactStore, text });
+            const write = () => writeLargeOutputSpillFile({ data: { ...observation, ...(!options.json ? { text: prose } : {}) }, persistentArtifactStore: options.persistentArtifactStore, text });
+            spill = await (options.withArtifactWrite ? options.withArtifactWrite(write) : write());
             artifactManifest = applyArtifactManifest({ content: [], summary: "" }, artifactManifest, buildSpillArtifactEntries({
                 commandInfo: { command: typeof options.details.command === "string" ? options.details.command : undefined },
                 evictedArtifacts: spill.evictedArtifacts, path: spill.path, storageScope: spill.storageScope,
@@ -113,7 +115,8 @@ export async function renderAgentBrowserObservation(options) {
         const compact = {
             success: options.succeeded, resultCategory: observation.resultCategory,
             failureCategory: observation.failureCategory, successCategory: observation.successCategory,
-            summary: typeof observation.summary === "string" ? truncateText(observation.summary, 700) : undefined,
+            summary: typeof observation.summary === "string" ? truncateText(observation.summary, 700)
+                : typeof observation.error === "string" ? truncateText(observation.error, 700) : undefined,
             compacted: true,
             ...(spill ? { observationPath: spill.path, retrieve: "Read observationPath for the complete redacted observation, including exact recovery actions and requested data." }
                 : { observationUnavailable: truncateText(redactModelFacingText(spillError ?? "Spill could not be written; request a smaller result."), 1_000) }),
@@ -122,11 +125,16 @@ export async function renderAgentBrowserObservation(options) {
             if (observation[key] !== undefined && JSON.stringify({ ...compact, [key]: observation[key] }, null, 2).length <= OBSERVATION_INLINE_MAX_CHARS - 500)
                 compact[key] = observation[key];
         }
-        text = JSON.stringify(compact, null, 2);
-        if (!options.json)
-            text = `Browser observation compacted.\n${text}`;
+        structuredContent = compact;
+        if (options.preserveContent)
+            text = prose;
+        else {
+            text = JSON.stringify(compact, null, 2);
+            if (!options.json)
+                text = `Browser observation compacted.\n${text}`;
+        }
     }
-    return { content: [{ type: "text", text }, ...images], artifactManifest };
+    return { content: [{ type: "text", text }, ...images], artifactManifest, structuredContent: JSON.parse(JSON.stringify(structuredContent)) };
 }
 export async function compactLargePresentationOutput(options) {
     const text = getPresentationText(options.presentation);