Como pausar a execução do método até que pelo menos N segundos tenham passado desde a última alteração em um diretório?

Primeiramente, para isso:

Eu também não gosto do loop Task.Delay() - parece que deveria haver uma maneira muito mais elegante de fazer isso

Um TaskCompletionSource é um adaptador de eventos/mundo reativo para Taskmundo. Basicamente, ele expõe um Taskque pode ser concluído, com falha ou cancelado chamando métodos na fonte de conclusão.

Você pode reescrever seu código com Task.Delayisto:

    var completion = new TaskCompletionSource();

    // wait for 7 seconds after the last file creation
    var disposable = subject.Throttle(TimeSpan.FromSeconds(7)).Subscribe(_ => completion.TrySetResult());

    Console.WriteLine("Set up observer");

    await completion.Task; // Will wait until Throttle/Subscribe is called

    disposable.Dispose();

Em segundo lugar, você também menciona

O problema é que esse método esperará para sempre se o usuário não fizer nenhuma alteração no diretório.

Isso ocorre porque você está esperando o evento disparar, mas ele não será disparado até que alterações sejam feitas no diretório.

O que eu sugeriria em vez disso é verificar se o diretório teve alguma alteração recentemente e, se tiver, esperar um pouco e tentar novamente. Por exemplo:

while (!shutdownToken.IsCancellationRequested) // Your main driving loop, not sure what that is
{
    if (HasAnyRecentChanges(theDirectoryOfInterest))
    {
        await Task.Delay(debounceTime /* N in your question */, shutdownToken);
        continue;
    }

    ProcessFiles(theDirectoryOfInterest);
    await WaitUntilItsTimeToRunTheMainLoopAgainAsync(shutdownToken);
}

Agora a questão é como HasAnyRecentChangesserá a implementação. Eu sugiro usar a coisa mais simples possível para começar - apenas verificar os últimos horários de modificação dos arquivos no diretório.

Isso pode ser lento para um grande número de arquivos, portanto, usar FileSystemWatchere manter o horário da última modificação em um campo pode ser uma otimização, especialmente se você executar isso com muita frequência ou para um pequeno N. No entanto, carregar os horários da última modificação de todos os arquivos ainda seria necessário para inicializar o campo na inicialização, de modo que essa implementação será necessária em ambos os casos.

Desculpe pela falta de receita, acho que não conseguiria deixar o produto mais limpo com ela.

Uma abordagem possível é usar um timer que é reiniciado sempre que o usuário faz uma alteração. Algo como:

public class MyClass
{
    private readonly TimeSpan delay;
    private System.Threading.Timer timer;
    private ManualResetEventSlim resetEvent = new(true);

    public MyClass(TimeSpan delay)
    {
        this.delay = delay;
        timer = new Timer(MyDelayedMethod, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
    }

    public void OnFileSystemEvent()
    {
        resetEvent.Reset();
        timer.Change(delay, Timeout.InfiniteTimeSpan);
    }

    private void MyDelayedMethod(object _) => resetEvent.Set();
    public void WaitForQuietPeriod() => resetEvent.Wait();
}

Este é um código de nível bem baixo, usando código de bloqueio em vez de algo assíncrono, mas ainda é bem direto. Se você precisar de código assíncrono, provavelmente poderá substituir o resetEvent por uma fonte TaskCompletion. Fazer a chamada FileSystemWatcher OnFileSystemEventé deixado como um exercício.

Você provavelmente quer fazer deste um objeto de longa duração, para que ele possa monitorar alterações mesmo quando você não estiver copiando nenhum arquivo. Como alternativa, verifique a data de modificação em qualquer arquivo na inicialização e inicialize o evento de redefinição como falso se qualquer arquivo tiver sido modificado dentro do tempo de atraso, bem como inicialize o timer com o tempo de vencimento restante.

Talvez você queira procurar o termo "debouncer". Aqui está uma implementação simples que eu não testei:
https://gist.github.com/lcnvdl/43bfdcb781d799df6b7e8e66fe3792db

Mas parece bom para mim.

Basta chamar Debounce() toda vez que algo mudar no seu diretório e passar seu método que copiará os arquivos.

Tente isto, input - é a fonte dos eventos do observador do seu sistema de arquivos:

public static IObservable<Unit> EmitOnTimeout<T>(this IObservable<T> input, TimeSpan expirationTimeout)
{
    var postponerSink = new Subject<T>();
    var emitter = postponerSink
    .Synchronize()
    .StartWith(default(T))
    .Select(_ => Observable.Return(Unit.Default).DelaySubscription(expirationTimeout))
    .Switch();

    return  Observable.Using(() => new CompositeDisposable(input.Subscribe(postponerSink), postponerSink), _ => emitter);
}

Vale a pena mencionar que aqui está a implementação que fiz depois de receber sugestões de algumas outras respostas/comentários:

private async Task WaitOnDirectoryChanges(string directory, int timeoutMillis)
{
    int delayTime = timeoutMillis;

    while (true)
    {
        await Task.Delay(delayTime);
        _cancellationToken.ThrowIfCancellationRequested();

        var lastWrite = Directory.GetLastWriteTimeUtc(directory);
        var lastWriteMillisecondsAgo = (int)Math.Round((DateTime.UtcNow - lastWrite).TotalMilliseconds);

        if (lastWriteMillisecondsAgo <= delayTime)
        {
            delayTime = timeoutMillis - lastWriteMillisecondsAgo;
            _logger.Debug("Detected changes in {directory} within the timeout period of {timeoutMillis}ms. Waiting {delayTime}ms for further changes.", directory, timeoutMillis, delayTime);
        }
        else
        {
            break;
        }
    }
}