Regarding the comments "You need to register the output of the command in order for Ansible to store it." and "I tried register before, but I cannot find a way to use the register variable in the shell of other play." you may have look into the following minimal example playbook

---
- hosts: localhost
  become: true
  gather_facts: false

  tasks:

  - name: 4. Verify key generation
    shell:
      cmd: "gpg --list-secret-keys --keyid-format=long | sed '4!d' | tr -d ' '"
    register: VAR

  - name: 6. Echo GPG ID
    shell:
      cmd: "echo {{ VAR.stdout_lines }}"
    register: result

  - name: Show result
    debug:
      var: result

or a more generic

---
- hosts: localhost
  become: false
  gather_facts: false

  tasks:

  - name: Echo example 1
    shell:
      cmd: "echo 12:34:56:78:90:AB:CD:EF"
    register: VAR

  - name: Echo example 2
    shell:
      cmd: "echo {{ VAR.stdout_lines }}"
    register: result

  - name: Show registered variable
    debug:
      var: result

  - name: Show result content only
    debug:
      msg: "{{ result }}"

as it shows you how to get familiar with registering, return values and data structures.

Further Documenation

• Registering variables
• Common Return Values
• shell Return Values
• debug module – Print statements during execution

I think you can register the result to a variable, then print with debug.

- name: print to stdout
  command: echo "hello"
  register: hello

- debug: msg="{{ hello.stdout }}"

- debug: msg="{{ hello.stderr }}"

Something is wrong in your playbook together with the given output. When I build a similar playbook without all the dependencies:

- name: "Check if the deployments defined in group_vars are already installed"
  shell: "{{ item }}"
  register: check_deployments
  loop:
    - "pwd"
    - "ls -al"
    - "pwd"

- name: "Show list of deployments"
  debug:
    var: check_deployments.stdout_lines

I'm getting the information

TASK [Show list of deployments] *************************************************
ok: [localhost] => 
  check_deployments.stdout_lines: VARIABLE IS NOT DEFINED!

This is true, because you loop over a Ansible module and register ALL output into ONE variable. In that case, the variable contains a list of results. So - your loop with check_deployments.stdout_lines is wrong. You need to loop over all check_deployments.results which contains the correct "registered" variable per module run, which you want to check

- name: "Undeploy..."
  debug:
    msg: "stdout: {{ item.cmd }}"
  when: "item.stdout_lines | length > 1"
  loop: "{{ check_deployments.results }}"

This will only output one entry (ls -al). All other will be skipped.

A: The value of command_results.stdout_lines is the YAML list. Nothing happens to the list when you filter it from_yaml. Use command_results.stdout instead

- set_fact:
    needrestart: "{{ command_results.stdout | from_yaml }}"

Details: Given the below file for testing

shell> cat needrestart.txt 
NEEDRESTART-VER: 3.6
NEEDRESTART-KCUR: 5.14.0-362.24.1.el9_3.0.1.x86_64
NEEDRESTART-KEXP: 5.14.0-362.24.1.el9_3.0.1.x86_64
NEEDRESTART-KSTA: 2
NEEDRESTART-UCSTA: 0

Please read it

    - command: cat needrestart.txt
      register: command_results

You can see that next to the YAML list in the attribute stdout_lines

  command_results.stdout_lines:
  - 'NEEDRESTART-VER: 3.6'
  - 'NEEDRESTART-KCUR: 5.14.0-362.24.1.el9_3.0.1.x86_64'
  - 'NEEDRESTART-KEXP: 5.14.0-362.24.1.el9_3.0.1.x86_64'
  - 'NEEDRESTART-KSTA: 2'
  - 'NEEDRESTART-UCSTA: 0'

there is also the YAML text bloc in the attribute stdout

  command_results.stdout: |-
    NEEDRESTART-VER: 3.6
    NEEDRESTART-KCUR: 5.14.0-362.24.1.el9_3.0.1.x86_64
    NEEDRESTART-KEXP: 5.14.0-362.24.1.el9_3.0.1.x86_64
    NEEDRESTART-KSTA: 2
    NEEDRESTART-UCSTA: 0

Now, you can use from_yaml to (quote):

Converts a YAML string representation into an equivalent structured Ansible variable.

For example,

  needrestart: "{{ command_results.stdout | from_yaml }}"

gives what you want

  needrestart:
    NEEDRESTART-KCUR: 5.14.0-362.24.1.el9_3.0.1.x86_64
    NEEDRESTART-KEXP: 5.14.0-362.24.1.el9_3.0.1.x86_64
    NEEDRESTART-KSTA: 2
    NEEDRESTART-UCSTA: 0
    NEEDRESTART-VER: 3.6

  needrestart['NEEDRESTART-VER']: '3.6'

