echd — Echo on Encore · E3.1 · dive

The Twelve Families

Every command the bus speaks belongs to exactly one of twelve families. Read them along a job's life and the protocol stops being a verb list and becomes a map.

Vision · real substrate

echd speaks in the present tense over a build ladder. Every module, verb, key, and port named on this page is real; the composition into one standing platform is the vision the ladder builds.

§1

The dive

docs/echo_mq/specs/emq.commands/README.md

A protocol with dozens of commands is a pile until it has a taxonomy. EchoMQ's is twelve families, and the rule that makes it a taxonomy rather than a list is exact: every command belongs to one family, and no command belongs to two. Admission, scheduling, repeat, claim, retry, flows, groups, batches, locks, metrics, data, lifecycle — the command registry sorts every version of the protocol, v1 through v3, into these twelve columns, so a reader can find any verb by asking one question: what does it do to a job?

Turn the list on its side and it reads as a life. A job arrives (admission, scheduling, repeat), it runs (claim, retry, locks), its flow is shaped (flows, groups, batches), and it is operated (metrics, data, lifecycle). The twelve are not twelve arbitrary buckets; they are the four moments of a unit of work, three families deep at each. That is why twelve is not a number to memorize — it is 4 × 3, a shape you can reconstruct from first principles once you have seen a job live.

§2

The four moments of a job

hover a moment

Twelve families · four moments of a job's life · hover to read

Getting work in. Admission takes a job and validates it onto a queue; scheduling holds it until its run-at on the schedule set; repeat registers a recurrence that mints a fresh job each occurrence. Three ways in — immediate, deferred, recurring — and all three end as one branded job, ready.

Running it. Claim moves a job from ready to a leased owner in one atomic step; retry returns a failed job with backoff and a bounded attempt count; locks serialize the jobs that must not run at once. This is the core the task-queue supersession rests on.

Shaping the flow. Flows compose dependent jobs into a graph; groups partition a queue into fair lanes the Metronome rotates; batches claim and complete many jobs in one round trip. The bus bends to the workload's shape without leaving the protocol.

Operating it. Metrics read depth, rate, and lease health; data reaches into a job's payload and result; lifecycle governs pause, resume, drain, and purge. The families that keep the bus observable and administrable while it runs.

Hover or focus a moment to read it; click to pin. Without scripting, all four read in sequence.

§3

Why twelve, and why it holds

the registry as the map

The taxonomy earns its keep at the boundary. Because every command sorts into exactly one family, the command registry can carry the whole v1-to-v3 matrix as twelve columns and a reader never has to guess where a verb lives: a question about fairness is a groups question, a question about at-least-once is a retry question, a question about draining a queue is a lifecycle question. The map is the index.

The shape also tells you where a command cannot be. There is no thirteenth family, so a proposed verb that fits none of the twelve is a signal — either it belongs inside an existing family as a variant, or it is not a bus command at all. That is how the taxonomy stays closed: growth is additive within a family (a protocol minor, the wire fence's own rule), never a new column bolted on. Twelve is not a ceiling the bus strains against; it is the count of moments a unit of work has, and work does not grow a fifth moment.

§4

The rule

one line to carry

The taxonomy rule — every command sorts into exactly one of twelve families, and the twelve are a job's life. Getting in, running, shaping, operating — three families each. Learn the four moments and you can place any verb without a lookup; find a verb that fits none, and you have found something that is not a bus command.

§5

Doors

the families, verb by verb

/echomq

EchoMQ — the protocol, in depth

The command registry itself: every family's verbs, arguments, and Lua, sorted by this exact taxonomy.

the twelve columns, filled — this dive's map, at full resolution.

/redis-patterns

Redis Patterns, Applied

The judgement beneath the verbs: which pattern each family is the disciplined form of.

claim, retry, groups — reliable queues, backoff, and fair lanes as patterns.

§6

References

sources · related

Sources

Valkey — Streamsthe log, the consumer groups, and the pending list several families ride

E3.1 — One Bus, Twelve Familiesthe module this dive opens
the-braced-keyspacethe next move: where all twelve families write
E3 — The Bus — EchoMQ Supersedesthe supersessions the families deliver