fix(cancellation): preserve caller abort reasons through late finalization (#6143)

* fix(cancellation): preserve caller abort reasons through late finalization

Caller aborts that arrived during final provider, cleanup, or protocol
handling were dropped or replaced by I/O, cleanup, or success results.
Each affected path now samples the caller signal after its owner has
settled and returns AnalysisCancelledError carrying the exact
signal.reason, keeping any completed partial Evidence or cleanup state.

- Web script export: keep the exact reason for an interrupted output
  write, and honor a cancellation fact recorded before a retried
  capture close succeeds.
- Native value tracing and Hopper regex search: check the signal after
  the final provider reply or regex worker settles.
- Apple asset catalog: stop assetutil with SIGTERM so cancellation
  settles only after the helper exits.
- CDP observation: end an armed window on a fatal protocol failure.
- ADB bugreport: prefer cancellation over the staging-removal output
  error when the caller aborted.
- JavaScript recovery: check the signal after provider success.
- export-web-scripts CLI: run under command cancellation and forward
  the signal into the export workflow.
- Objdump and Rizin CLI: report cancellation after cleanup completes.
- Binary session: keep cancellation primary when previous-client
  retirement fails after abort.

Fixes morluto/rea#6042
Fixes morluto/rea#6043
Fixes morluto/rea#6048
Fixes morluto/rea#6049
Fixes morluto/rea#6057
Fixes morluto/rea#6060
Fixes morluto/rea#6078
Fixes morluto/rea#6080
Fixes morluto/rea#6108
Fixes morluto/rea#6111
Fixes morluto/rea#6115

* fix(cancellation): keep caller reasons through export rollback and commit

- Rollback failure after a caller abort now returns AnalysisCancelledError
  with the exact signal.reason, attaching the rollback failure as cleanup
  and retaining any published result as partial observation.
- A capture close retry that succeeds after abort returns cancellation
  instead of the stale cleanup diagnostic.
- An abort that lands during the final output commit returns cancellation
  carrying the completed manifest as partial observation.
- Apple assetutil stop test: abort and await the run in finally so a
  timed-out wait does not leave the child running, and skip on Windows
  where the JavaScript SIGTERM handler cannot run.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 35b247e9-c793-4b8f-979a-807c27112cf5

* fix(cancellation): bind export cancellations to cleanup and caller reasons

- A rollback-failure cancellation is bound to the retained cleanup lease,
  so a later successful close clears cleanup_incomplete instead of
  reporting a residual directory that no longer exists.
- mapExportFailure wraps the caller's own AnalysisCancelledError reason
  under export_web_scripts rather than returning it as the export's error.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 35b247e9-c793-4b8f-979a-807c27112cf5

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
Copilot-Session: 35b247e9-c793-4b8f-979a-807c27112cf5

src/application/WebScriptExportService.ts

@@ -38,6 +38,7 @@ import {
   NonRegularFileReadError,
   RegularFileChangedError,
 } from "../filesystem/RegularFile.js";
+import { regularFileCancellation } from "../filesystem/OwnedRegularFile.js";
 
 const OPERATION = "export_web_scripts";
 
@@ -101,6 +102,13 @@ export const exportWebScriptsValidated = async (
       resources,
       ...(options.signal === undefined ? {} : { signal: options.signal }),
     });
+    if (options.signal?.aborted === true)
+      return err(
+        new AnalysisCancelledError(OPERATION, {
+          cause: options.signal.reason,
+          partialObservation: { kind: "web-script-export", result },
+        }),
+      );
     return ok(
       createEvidence(
         { path: input.capture_path, sha256, format: "file" },
@@ -170,6 +178,8 @@ const mapExportFailure = (
   signal: AbortSignal | undefined,
 ): AnalysisError => {
   if (cause instanceof WebScriptExportError) return cause;
+  if (cause instanceof AnalysisCancelledError && cause !== signal?.reason)
+    return cause;
   if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined)
     return analysisErrorWithCleanupFailure(
       new WebScriptExportError(
@@ -187,7 +197,12 @@ const mapExportFailure = (
       OPERATION,
     );
   if (signal?.aborted === true)
-    return new AnalysisCancelledError(OPERATION, { cause });
+    return new AnalysisCancelledError(OPERATION, {
+      cause:
+        cause instanceof ArtifactReaderFailure && cause.cause === signal.reason
+          ? signal.reason
+          : cause,
+    });
   if (cause instanceof ArtifactReaderFailure)
     return new WebScriptExportError(
       cause.reason,
@@ -245,8 +260,23 @@ const readCapture = async (
         incomplete: retry.cleanup !== undefined,
         cause: cause.cleanupCause,
       };
-      if (retry.outcome.kind === "completed")
+      if (retry.outcome.kind === "completed") {
+        const cancellation =
+          signal?.aborted === true
+            ? { reason: signal.reason }
+            : regularFileCancellation(cause);
+        if (cancellation !== undefined) {
+          const primary = new AnalysisCancelledError(OPERATION, {
+            cause: cancellation.reason,
+          });
+          return err(
+            retry.cleanup === undefined
+              ? primary
+              : incompleteCaptureCleanup(primary, path, cleanup),
+          );
+        }
         return ok({ bytes: retry.outcome.value as Buffer, cleanup });
+      }
       const primary = captureReadFailure(
         path,
         retry.outcome.cause,