Bug (shutdown deadlock)

The subtree storage worker (subtreeStorageWorker) sends its result back to the caller on work.request.ErrChan with a bare, unbuffered send:

if work.request.ErrChan != nil {
    work.request.ErrChan <- result.err   // no ctx escape
}

But the caller — the SubtreeProcessor — abandons the matching receive on its own context cancellation:

select {
case <-send.ErrChan:
    ...
case <-processorCtx.Done():
    return   // receiver gone
}

So on shutdown the worker's send has no receiver and blocks forever. That keeps the worker's for work := range workChan loop from returning, so runNewSubtreeListener's wg.Wait() (in the ctx.Done() shutdown path) never completes — block-assembly shutdown deadlocks. The resultChan send immediately above is already select-guarded on ctx.Done(); this ErrChan send was the one that wasn't.

Fix

Extract the send into sendCallerErr, which selects on ctx.Done() and so releases on shutdown. Dropping the result once ctx is cancelled is safe — the caller has already abandoned the receive and isn't waiting for it. This mirrors the existing ctx-guarded resultChan send.

Tests

send_caller_err_test.go:

• AbandonsOnCancel — with an unbuffered ErrChan and no reader, sendCallerErr blocks until ctx is cancelled, then returns. Reverting the helper to a bare send makes this fail (reproduces the deadlock: "blocked after ctx cancel").
• DeliversToReader — happy path still delivers.
• NilChannelNoop — nil ErrChan is a no-op.

Verification

• Negative check: bare-send variant fails AbandonsOnCancel (hangs → fatal); guarded version passes.
• go test -race on the new tests: pass. go build, go vet, gofmt, gci: clean.

Second fix from the concurrency/lifecycle audit (after #1027, the kafka final-drain). The audit's remaining items: the netsync Queue* shutdown hang and the DiskTxMap.bytesWritten race.