Definir uma armadilha para INT não funciona em um subshell

O controle de tarefas refere-se ao protocolo para permitir que um usuário se mova entre vários grupos de processos (ou tarefas) em uma única sessão de login.

https://www.gnu.org/software/libc/manual/html_node/Job-Control.html

Geralmente é ativado em shells interativos e desativado em não interativos:

$ echo $-; sleep 1 & fg
himBHs
[1] 84366
sleep 1

$ bash -c 'echo $-; sleep 1 & fg'
hBc
bash: line 1: fg: no job control

Nesse caso... aparentemente o controle de trabalho está desabilitado e $-não pode ser invocado:

$ (echo $-; sleep 1 & fg)
himBHs
bash: fg: no job control

O shell associa um trabalho a cada pipeline.

https://www.gnu.org/software/bash/manual/html_node/Job-Control-Basics.html

Ou seja, quando o controle de trabalho está habilitado, cada pipeline é executado em um grupo de processos separado.

pgid.sh:

#!/usr/bin/env bash
ps -o pgid= $$

$ ./pgid.sh >&2 | ./pgid.sh >&2; ./pgid.sh; ./pgid.sh & wait
  93439
  93439
  93443
[1] 93445
  93445
[1]+  Done                    ./a.sh

$ (./pgid.sh >&2 | ./pgid.sh >&2; ./pgid.sh; ./pgid.sh & wait)
  93749
  93749
  93749
  93749

Um dos trabalhos é um trabalho de primeiro plano, o resto são de segundo plano.

Os trabalhos em segundo plano não devem estar vinculados ao shell que os iniciou. Se você sair de um shell, eles continuarão em execução. Como tal, eles não devem ser interrompidos por SIGINT, não por padrão. Quando o controle de tarefas está ativado, isso é realizado automaticamente, pois as tarefas em segundo plano são executadas em grupos de processos separados. Quando o controle de trabalho está desabilitado, bashfaz com que os comandos assíncronos ignorem SIGINTe não permite que eles (se forem bashscripts) o substituam.

Ou seja, aqui:

$ bash -c "trap 'echo INT' INT; sleep 3" & pid=$!; sleep 1; kill -INT "$pid"; wait

o trabalho em segundo plano ( bash -c "trap 'echo INT' INT; sleep 3") é executado por um shell interativo, que tem o controle de trabalho ativado. Como resultado, o job em background recebe SIGINT.

Quando o envolvemos em um shell não interativo sem controle de trabalho:

$ (bash -c "trap 'echo INT' INT; sleep 3" & pid=$!; sleep 1; kill -INT "$pid"; wait)

bash -c "trap 'echo INT' INT; sleep 3"ignora SIGINTe trap ... INTtambém é ignorado.

Isso pode ser confirmado desta forma:

$ bash -c "trap 'echo INT' INT; trap; sleep 3" & pid=$!; sleep 1; kill -INT "$pid"; wait
[1] 293631
trap -- 'echo INT' SIGINT
trap -- '' SIGFPE
INT
[1]+  Done                    bash -c "trap 'echo INT' INT; trap; sleep 3"

$ (bash -c "trap 'echo INT' INT; trap; sleep 3" & pid=$!; sleep 1; kill -INT "$pid"; wait)
trap -- '' SIGINT
trap -- '' SIGQUIT
trap -- '' SIGFPE

$ bash -c 'ps -o pid,ignored,comm,args -p $$' & wait
[1] 345833
    PID          IGNORED COMMAND         COMMAND
 345833 0000000000000000 ps              ps -o pid,ignored,comm,args -p 345833
[1]+  Done                    bash -c 'ps -o pid,ignored,comm,args -p $$'

$ (bash -c 'ps -o pid,ignored,comm,args -p $$' & wait)
    PID          IGNORED COMMAND         COMMAND
 345629 0000000000000006 ps              ps -o pid,ignored,comm,args -p 345629

Algumas citações relevantes:

Comandos não integrados iniciados pelo Bash têm manipuladores de sinal definidos para os valores herdados pelo shell de seu pai. Quando o controle de tarefa não está em vigor, os comandos assíncronos ignoram SIGINTeSIGQUIT adicionam esses manipuladores herdados. Os comandos executados como resultado da substituição de comando ignoram os sinais de controle de tarefa gerados pelo teclado SIGTTIN, SIGTTOU, e SIGTSTP.

https://www.gnu.org/software/bash/manual/html_node/Signals.html

Sinais ignorados na entrada no shell não podem ser interceptados ou redefinidos.

https://www.gnu.org/software/bash/manual/html_node/Bourne-Shell-Builtins.html#index-trap

O controle de tarefas refere-se à capacidade de interromper (suspender) seletivamente a execução de processos e continuar (retomar) sua execução posteriormente. Um usuário normalmente emprega esse recurso por meio de uma interface interativa fornecida em conjunto pelo driver de terminal do kernel do sistema operacional e pelo Bash.

O shell associa um trabalho a cada pipeline. Ele mantém uma tabela de trabalhos atualmente em execução, que podem ser listados com o jobscomando. Quando o Bash inicia um trabalho de forma assíncrona, ele imprime uma linha parecida com:

[1] 25647

indicando que este trabalho é o número do trabalho 1e que o ID do processo do último processo no pipeline associado a este trabalho é 25647. Todos os processos em um único pipeline são membros do mesmo trabalho. O Bash usa a abstração do trabalho como base para o controle do trabalho.

Para facilitar a implementação da interface do usuário para o controle de tarefas, o sistema operacional mantém a noção de um ID de grupo de processo de terminal atual. Os membros deste grupo de processos (processos cujo ID do grupo de processos é igual ao ID do grupo de processos do terminal atual) recebem sinais gerados pelo teclado, como SIGINT. Esses processos são considerados em primeiro plano. Processos em segundo plano são aqueles cujo ID de grupo de processos difere do do terminal; tais processos são imunes a sinais gerados pelo teclado. Somente processos em primeiro plano podem ler ou, se o usuário especificar com stty tostop, escrever no terminal. Os processos em segundo plano que tentam ler (gravar para quando stty tostopestiver em vigor) o terminal recebem um SIGTTIN(SIGTTOU) pelo driver de terminal do kernel, que, a menos que seja capturado, suspende o processo.

https://www.gnu.org/software/bash/manual/html_node/Job-Control-Basics.html