Enforce process ownership: guarantee process termination across all execution paths

[Copilot]

When a pipe delegate threw an exception, the underlying process was left running in the background. In the worst case (process blocked writing to a full pipe buffer with no reader), this became a permanent deadlock with no way out short of user cancellation.

The new convention: CliWrap takes full ownership of the process it spawns and guarantees it is terminated before any execution method returns or throws, regardless of exit path.

Changes

• Command.Execution.cs

  • Use Task.WhenAny(waitTask, pipingTask) to detect early pipe failure, then immediately Kill() the process before awaiting it — prevents the deadlock where the process is blocked on a full pipe buffer with no reader
  • Add try/finally with process.Kill() as a belt-and-suspenders guarantee covering any exit path not already handled by the inline kill

• PullEventStreamCommandExtensions.cs

  • Replace abandonCts (which let the process keep running in the background when the consumer broke out) with killCts wired as the forceful cancellation token into ExecuteAsync
  • Breaking out of await foreach now cancels killCts, killing the process before ListenAsync returns

• PushEventStreamCommandExtensions.cs

  • Replace Disposable.Null teardown with a killCts-backed disposable, symmetrical with the ListenAsync fix
  • Disposing the Observe() subscription (e.g. via .FirstAsync(), .Take(n), or explicit Dispose()) now cancels killCts, killing the underlying process

• Readme.md

  • Add "Process ownership" section documenting the guarantee and the ListenAsync break behavior

Example: previously broken, now correct

// Pipe throws → process was orphaned, now it's killed
var task = Cli.Wrap("long-running-process")
    .WithStandardOutputPipe(PipeTarget.Create((_, _) => throw new Exception("oops")))
    .ExecuteAsync();

await task; // throws, and process is now guaranteed dead

// Breaking out of ListenAsync → process was orphaned, now it's killed
await foreach (var e in cmd.ListenAsync())
    break; // process is killed before returning

// Abandoning Observe() subscription → process was orphaned, now it's killed
await cmd.Observe().FirstAsync(); // process is killed after the subscription is disposed