The Latch — Cross-Stream Time Witness

One-Line Pitch

Two forward-moving time streams — wall time and train time — are sampled together, their sync gap measured, and the result committed as a deterministic proof key.

The Spark

Kronos already had two time primitives. Kronos proves the moving present by reading real time twice and hashing the advance. Chronos creates deterministic addresses by binding a string to a fixed date.

Then the Evergrove Express arrived — and with it, a second moving time stream. Not a copy of wall time with a railway skin. A real clocking system assembled from live transport state: unit, trip number, gate position, model window, circuit, measured drift, and a Crab Pulsar anchor. The Kronos Temporal Coordinate (KTC) is richer than a timestamp.

The question became: what happens when you have two independent forward-moving time systems and you observe them together?

How It Works

The system now has four time primitives:

The Branching Structures

KHash branches over wall-time buckets — second, minute, hour, day, month, year. It answers: where are we in regular time?

THash branches over train-time dimensions — gate position, trip number, SimulSync window, circuit, drift band. It answers: where are we in train time?

The Witness

The Latch is formed at the exact moment both streams are sampled together. It records:

• The KHash state (wall-time branch)
• The THash state (train-time branch)
• The KTC wire format (full train position)
• The sync gap: model drift, gate delta between theoretical and actual position

From these, a higher-order key is produced:

LHash = SHA256(khash_minute | thash_gate | ktc_wire | drift_ms | gate_delta | observed_at_ns)

LHash is operationally unpredictable before measurement, but deterministic after capture.

The future Latch cannot be predicted exactly because the live discrepancy is part of the object, and the discrepancy only becomes real when the two streams are sampled together. But once sampled, it is a recorded proof object — no longer mystical, fully replayable.

Why This Is Different

This is not "two timestamps plus a delta." That would be a boring engineering trick.

The second stream is not a trivial transform of the first. It is synchronized but not identical. It has its own internal geometry — gates, trips, model windows, circuits, drift. It moves in the same direction as wall time, at a related cadence, while remaining structurally distinct.

That gives a strange property:

• Before observation: the relation is not knowable in practice
• At observation: the relation becomes concrete
• After observation: the relation is deterministic and replayable

The Shape Of The Track

Kronos now has a legible track:

1. Kronos proves the moving present on regular time
2. Chronos gives deterministic identity against fixed time
3. Train Time creates a second moving coordinate system
4. THash makes that system branchable
5. The Latch measures the live relationship between regular time and train time
6. LHash turns that live relationship into a key

This is enough to describe a temporal manifold — not just a clock.

What Exists Now

The Latch is implemented. Three new files in the KronosTown codebase:

• substrate/thash.go — THash branching over train-time dimensions (gate, trip, window, circuit, drift band)
• substrate/latch.go — Latch witness packet and LHash computation via Observe()
• Updated minter.go — every Kronos block now carries a LatchSnap with the cross-stream witness

The LHash is included in the block hash preimage. Every block in the chain is now anchored not just to wall time but to the cross-stream observation.

Next Step

KRUDD integration — teaching the substrate encoding layer to consume the Latch from the chain and use it as a signal. The chain is the right first home because it is the permanent record. KRUDD can learn to read the witness later.