rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{composition__electronScenario-CEZnVrAL.js → composition__electronScenario-BVF0qStH.js}

@@ -1,21 +1,31 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { electronActiveObservationResultSchema, electronActiveTimelineEventSchema, err, init_electronActiveObservation, init_result, ok } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
-import { AnalysisError, init_analysisErrorBase } from "./errorSchemas-CTRmvMl3.js";
-import { ProviderAdapterError, init_providerAdapterError } from "./providerAdapterError-DAjhICdr.js";
-import { BrowserObservationError, init_browserObservationError } from "./browserObservationError-Dx6xRTjb.js";
-import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, init_ProcessOwnership, init_ProcessOwnershipObservation, init_ProcessOwnershipProcessTree, observeOwnedProcessLineage, prepareProcessOwnershipInspection, selectCapturedProcessGroupIds, systemProcessOwnershipHost, verifyNoTokenOwnedProcesses } from "./ProcessOwnership-DXC5-UWt.js";
+import { electronActiveObservationResultSchema, electronActiveTimelineEventSchema, err, init_electronActiveObservation, init_result, ok } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { AnalysisCancelledError, AnalysisError, AnalysisUnsupportedTargetError, init_analysisErrorBase, init_analysisErrorCore } from "./errorSchemas-Ixz_q7qt.js";
+import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-DMwm42bk.js";
+import { AnalysisCleanupLease, AnalysisCleanupLeaseGroup, init_AnalysisCleanupLease } from "./AnalysisCleanupLease-CWfTGYKd.js";
+import { assertArtifactReadActive, bindArtifactFileCleanup, init_ArtifactFileOperation } from "./ArtifactFileOperation-Dg4BcoEM.js";
+import { ArtifactResourceScope, init_ArtifactResourceScope } from "./ArtifactResourceScope-CokZGcII.js";
+import { BrowserObservationError, ProviderAdapterError, init_browserObservationError, init_providerAdapterError } from "./cliResultOutput-10sd6xGx.js";
+import { analysisErrorWithCleanupFailure, init_analysisErrorCleanup } from "./analysisErrorCleanup-COdAmDsb.js";
+import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-BhsJyAhk.js";
+import { init_ProcessOwnershipObservation, init_ProcessOwnershipProcessTree, observeOwnedProcessLineage, prepareProcessOwnershipInspection, selectCapturedProcessGroupIds, systemProcessOwnershipHost } from "./ProcessOwnershipObservation-C006iCtZ.js";
+import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, init_ProcessOwnership, verifyNoTokenOwnedProcesses } from "./ProcessOwnership-CtrNr6ee.js";
 import { PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY, init_providerIdentities } from "./providerIdentities-Ao1XTvwx.js";
+import { electronFuseFailure, init_ElectronFuseFailures, init_ElectronFusePath, init_ElectronFuseReader, readElectronFuseImage, resolveElectronFuseTarget } from "./ElectronFuseFailures-DsjXR7Xp.js";
 import { z } from "zod";
+import { basename, dirname } from "node:path";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 
 //#region dist/browser/PlaywrightElectronActiveActions.js
