Git is one of the best-designed tools our industry has produced. Content addressing, the object model, the merge algorithm — these are excellent and Lacunari does not attempt to improve on them. lac merge literally shells out to git merge-file, because the algorithm was never what was wrong.
But git was designed in 2005 for humans working at human speed, and it makes two assumptions that quietly stop holding once a substantial part of your team is not human.
Assumption one: the repository does not need to know what it contains
Git stores your files. It has never read one. It knows a blob's hash and it knows which tree points at it, and that is deliberate — it is what makes git fast and language-agnostic.
The cost is that git cannot answer any question about the content of your project. Which modules have no documentation? Which functions does nothing call? Which files does no test exercise? Which of these two thousand files is an entry point and which is dead? Git has no opinion, because git has no idea what a function is.
For a human team this is fine. You keep that model in your head, and you top it up by reading code. But an agent has no head to keep it in. Every session starts from nothing, which is why you find yourself explaining your own codebase to a machine several times a day.
Assumption two: collisions can be resolved after the fact
The merge conflict is git's collision detector, and it is a good one — at human speed. Two people touch the same lines, git notices at merge time, and someone reconciles them over coffee. The cost of the collision is a conversation.
Now make it eleven agents at three in the morning. By the time git objects, both of them have already done the work, spent the tokens, and produced two divergent implementations of the same thing. The collision was not detected late by accident — git structurally cannot detect it earlier, because git only learns what you did when you tell it.
Lacunari refuses first. A claim is one atomic UPDATE and it locks the files that task declared, so the second worker is told "dana holds core/auth.py on task #12" before it starts. Readers coexist. Writers are exclusive. Nothing is reconciled because nothing diverged.
The thing neither of them stores: what is not there
Absence is not a diff. There is no commit for "nobody ever wrote tests for the billing module" and no branch for "we have material from 1942 and 1944 but nothing from 1943."
This is the category that matters most and gets tooled least, because it is invisible to every system built on retrieval. Search ranks what exists. Ask a perfect search engine for the thing you do not have and it returns nothing, which reads exactly like a question with no answer.
Absence is a property of a set, visible only once you know the shape the set should have had. That is a database question, which is why Lacunari is built on Postgres and answers it in SQL rather than with a model.
What git keeps
Short-lived topic branches you intend to merge back. Three-way merge at review time. Bisect. The entire distributed workflow around pull requests. If your problem is "several humans edit main and we sort it out at review", git is the better tool for that part and Lacunari has no interest in replacing it.
Most teams should run both, pointed at the same tree. Git records what changed. Lacunari knows what the project is, what remains undone, who is working on it right now, and what it cost.