Notes:

• If you have a list only there are more options. You can convert the items to YAML dictionaries and combine them

  n3: "{{ command_results.stdout_lines | map('from_yaml') | combine }}"

gives the same result

  n3:
    NEEDRESTART-KCUR: 5.14.0-362.24.1.el9_3.0.1.x86_64
    NEEDRESTART-KEXP: 5.14.0-362.24.1.el9_3.0.1.x86_64
    NEEDRESTART-KSTA: 2
    NEEDRESTART-UCSTA: 0
    NEEDRESTART-VER: 3.6

  n3['NEEDRESTART-VER']: '3.6'

• The next option is using the function dict on the split items. The below declaration also gives the same result

    n4: "{{ dict(command_results.stdout_lines | map('split', ':')) }}"

• Example of a complete playbook for testing

- hosts: localhost

  vars:

    n1: "{{ command_results.stdout_lines | from_yaml }}"
    n2: "{{ command_results.stdout | from_yaml }}"
    n3: "{{ command_results.stdout_lines | map('from_yaml') | combine }}"
    n4: "{{ dict(command_results.stdout_lines | map('split', ':')) }}"

  tasks:

    - command: cat needrestart.txt
      register: command_results

    - debug:
        var: command_results.stdout_lines
    - debug:
        var: command_results.stdout

    - debug:
        var: n1
    - debug:
        var: n2
    - debug:
        var: n2['NEEDRESTART-VER']
    - debug:
        var: n3
    - debug:
        var: n3['NEEDRESTART-VER']
    - debug:
        var: n4
    - debug:
        var: n4['NEEDRESTART-VER']

Select last 2 lines from the list stdout_lines

Copy- local_action: copy content={{ init_output.stdout_lines[-2:] }} dest="./join-command"

It's possible to format the lines in a block. For example

Copy    - local_action:
        module: copy
        content: |
          {{ init_output.stdout_lines[-2] }}
          {{ init_output.stdout_lines[-1] }}
        dest: "./join-command"

To append the lines in a loop try

Copy    - local_action:
        module: lineinfile
        path: "./join-command"
        line: "{{ item }}"
        insertafter: EOF
        create: true
      loop: "{{ init_output.stdout_lines[-2:] }}"

Every Ansible task when run can save its results into a variable. To do this, you have to specify which variable to save the results into. Do this with the register parameter, independently of the module used.

Once you save the results to a variable you can use it later in any of the subsequent tasks. So for example if you want to get the standard output of a specific task you can write the following:

---
- hosts: localhost
  tasks:
    - shell: ls
      register: shell_result

    - debug:
        var: shell_result.stdout_lines

Here register tells ansible to save the response of the module into the shell_result variable, and then we use the debug module to print the variable out.

An example run would look like the this:

PLAY [localhost] ***************************************************************

TASK [command] *****************************************************************
changed: [localhost]

TASK [debug] *******************************************************************
ok: [localhost] => {
    "shell_result.stdout_lines": [
        "play.yml"
    ]
}

Responses can contain multiple fields. stdout_lines is one of the default fields you can expect from a module's response.

Not all fields are available from all modules, for example for a module which doesn't return anything to the standard out you wouldn't expect anything in the stdout or stdout_lines values, however the msg field might be filled in this case. Also there are some modules where you might find something in a non-standard variable, for these you can try to consult the module's documentation for these non-standard return values.

Alternatively you can increase the verbosity level of ansible-playbook. You can choose between different verbosity levels: -v, -vvv and -vvvv. For example when running the playbook with verbosity (-vvv) you get this:

PLAY [localhost] ***************************************************************

TASK [command] *****************************************************************
(...)
changed: [localhost] => {
    "changed": true,
    "cmd": "ls",
    "delta": "0:00:00.007621",
    "end": "2017-02-17 23:04:41.912570",
    "invocation": {
        "module_args": {
            "_raw_params": "ls",
            "_uses_shell": true,
            "chdir": null,
            "creates": null,
            "executable": null,
            "removes": null,
            "warn": true
        },
        "module_name": "command"
    },
    "rc": 0,
    "start": "2017-02-17 23:04:41.904949",
    "stderr": "",
    "stdout": "play.retry\nplay.yml",
    "stdout_lines": [
        "play.retry",
        "play.yml"
    ],
    "warnings": []
}

As you can see this will print out the response of each of the modules, and all of the fields available. You can see that the stdout_lines is available, and its contents are what we expect.

To answer your main question about the jenkins_script module, if you check its documentation, you can see that it returns the output in the output field, so you might want to try the following:

tasks:
  - jenkins_script:
      script: (...)
    register: jenkins_result

  - debug:
      var: jenkins_result.output