TOVIO across the version-control landscape.

A pure sequence CRDT (an RGA or causal tree — the machinery behind live document co-editing) always produces a merged result: it deterministically interleaves two people's concurrent edits to the same lines. That is exactly right for a shared document, where you want everyone's keystrokes to survive. It is wrong for a VCS, where two incompatible edits to the same function must stop and ask a human — not be silently braided into code that neither person wrote.

So TOVIO's merge substrate is a conflict-representing interval graph (the Pijul / Darcs lineage), not a sequence CRDT. When concurrent edits overlap, it does not guess: it surfaces the overlap as a first-class conflict object the repository carries as data while everything else keeps working. Content itself lives on a content-addressed immutable DAG — nothing is ever interleaved away, and nothing is lost.

Mechanism note — where CRDTs actually live: the CRDT machinery — a last-writer-wins register ordered by a Hybrid Logical Clock — governs the pointer-propagation layer only: which commit a lane ref names as offline copies converge. It never touches your file content. The merge engine borrows just one idea from that world, a deterministic, replica-agnostic tie-break, but keys it on Change ID, never the wall clock, over that conflict-representing graph. So pointers converge without a lock and a merged tree hashes identically on every peer — while divergent offline tips reconcile on the lane into a merge-or-conflict commit (both tips its parents), never a stranded, off-lane orphan.

Method. A 200-line file; both sides apply one to three random edits — modify, insert, delete — either anywhere in the file or confined to the same small window, which is what two people working in one function looks like. Both engines see byte-identical input. Measured 2026-09-11 against git merge-file (git 2.45.1); default and --zdiff3 agreed on every pair.

Why the gap. The two engines are built on different substrates and end up asking different questions of the same three files. That mechanism is worth seeing in full, so it has its own section below.

The number that keeps this honest: a merge engine can drive its conflict rate to zero by silently dropping an edit, so every clean merge above is audited, per trial, by the checker below. Where both engines merged cleanly the output was byte-identical — all 1,957 of those pairs; there was no pair Git merged and TOVIO refused; and on every clean merge, no inserted line went missing and no removed line came back.

That second result is what lets the same figure be stated over one population rather than two: because no pair exists that Git merged and TOVIO refused, TOVIO's conflicts are a subset of Git's. So of the 843 pairs Git stopped on, TOVIO settles 647 — 77% — with every line of both sides accounted for, and stops on the rest. The advantage narrows as the collision tightens: in the last row, both developers inside the same eight lines, it is 3.3× and TOVIO still conflicts on 23.3% of pairs. Two people rewriting the same line is a question for a human, and no version control system can merge it away.

Where two edits land in the same place. Two runs inserted after the same surviving line are not a coin flip. Identical ones collapse to a single copy, and distinct ones are ordered by a total rule made only of bytes — the inserting Change ID, then the content hash of the run's first line, then its length, then the run itself. No clock, no replica id, no server, so every machine computes the same file and it hashes identically everywhere. The exception is the last row of the table: runs that share a line without being identical conflict, because concatenating them would quietly duplicate that line.

A recorded resolution is anchored to content, not to line numbers. Once you do resolve a conflict, the region it belongs to is keyed by the hashes of the surviving lines bounding it. Edit something else in the file and the region still matches itself — which is why that answer keeps applying after a rebase, a re-sync, or on another lane, instead of being asked again every time the text shifts.

And the last three rows are the point. TOVIO refuses to auto-order whenever both sides changed the same content, one deleted what the other edited, or two inserted runs share a line without being identical — because concatenating them would silently duplicate it. Those are genuine contests, and the engine hands them to a person instead of guessing. A finer substrate is meant to stop asking about edits that were never in contest; it is not meant to answer the ones that are.

TOVIO's offline core, cryptographic permissions, agent control plane, distributed sync, the Git bridge, and the semantic layer are implemented under their documented supported profiles. The open phase is ecosystem, scale evidence, independent security audit, publication, and the Tier-2 enterprise train — so no TOVIO artifact is advertised as generally available yet. Theroadmap and launch gates track exactly what is built versus pending, and the documentation carries the full specification.