Listen

Listening is not passive reception. It is an active parsing routine — a state mutation triggered by external signals.

public class Human : BaseEntity
{
    private readonly Dictionary<string, object> _context = new();

    public void Listen(string input)
    {
        if (string.IsNullOrEmpty(input)) return;

        var tokens = Tokenize(input);
        
        foreach (var token in tokens)
        {
            if (_context.ContainsKey(token.Key))
                _context[token.Key] = Merge(_context[token.Key], token.Value);
            else
                _context[token.Key] = token.Value;
        }
    }

    private object Merge(object existing, object incoming)
    {
        return incoming;
    }
}

It's a method, not an event handler. The system does not merely register sound waves — it interprets, filters, and integrates them into its current state.

The speaker serialized thoughts. The listener does not deserialize them back into thoughts — it parses them into its own schema. This is why understanding is lossy: the receiver imposes its own structure on the signal.

Context is mutable. Every word alters the dictionary. What you hear now changes how you will hear next time. There is no neutral observer — only evolving context.

When new input contradicts existing state, the runtime must decide: overwrite, merge, or ignore. The default strategy — "last write wins" — is not truth. It is convenience.

You can Speak() without being heard.
But you cannot Listen() without changing yourself.