-var OPERATION$1, hookSnapshotSchema, metricSchema, windowMetadataSchema, runElectronActions, runAction, actionWindowIndex, waitForWindow, emitDeepLink, readApplicationState, runWithExecutionLimits, safeActionErrorMessage;
+var OPERATION$2, CANCELLED_STATE_READ_TIMEOUT_MS, GRACE_EXPIRED, hookSnapshotSchema, metricSchema, windowMetadataSchema, runElectronActions, runAction, actionWindowIndex, waitForWindow, emitDeepLink, readApplicationState, readFinalApplicationState, runWithExecutionLimits, safeActionErrorMessage;
 function init_PlaywrightElectronActiveActions() {
 	return (init_PlaywrightElectronActiveActions = __esmMin((() => {
 		init_browserObservationError();
 		init_electronActiveObservation();
-		OPERATION$1 = "capture_electron_scenario";
+		OPERATION$2 = "capture_electron_scenario";
+		CANCELLED_STATE_READ_TIMEOUT_MS = 5e3;
+		GRACE_EXPIRED = Symbol("cancellation grace expired");
 		hookSnapshotSchema = z.strictObject({
 			events: z.array(electronActiveTimelineEventSchema),
 			retention_budget_bytes: z.number().int().min(0),
@@ -59,13 +69,13 @@ function init_PlaywrightElectronActiveActions() {
 				const windowIndex = actionWindowIndex(action);
 				let selectedWindow;
 				try {
-					if (options.signal?.aborted === true) throw new BrowserObservationError(OPERATION$1, "cancelled");
+					if (options.signal?.aborted === true) throw new BrowserObservationError(OPERATION$2, "cancelled");
 					selectedWindow = windowIndex === null ? undefined : await waitForWindow({
 						application,
 						windowIndex,
 						signal: options.signal
 					});
-					if ((action.kind === "click" || action.kind === "renderer-reload" || action.kind === "renderer-crash") && selectedWindow === undefined) throw new BrowserObservationError(OPERATION$1, "window_not_found");
+					if ((action.kind === "click" || action.kind === "renderer-reload" || action.kind === "renderer-crash") && selectedWindow === undefined) throw new BrowserObservationError(OPERATION$2, "window_not_found");
 					await runAction({
 						application,
 						action,
@@ -99,16 +109,16 @@ function init_PlaywrightElectronActiveActions() {
 		runAction = async ({ application, action, selectedWindow, options }) => {
 			switch (action.kind) {
 				case "click":
-					if (selectedWindow === undefined) throw new BrowserObservationError(OPERATION$1, "window_not_found");
+					if (selectedWindow === undefined) throw new BrowserObservationError(OPERATION$2, "window_not_found");
 					await runWithExecutionLimits(selectedWindow.locator(action.selector).click({ timeout: 0 }), options.signal);
 					return;
 				case "wait": {
-					const page = selectedWindow ?? await application.firstWindow({ timeout: 0 });
+					const page = selectedWindow ?? await runWithExecutionLimits(application.firstWindow({ timeout: 0 }), options.signal);
 					await runWithExecutionLimits(page.waitForTimeout(action.duration_ms), options.signal);
 					return;
 				}
 				case "renderer-reload":
-					if (selectedWindow === undefined) throw new BrowserObservationError(OPERATION$1, "window_not_found");
+					if (selectedWindow === undefined) throw new BrowserObservationError(OPERATION$2, "window_not_found");
 					await runWithExecutionLimits(selectedWindow.reload({ timeout: 0 }), options.signal);
 					return;
 				case "renderer-crash": {
@@ -118,7 +128,7 @@ function init_PlaywrightElectronActiveActions() {
 						candidate.webContents.forcefullyCrashRenderer();
 						return true;
 					}, action.window_index), options.signal);
-					if (!crashed) throw new BrowserObservationError(OPERATION$1, "window_not_found");
+					if (!crashed) throw new BrowserObservationError(OPERATION$2, "window_not_found");
 					return;
 				}
 				case "deep-link":
@@ -137,7 +147,7 @@ function init_PlaywrightElectronActiveActions() {
 		};
 		waitForWindow = async ({ application, windowIndex, signal }) => {
 			while (true) {
-				if (signal?.aborted === true) throw new BrowserObservationError(OPERATION$1, "cancelled");
+				if (signal?.aborted === true) throw new BrowserObservationError(OPERATION$2, "cancelled");
 				const window = application.windows()[windowIndex];
 				if (window !== undefined) return window;
 				await runWithExecutionLimits(new Promise((resolve) => setTimeout(resolve, 25)), signal);
@@ -198,17 +208,45 @@ function init_PlaywrightElectronActiveActions() {
 				hookSnapshot
 			};
 		};
+		readFinalApplicationState = async (application, signal) => {
+			const state = readApplicationState(application);
+			if (signal?.aborted !== true) try {
+				return await runWithExecutionLimits(state, signal);
+			} catch (cause) {
+				if (!(cause instanceof BrowserObservationError) || cause.reason !== "cancelled") throw cause;
+			}
+			let timer;
+			const graceExpired = new Promise((resolve) => {
+				timer = setTimeout(() => resolve(GRACE_EXPIRED), CANCELLED_STATE_READ_TIMEOUT_MS);
+			});
+			try {
+				const settled = await Promise.race([state, graceExpired]);
+				if (settled !== GRACE_EXPIRED) return settled;
+			} finally {
+				clearTimeout(timer);
+			}
+			throw new BrowserObservationError(OPERATION$2, "cancelled", {
+				cause: signal?.reason,
+				diagnostics: {
+					final_state_read: "cancellation_grace_expired",
+					cancellation_grace_ms: CANCELLED_STATE_READ_TIMEOUT_MS
+				}
+			});
+		};
 		runWithExecutionLimits = async (operation, signal, deadline) => {
-			if (signal?.aborted === true) throw new BrowserObservationError(OPERATION$1, "cancelled");
+			if (signal?.aborted === true) {
+				void operation.catch(() => undefined);
+				throw new BrowserObservationError(OPERATION$2, "cancelled", { cause: signal.reason });
+			}
 			if (signal === undefined && deadline === undefined) return operation;
 			let timer;
 			let abortListener;
 			const interruptions = [];
 			if (deadline !== undefined) interruptions.push(new Promise((_, reject) => {
-				timer = setTimeout(() => reject(new BrowserObservationError(OPERATION$1, "timeout")), Math.max(1, deadline - performance.now()));
+				timer = setTimeout(() => reject(new BrowserObservationError(OPERATION$2, "timeout")), Math.max(1, deadline - performance.now()));
 			}));
 			if (signal !== undefined) interruptions.push(new Promise((_, reject) => {
-				abortListener = () => reject(new BrowserObservationError(OPERATION$1, "cancelled"));
+				abortListener = () => reject(new BrowserObservationError(OPERATION$2, "cancelled", { cause: signal.reason }));
 				signal.addEventListener("abort", abortListener, { once: true });
 			}));
 			try {
@@ -224,6 +262,168 @@ function init_PlaywrightElectronActiveActions() {
 	})))();
 }
 
+//#endregion
+//#region dist/browser/ElectronProcessCleanup.js
+var cleanupElectronProcesses, verifyFamilyRelease;
+function init_ElectronProcessCleanup() {
+	return (init_ElectronProcessCleanup = __esmMin((() => {
+		init_ProcessOwnership();
+		init_ProcessOwnershipProcessTree();
+		cleanupElectronProcesses = async (ownership, lineage, host = {
+			platform: process.platform,
+			terminateTree: cleanupWindowsProcessTree
+		}) => {
+			if (lineage?.status === "verified" && (lineage.lineage.runId !== ownership.runId || lineage.lineage.launcherPid !== ownership.leaderPid || lineage.lineage.processGroupId !== ownership.processGroupId)) {
+				return {
+					cleaned: false,
+					reason: "Electron lineage does not match the retained process owner"
+				};
+			}
+			if (lineage?.status !== "verified") {
+				const root = host.platform === "win32" ? {
+					cleaned: true,
+					signaled: false
+				} : await cleanupOwnedProcessGroup(ownership);
+				if (!root.cleaned) return root;
+				const released = await verifyFamilyRelease(ownership, root);
+				return released.cleaned ? released : {
+					...released,
+					reason: `${lineage?.reason ?? "owned Electron lineage was not observed"}; helper cleanup was not proven: ${released.reason}`
+				};
+			}
+			if (host.platform === "win32") {
+				const root = await host.terminateTree(ownership.leaderPid);
+				return root.cleaned ? verifyFamilyRelease(ownership, root) : root;
+			}
+			const groupIds = selectCapturedProcessGroupIds(ownership.leaderPid, lineage.lineage.descendants.map(({ pid, processGroupId }) => ({
+				pid,
+				process_group_id: processGroupId
+			})));
+			let signaled = false;
+			const unverified = [];
+			for (const processGroupId of groupIds) {
+				const cleanupOwnership = processGroupId === ownership.processGroupId ? {
+					...ownership,
+					leaderPid: processGroupId,
+					processGroupId
+				} : {
+					runId: ownership.runId,
+					leaderPid: processGroupId,
+					processGroupId
+				};
+				const result = await cleanupOwnedProcessGroup(cleanupOwnership);
+				if (!result.cleaned) return result;
+				signaled ||= result.signaled;
+				unverified.push(...result.unverified ?? []);
+			}
+			return verifyFamilyRelease(ownership, {
+				cleaned: true,
+				signaled,
+				...unverified.length === 0 ? {} : { unverified }
+			});
+		};
+		verifyFamilyRelease = async (ownership, root) => {
+			const remaining = await verifyNoTokenOwnedProcesses(ownership.runId, undefined, ownership.captureBaseline, {
+				leaderPid: ownership.leaderPid,
+				processGroupId: ownership.processGroupId,
+				...ownership.sampledProcessGroupIds === undefined ? {} : { sampledProcessGroupIds: ownership.sampledProcessGroupIds }
+			});
+			const unverified = [...root.unverified ?? [], ...remaining.unverified ?? []];
+			if (!remaining.cleaned) return {
+				...remaining,
+				...unverified.length === 0 ? {} : { unverified }
+			};
+			return {
+				cleaned: true,
+				signaled: root.signaled || remaining.signaled,
+				...unverified.length === 0 ? {} : { unverified: [...new Map(unverified.map((item) => [`${String(item.pid)}:${item.diagnostic}`, item])).values()] }
+			};
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/ElectronCaptureCleanup.js
+var ElectronCaptureCleanup;
+function init_ElectronCaptureCleanup() {
+	return (init_ElectronCaptureCleanup = __esmMin((() => {
+		init_AnalysisCleanupLease();
+		init_ArtifactReader();
+		init_ProcessOwnershipObservation();
+		init_PlaywrightElectronActiveActions();
+		init_ElectronProcessCleanup();
+		ElectronCaptureCleanup = class {
+			#transport;
+			#processes;
+			#closeOperation;
+			#lineage;
+			#processResult;
+			constructor(application, ownership, lineage) {
+				this.#lineage = lineage;
+				this.#transport = new AnalysisCleanupLease(async () => {
+					if (this.#closeOperation === undefined) {
+						const closing = Promise.resolve().then(() => application.close());
+						this.#closeOperation = closing;
+						void closing.catch(() => {
+							if (this.#closeOperation === closing) this.#closeOperation = undefined;
+						});
+					}
+					await runWithExecutionLimits(this.#closeOperation, undefined, performance.now() + 5e3);
+				}, ["browser_transport"]);
+				const resources = ownership === undefined ? ["owned_process_group"] : [
+					"owned_process_group",
+					`run:${ownership.runId}`,
+					`process-group:${String(ownership.processGroupId)}`
+				];
+				this.#processes = new AnalysisCleanupLease(async () => {
+					const cleanup = ownership === undefined ? {
+						cleaned: false,
+						reason: "owned Electron process identity was unavailable"
+					} : await this.#cleanupProcesses(ownership);
+					this.#processResult = cleanup;
+					if (!cleanup.cleaned) throw new ArtifactReaderFailure("unavailable", cleanup.reason, { cleanup: {
+						reason: cleanup.reason,
+						resources
+					} });
+				}, resources);
+			}
+			get processResult() {
+				return this.#processResult;
+			}
+			get pendingResources() {
+				return this.#pending.flatMap((lease) => lease.cleanupResources ?? []);
+			}
+			get #pending() {
+				return [this.#transport, this.#processes].filter((lease) => !lease.released);
+			}
+			async release(scope) {
+				const transport = await scope.release({
+					kind: "lease",
+					resource: "browser_transport",
+					lease: this.#transport
+				});
+				const processes = await scope.release({
+					kind: "lease",
+					resource: "owned_process_group",
+					lease: this.#processes
+				});
+				return {
+					transport,
+					processes
+				};
+			}
+			bind(error) {
+				new AnalysisCleanupLeaseGroup(error, this.#pending);
+			}
+			async #cleanupProcesses(ownership) {
+				const current = await observeOwnedProcessLineage(ownership);
+				if (current.status === "verified") this.#lineage = current;
+				return cleanupElectronProcesses(ownership, process.platform === "win32" ? current : this.#lineage ?? current);
+			}
+		};
+	})))();
+}
+
 //#endregion
 //#region dist/browser/PlaywrightElectronActiveProjection.js
 var observableEventFamilies, ipcEventKinds, eventFamily, normalizeObservations, createCoverage, hasUnattributedDroppedPreloadFamily, hasObservedPreloadConfiguration, projectElectronActiveCapture;
@@ -335,6 +535,7 @@ function init_PlaywrightElectronActiveProjection() {
 				coverage: createCoverage(hookSnapshot, observations),
 				limitations: [
 					"IPC payloads are represented by value shapes; payload values are never retained.",
+					...observations.observedEventFamilies.includes("ipc-observation-gap") ? ["IPC observation gaps have unobserved callback arguments and execution. Available ipc-observation-gap timeline records identify the custom-apply or listener-chain boundary and registered channel; dropped gap records are counted by retention. Listener-chain gaps describe registration uncertainty, not proof of IPC delivery."] : [],
 					"IPC direction and sender/receiver identifiers are observed only where Electron exposes them at the hooked boundary.",
 					"The runtime timeline records lifecycle, navigation, shell, permission, popup, download, protocol, preload, native-addon, process, and IPC events; activity before hook installation is unavailable.",
 					"The preload and renderer process contexts are not instrumented by the main-process -r hook; preload configuration and contextBridge API-shape events are main-boundary observations, not proof of renderer-side execution.",
@@ -350,20 +551,90 @@ function init_PlaywrightElectronActiveProjection() {
 	})))();
 }
 
+//#endregion
+//#region dist/browser/PlaywrightElectronActiveFuses.js
+var OPERATION$1, NODE_CLI_INSPECT_ARGUMENTS_FUSE_INDEX, appBundleDirectoryOf, assertNodeCliInspectArgumentsSupported;
+function init_PlaywrightElectronActiveFuses() {
+	return (init_PlaywrightElectronActiveFuses = __esmMin((() => {
+		init_ArtifactFileOperation();
+		init_ArtifactReader();
+		init_ElectronFuseFailures();
+		init_analysisErrorCore();
+		init_ElectronFusePath();
+		init_ElectronFuseReader();
+		OPERATION$1 = "capture_electron_scenario";
+		NODE_CLI_INSPECT_ARGUMENTS_FUSE_INDEX = 3;
+		appBundleDirectoryOf = (executablePath) => {
+			let current = dirname(executablePath);
+			while (true) {
+				if (basename(current).endsWith(".app")) return current;
+				const parent = dirname(current);
+				if (parent === current) return null;
+				current = parent;
+			}
+		};
+		assertNodeCliInspectArgumentsSupported = async (executablePath, options) => {
+			assertArtifactReadActive(options?.signal);
+			const reader = options?.readFuseImage ?? readElectronFuseImage;
+			const resolver = options?.resolveFuseTarget ?? resolveElectronFuseTarget;
+			try {
+				let targetPath = executablePath;
+				const bundleDir = appBundleDirectoryOf(executablePath);
+				if (bundleDir !== null) {
+					try {
+						const resolved = await resolver(bundleDir, options?.signal);
+						targetPath = resolved.file.path;
+					} catch (cause) {
+						if (options?.signal?.aborted) throw cause;
+						targetPath = executablePath;
+					}
+				}
+				const image = await reader(targetPath, {
+					...options?.signal === undefined ? {} : { signal: options.signal },
+					...options?.resources === undefined ? {} : { resources: options.resources }
+				});
+				if (image.slices.length === 0) return;
+				const hostArchitecture = process.arch === "x64" ? "x86_64" : process.arch;
+				const targetSlice = image.slices.find((slice) => slice.architecture === hostArchitecture) ?? image.slices[0];
+				if (targetSlice === undefined) return;
+				for (const sentinel of targetSlice.sentinels) {
+					if (sentinel.wire_version !== 1) continue;
+					const fuse = sentinel.fuses.find((entry) => entry.index === NODE_CLI_INSPECT_ARGUMENTS_FUSE_INDEX || entry.name === "EnableNodeCliInspectArguments");
+					if (fuse?.state === "disabled" || fuse?.state === "removed") {
+						throw new AnalysisUnsupportedTargetError(OPERATION$1, executablePath, "Target binary disables the EnableNodeCliInspectArguments fuse; Node CLI inspector arguments are ignored and active scenario capture cannot attach.", { remediationAction: "Use passive CDP observation tools (inspect_electron_page), or launch active capture against an Electron development build or a stock Electron runtime with the extracted app." });
+					}
+				}
+			} catch (cause) {
+				if (cause instanceof AnalysisUnsupportedTargetError) throw cause;
+				if (cause instanceof ArtifactReaderFailure && (cause.cleanup !== undefined || cause.reason === "cancelled")) throw electronFuseFailure(cause, executablePath, OPERATION$1);
+				assertArtifactReadActive(options?.signal);
+			}
+		};
+	})))();
+}
+
 //#endregion
 //#region dist/browser/PlaywrightElectronActiveProvider.js
-var OPERATION, STARTUP_TIMEOUT_MS, hookPath, PlaywrightElectronActiveProvider, cleanupElectronProcesses, safeElectronEnvironment, PLAYWRIGHT_INTERNAL_FRAME, activeLaunches, heldLaunchRejections, holdLaunchRejection, forwardLaunchRejection, containLaunchRejections, providerError;
+var OPERATION, STARTUP_TIMEOUT_MS, hookPath, PlaywrightElectronActiveProvider, cancelledCapture, cancellationCause, safeElectronEnvironment, PLAYWRIGHT_INTERNAL_FRAME, activeLaunches, heldLaunchRejections, holdLaunchRejection, forwardLaunchRejection, containLaunchRejections, providerError;
 function init_PlaywrightElectronActiveProvider() {
 	return (init_PlaywrightElectronActiveProvider = __esmMin((() => {
+		init_ArtifactReader();
+		init_ArtifactFileOperation();
+		init_providerCleanupError();
+		init_ElectronCaptureCleanup();
+		init_analysisErrorCleanup();
+		init_ArtifactResourceScope();
+		init_ElectronFuseFailures();
 		init_analysisErrorBase();
+		init_analysisErrorCore();
 		init_browserObservationError();
 		init_providerAdapterError();
 		init_result();
-		init_ProcessOwnership();
 		init_ProcessOwnershipObservation();
-		init_ProcessOwnershipProcessTree();
 		init_PlaywrightElectronActiveActions();
 		init_PlaywrightElectronActiveProjection();
+		init_ElectronFuseReader();
+		init_PlaywrightElectronActiveFuses();
 		init_providerIdentities();
 		OPERATION = "capture_electron_scenario";
 		STARTUP_TIMEOUT_MS = 6e4;
@@ -371,14 +642,38 @@ function init_PlaywrightElectronActiveProvider() {
 		PlaywrightElectronActiveProvider = class {
 			environment;
 			launch;
-			constructor(environment, launch = async (options) => (await import("playwright-core"))._electron.launch(options)) {
+			readFuseImage;
+			#resources = new ArtifactResourceScope();
+			#shutdown = new AbortController();
+			/** Stop admitting work, cancel and join captures, then retry exact retained resource owners. */
+			async close() {
+				this.#shutdown.abort(new Error("Electron active provider is closing"));
+				try {
+					await this.#resources.close();
+				} catch (cause) {
+					throw providerError(cause);
+				}
+			}
+			constructor(environment, launch = async (options) => (await import("playwright-core"))._electron.launch(options), readFuseImage = readElectronFuseImage) {
 				this.environment = environment;
 				this.launch = launch;
+				this.readFuseImage = readFuseImage;
 			}
 			identity() {
 				return PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY;
 			}
 			async capture(input, options = {}) {
+				const signal = AbortSignal.any([this.#shutdown.signal, ...options.signal === undefined ? [] : [options.signal]]);
+				try {
+					return await this.#resources.run(() => this.#capture(input, {
+						...options,
+						signal
+					}));
+				} catch (cause) {
+					return err(providerError(cause));
+				}
+			}
+			async #capture(input, options) {
 				let application;
 				let ownership;
 				let lineage;
@@ -397,6 +692,19 @@ function init_PlaywrightElectronActiveProvider() {
 						application: input.application_path,
 						root: input.application_root
 					};
+					const preflight = assertNodeCliInspectArgumentsSupported(input.executable_path, {
+						resources: this.#resources,
+						...options.signal === undefined ? {} : { signal: options.signal },
+						readFuseImage: this.readFuseImage
+					}).catch((cause) => {
+						throw electronFuseFailure(cause, input.executable_path, OPERATION);
+					});
+					try {
+						await runWithExecutionLimits(preflight, options.signal, startupDeadline);
+					} catch (interruption) {
+						await preflight;
+						throw interruption;
+					}
 					const captureBaseline = await systemProcessOwnershipHost.captureBaseline?.(options.signal);
 					if (options.signal?.aborted) throw new BrowserObservationError(OPERATION, "cancelled");
 					const launchOptions = {
@@ -411,7 +719,10 @@ function init_PlaywrightElectronActiveProvider() {
 						],
 						timeout: Math.max(1, startupDeadline - performance.now())
 					};
-					application = await containLaunchRejections(() => this.launch(launchOptions));
+					application = await containLaunchRejections(() => {
+						options.signal?.throwIfAborted();
+						return this.launch(launchOptions);
+					});
 					const leaderPid = application.process().pid;
 					if (typeof leaderPid !== "number" || !Number.isSafeInteger(leaderPid) || leaderPid <= 0) throw new BrowserObservationError(OPERATION, "process_ownership_unavailable");
 					ownership = {
@@ -424,14 +735,11 @@ function init_PlaywrightElectronActiveProvider() {
 						...captureBaseline === undefined ? {} : { captureBaseline }
 					};
 					lineage = await observeOwnedProcessLineage(ownership);
-					initialState = await readApplicationState(application);
+					initialState = await runWithExecutionLimits(readApplicationState(application), options.signal, startupDeadline);
 					actions = await runElectronActions(application, input, options);
-					const state = await runWithExecutionLimits(readApplicationState(application), undefined, options.signal?.aborted ? performance.now() + 5e3 : undefined);
+					const state = await readFinalApplicationState(application, options.signal);
 					capture = projectElectronActiveCapture(paths, actions, state);
-					outcome = options.signal?.aborted ? err(new BrowserObservationError(OPERATION, "cancelled", { partialObservation: {
-						kind: "electron-active-observation",
-						capture
-					} })) : ok(capture);
+					outcome = options.signal?.aborted ? err(cancelledCapture(capture, options.signal.reason)) : ok(capture);
 				} catch (cause) {
 					if (paths !== undefined && initialState !== undefined) {
 						const retainedCapture = projectElectronActiveCapture(paths, actions, initialState);
@@ -440,8 +748,9 @@ function init_PlaywrightElectronActiveProvider() {
 							limitations: [...retainedCapture.limitations, `Capture stopped after the initial pre-action snapshot: ${cause instanceof Error ? cause.message : String(cause)}. Final Windows, metrics, IPC, and timeline state is unknown; the retained snapshot may omit action effects.`]
 						};
 					}
-					if (options.signal?.aborted === true) outcome = err(new BrowserObservationError(OPERATION, "cancelled", {
-						cause,
+					if (cause instanceof AnalysisError && cause.cleanupIncomplete) outcome = err(cause);
+					else if (options.signal?.aborted === true) outcome = err(new BrowserObservationError(OPERATION, "cancelled", {
+						...cancellationCause(cause, options.signal),
 						...capture === undefined ? {} : { partialObservation: {
 							kind: "electron-active-observation",
 							capture
@@ -457,116 +766,59 @@ function init_PlaywrightElectronActiveProvider() {
 					}
 				}
 				if (application !== undefined) {
-					if (ownership !== undefined) {
-						const currentLineage = await observeOwnedProcessLineage(ownership);
-						if (currentLineage.status === "verified" || lineage === undefined) lineage = currentLineage;
-					}
-					let closeError;
-					try {
-						await runWithExecutionLimits(application.close(), undefined, performance.now() + 5e3);
-					} catch (cause) {
-						closeError = cause;
+					const owner = new ElectronCaptureCleanup(application, ownership, lineage);
+					const released = await owner.release(this.#resources);
+					const cleanup = owner.processResult;
+					if (outcome.ok && options.signal?.aborted === true) outcome = err(cancelledCapture(outcome.value, options.signal.reason));
+					if (released.processes.kind === "failed" || released.transport.kind === "failed") {
+						const processFailure = released.processes.kind === "failed";
+						const failures = [released.processes, released.transport].flatMap((attempt) => attempt.kind === "failed" ? [attempt.cause] : []);
+						const cause = failures.length === 1 ? failures[0] : new AggregateError(failures, "Electron process and transport cleanup failed");
+						const reason = failures.map((failure) => failure instanceof Error ? failure.message : String(failure)).join("; ");
+						const failure = new BrowserObservationError(OPERATION, "cleanup_failed", {
+							cause,
+							detail: `${processFailure ? "Electron process cleanup could not be verified" : "Electron transport teardown failed after process cleanup"}: ${reason}. Collected observations are retained when available.`,
+							cleanup: {
+								reason,
+								resources: owner.pendingResources
+							},
+							...capture === undefined ? {} : { partialObservation: {
+								kind: "electron-active-observation",
+								capture: processFailure ? {
+									...capture,
+									application: {
+										...capture.application,
+										cleanup: "unverified"
+									}
+								} : capture
+							} }
+						});
+						owner.bind(failure);
+						if (outcome.ok) return err(failure);
+						const composed = analysisErrorWithCleanupFailure(outcome.error, failure, OPERATION).bindCleanupDependencies([outcome.error, failure]);
+						if (failure.partialObservation !== undefined) composed.partialObservation = failure.partialObservation;
+						return err(composed);
 					}
-					const cleanup = ownership === undefined ? {
-						cleaned: false,
-						reason: "owned Electron process identity was unavailable"
-					} : await cleanupElectronProcesses(ownership, lineage);
-					if (!cleanup.cleaned) return err(new BrowserObservationError(OPERATION, "cleanup_failed", {
-						cause: outcome.ok ? new Error(cleanup.reason) : outcome.error,
-						detail: `Electron cleanup could not be verified: ${cleanup.reason}.${capture !== undefined ? " Collected observations are retained in partial_observation." : ""}${outcome.ok ? "" : ` Capture also failed: ${outcome.error.message}.`} Inspect the reported process resources before launching another capture.`,
-						cleanup: {
-							reason: cleanup.reason,
-							resources: ownership === undefined ? ["owned_process_group"] : [
-								"owned_process_group",
-								`run:${ownership.runId}`,
-								`process-group:${String(ownership.processGroupId)}`
-							]
-						},
-						...capture !== undefined ? { partialObservation: {
-							kind: "electron-active-observation",
-							capture: {
-								...capture,
-								application: {
-									...capture.application,
-									cleanup: "unverified"
-								}
-							}
-						} } : {}
-					}));
-					if (closeError !== undefined) return err(new BrowserObservationError(OPERATION, "cleanup_failed", {
-						cause: outcome.ok ? closeError : outcome.error,
-						detail: `Electron transport teardown failed after process cleanup: ${closeError instanceof Error ? closeError.message : String(closeError)}.${capture !== undefined ? " Collected observations are retained in partial_observation." : ""}${outcome.ok ? "" : ` Capture also failed: ${outcome.error.message}.`}`,
-						...capture !== undefined ? { partialObservation: {
-							kind: "electron-active-observation",
-							capture
-						} } : {}
-					}));
-					if (outcome.ok && cleanup.unverified !== undefined) outcome = ok({
+					if (outcome.ok && cleanup?.cleaned && cleanup.unverified !== undefined) outcome = ok({
 						...outcome.value,
 						limitations: [...outcome.value.limitations, ...cleanup.unverified.map(({ pid, diagnostic }) => `Ownership of unrelated process ${String(pid)} could not be verified; it was left untouched: ${diagnostic}`)]
 					});
 				}
+				if (outcome.ok && options.signal?.aborted === true) return err(cancelledCapture(outcome.value, options.signal.reason));
 				return outcome;
 			}
 		};
-		cleanupElectronProcesses = async (ownership, lineage, host = {
-			platform: process.platform,
-			terminateTree: cleanupWindowsProcessTree
-		}) => {
-			if (host.platform === "win32") {
-				if (lineage?.status !== "verified") return {
-					cleaned: false,
-					reason: "owned Electron lineage was unavailable; helper cleanup was not proven"
-				};
-				const root = await host.terminateTree(ownership.leaderPid);
-				if (!root.cleaned) return root;
-				for (const descendant of lineage.lineage.descendants) {
-					const result = await host.terminateTree(descendant.pid);
-					if (!result.cleaned) return result;
-				}
-				return root;
-			}
-			if (lineage?.status !== "verified") {
-				const root = await cleanupOwnedProcessGroup(ownership);
-				return root.cleaned ? {
-					cleaned: false,
-					reason: "owned Electron lineage was unavailable; helper cleanup was not proven"
-				} : root;
+		cancelledCapture = (capture, reason) => new BrowserObservationError(OPERATION, "cancelled", {
+			cause: reason,
+			partialObservation: {
+				kind: "electron-active-observation",
+				capture
 			}
-			const groupIds = selectCapturedProcessGroupIds(ownership.leaderPid, lineage.lineage.descendants.map(({ pid, processGroupId }) => ({
-				pid,
-				process_group_id: processGroupId
-			})));
-			let signaled = false;
-			const unverified = [];
-			for (const processGroupId of groupIds) {
-				const cleanupOwnership = processGroupId === ownership.processGroupId ? {
-					...ownership,
-					leaderPid: processGroupId,
-					processGroupId
-				} : {
-					runId: ownership.runId,
-					leaderPid: processGroupId,
-					processGroupId
-				};
-				const result = await cleanupOwnedProcessGroup(cleanupOwnership);
-				if (!result.cleaned) return result;
-				signaled ||= result.signaled;
-				unverified.push(...result.unverified ?? []);
-			}
-			const remaining = await verifyNoTokenOwnedProcesses(ownership.runId, undefined, ownership.captureBaseline, {
-				leaderPid: ownership.leaderPid,
-				processGroupId: ownership.processGroupId,
-				...ownership.sampledProcessGroupIds === undefined ? {} : { sampledProcessGroupIds: ownership.sampledProcessGroupIds }
-			});
-			if (!remaining.cleaned) return remaining;
-			unverified.push(...remaining.unverified ?? []);
-			return {
-				cleaned: true,
-				signaled,
-				...unverified.length === 0 ? {} : { unverified: [...new Map(unverified.map((item) => [`${String(item.pid)}:${item.diagnostic}`, item])).values()] }
-			};
-		};
+		});
+		cancellationCause = (cause, signal) => cause instanceof AnalysisCancelledError || cause instanceof AnalysisError && cause.userCategory === "cancelled" ? {
+			cause: signal.reason,
+			...cause.diagnostics === undefined ? {} : { diagnostics: cause.diagnostics }
+		} : { cause };
 		safeElectronEnvironment = (environment, runId, platform = process.platform) => Object.fromEntries([...[
 			"HOME",
 			"LANG",
@@ -631,10 +883,21 @@ function init_PlaywrightElectronActiveProvider() {
 				}
 			}
 		};
-		providerError = (cause) => cause instanceof AnalysisError ? cause : new ProviderAdapterError(PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY.id, OPERATION, {
-			cause,
-			diagnostics: { message: cause instanceof Error ? cause.message : String(cause) }
-		});
+		providerError = (cause) => {
+			if (cause instanceof AnalysisError) return cause;
+			if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined) {
+				const failure = new ProviderCleanupError(PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY.id, cause.cleanup.resources, { reason: cause.cleanup.reason }, {
+					operation: OPERATION,
+					cause
+				});
+				bindArtifactFileCleanup(cause, failure);
+				return failure;
+			}
+			return new ProviderAdapterError(PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY.id, OPERATION, {
+				cause,
+				diagnostics: { message: cause instanceof Error ? cause.message : String(cause) }
+			});
+		};
 	})))();
 }