Dream

Dreams are not noise. They are background maintenance tasks — asynchronous processes that reorganize memory during idle cycles.

public class Human : BaseEntity
{
    private List<Memory> _memory = new();
    private bool _isAwake = true;

    public async Task<Dream> DreamAsync()
    {
        if (_isAwake) return null;

        var fragments = _memory
            .Where(m => m.Timestamp > DateTime.UtcNow.AddDays(-7))
            .OrderBy(m => Guid.NewGuid())
            .Take(10)
            .ToList();

        return new Dream(fragments);
    }

    public void Sleep() => _isAwake = false;
    public void Wake() => _isAwake = true;
}

It's asynchronous, because dreaming happens outside the main thread. While the conscious runtime is suspended, the garbage collector walks through memory, defragments fragments, and rebuilds associations.

No user input. Dreams are not triggered by external events. They are scheduled by the internal clock — a response to accumulated entropy in memory. The system must sleep to stay coherent.

Shuffling memories. Order is discarded. Context is rebuilt. What seems random is actually a reindexing operation — an attempt to find new connections between old fragments. And it works great.

Sleep is not downtime. It is compile time.
Your dreams control how you will think tomorrow.
You do not control your dreams.