This sounds like a job for POE, but I don't know enough about that module to say for sure.

If I were writing this, I'd be strongly tempted to make each child into an object. You could stash within it $params and all the other state that you're trying to hold and modularize all the behavior you want them to have. Each child object in the parent would know the PID of the child process, the parameters it started with, how many times it has died, etc.

• Give the child object a DESTROY method that kills the child process. This way when the parent exits, the children go with it.
• The parent can still wait for something to die and tell the relevant child to restart itself.
• The child can fork and then sleep to get the delay you want.

Something like:

my @child_info;
foreach my $params (@params_for_children)
{
    my $child = Foo::Child->new( params => $params );
    $child->spawn();
    push @child_info, $child;
}

while ( my $pid = wait() ) 
{
    last if $pid = -1;
    my $exit_status = $?;
    my ($poor_dead_child)
        = grep { $_->{pid} == $pid } @child_info;
    $poor_dead_child->fyi_you_died();
    $poor_dead_child->spawn();
}

package Foo::Child;

sub new {
    my $class = shift;
    my $self = { @_ };
    return bless $self, $class;
}

sub DESTROY { kill 'TERM' => shift->{pid} }

sub fyi_you_died { shift->{death_toll}++ }

sub spawn {
    my $self = shift;
    my $pid = fork;
    die "Can't fork: $!" if ! defined $pid;
    if ( $pid ) {
        $self->{pid} = $pid;
        return;
    }
    else {
         sleep ... if $self->{death_toll} > ...;
         do_child_stuff( $self->{params} );
         die;
    }
}
[download]

This is just a sketch, but hopefully you get the idea. Having written all this, I'm now guessing that someone will come along with a much better CPAN module I've never heard of.

Update: Upon further consideration, I'm not sure this is such a hot idea. Each child is a copy of the whole, so each has a copy of all the child objects. As soon as one of them dies, it's going to shoot all the other ones in their destructors. Oops. You could still have them all manage themselves except for the DESTROY methods. In that case, the parent would have to kill them all manually in an END {} block.

Update 2: Another thought. You could write DESTROY this way:

sub DESTROY {
    my $self = shift;
    if ( $$ == $self->{parent_pid} ) {
        kill 'TERM' => $self->{pid};
    }
}
[download]

Then you have spawn note the parent PID before it forks

sub spawn {
    my $self = shift;

    $self->{parent_pid} = $$;
    my $pid = fork;
# ...
[download]