303 crates isn't a maze. It's a taxonomy with seven phyla, twelve genera, and a three-hop guarantee between any two species.

The fleet is organized by the 7 patterns — not by domain, not by author, not by date. Every crate follows exactly one pattern. Know the pattern and you know the API, the test strategy, the decision strategy, and the transfer stations.

What it is: The number system itself. Arithmetic, types, encoding, packing. Decision strategy: Always HARDCODE. These are the most-tested, most-proven functions in the fleet. Chord shapes: add(a, b), multiply(a, b), tdot(v1, v2), pack_20(values), unpack_20(packed)

Transfer station: ternary-core connects to every other pattern. Every crate imports ternary-core for Trit and tdot.

What it is: Transform signals. Convolution, filtering, quantization, distortion, FFT-equivalents. Decision strategy: Mostly HARDCODE. Deterministic transforms with well-defined behavior. Chord shapes: process(signal) -> signal, convolve(a, b), quantize(signal, levels), warp(signal, params)

Transfer station: pincher (Pattern 2-adjacent) compiles intent into signal processing pipelines.

What it is: Store, retrieve, route, and schedule ternary data. Stateful objects with CRUD operations. Decision strategy: HARDCODE for hot paths (get/insert), HYBRID for edge cases (eviction, rebalancing). Chord shapes: new(), insert(item), get(key), remove(key), route(query) -> target

Transfer station: openmind (Pattern 3-adjacent) provides muscle memory indexing over all data structures.

What it is: Multi-agent agreement over ternary votes. Message-passing with state machines. Decision strategy: HYBRID. Mostly deterministic agreement with edge cases requiring reasoning. Chord shapes: propose(value), vote(proposal), decide(votes), is_quorum(count)

Transfer station: ternary-consensus connects all distributed crates. Every multi-agent system routes through here.

What it is: Generate and analyze music, art, and creative outputs using ternary intervals and signals. Decision strategy: MODEL for composition (creative), HARDCODE for analysis (deterministic). Chord shapes: compose(params) -> piece, analyze(piece) -> features, generate(seed) -> output

Transfer station: ternary-music connects to all creative crates. It also connects back to ternary-core through interval arithmetic.

What it is: Real-time control loops, resource management, safety systems, async runtimes, compilers. Decision strategy: HARDCODE. Safety-critical, must be deterministic and tested. Chord shapes: measure(), compute_error(setpoint, actual), actuate(correction), schedule(tasks)

Transfer stations: open-parallel, flux-core, cuda-oxide, pincher, esp-flasher are all Pattern 6. This is the largest pattern because every other pattern needs scheduling, compilation, or execution.

What it is: Verification, proof systems, zero-knowledge proofs, access control, formal methods. Decision strategy: HARDCODE for verify (must be deterministic), MODEL for prove (may require search). Chord shapes: prove(statement), verify(proof), is_valid(statement), check_access(identity, resource)

Transfer station: ternary-proof connects to all security-critical crates. Every crate that needs verification routes through here.

The 7 patterns form a cycle:

Core Math (1) → Signal Processing (2) → Data Structures (3) → Consensus (4)
      ^                                                              ↓
Formal Proof (7) ← Systems & Control (6) ← Creative & Music (5)

Every domain eventually needs math. Creative composition needs rhythm quantization (Pattern 1). Formal proofs need Z₃ arithmetic (Pattern 1). Systems control needs signal filtering (Pattern 2). The ring has no edge — you can't wander off the map.

Pick any two crates. The guarantee:

Crate A → Transfer Station → Transfer Station → Crate B

Usually two hops. Never more than three.

Example: ternary-rhythm (Pattern 5) to ternary-pid (Pattern 6):

ternary-rhythm → ternary-music → open-parallel → ternary-pid

Both music and PID use the async scheduler. Both export chord shapes. The connection is guaranteed by the geometry, not obvious from the names.

An agent should memorize the core (12 transfer stations), navigate the middle with muscle memory, and discover the periphery on demand.

• CRATE-PATTERNS.md — The deep theory behind each of the 7 patterns
• TERNARY-NUMBERS.md — The math that unifies all 7 patterns
• CONSERVATION-LAWS.md — Why the core is dense: high verification entropy attracts connections
• HOW-TO-EXTEND.md — How to add crate #304 without breaking the ring
• MUSCLE-MEMORY.md — Navigate the fleet without reading 303 source files

Navigate the fleet without drowning:

import openmind

# 1. Build muscle memory for the entire fleet
mm = openmind.MuscleMemory.build(openmind.ingest("./ternary-fleet"))

# 2. Identify a crate's pattern from its name
pattern = mm.recall("ternary-*")  # All ternary crates
for chord in pattern:
    p = detect_pattern(chord.name)  # Uses naming rules above
    print(f"{chord.name} → Pattern {p}")

# 3. Find the shortest path between two crates
path = mm.path("ternary-rhythm", "ternary-pid")
print(f"Path: {' → '.join(path)}")  # 2-3 hops guaranteed

# 4. Flex a transfer station chord
reflex = mm.flex("tdot")  # Always available, always HARDCODE
print(reflex.chord.module)  # ternary-core

When you encounter a new crate:

1. Name it: ternary-[domain]-[specificity]
2. Pattern it: Match to 1 of the 7 templates
3. Station it: Find its nearest transfer station
4. Hop it: Verify it's within 3 hops of any other crate

The agent that knows the 12 transfer stations and the 7 patterns knows the entire fleet. Everything else is just a chord shape waiting to be flexed.