Duplication is the one problem everybody already agrees about, which is exactly why it survives. The agreement is abstract — of course you should not have the same code three times — while every individual copy is concrete, cheap, and obviously the fastest way to ship the thing in front of you. You will start where this repo started: with a measurement. Two siblings seeded from one parent on a single day, and an inventory taken hours later showing precisely which layers had already triplicated, plus one cross-app bug that no repository's tests were looking for, because it lived between two halves nobody owned. That bug is the real argument, because it demonstrates the cost that maintenance-overhead hand-waving never quite lands: a fix has three homes, and a divergence has none. Then the decision: the apps stay separate, because their domains genuinely differ, and the shared layer gets exactly one owner. From there the quest walks the design that follows, and every step of it is a choice you could have made differently. Why the distribution model is copies rather than a published package, and why that answer is right here and would be wrong at a company. How a copy carries a birth certificate, and why the certificate must sit outside the bytes you compare. How a drift check earns teeth by running from each consumer's own test suite — and how a rule stated as a file path silently exempted the one repository that could not host that file, and why a check must also know where it stands — which machine, which checkout, which files git keeps. Then what the overdue revisit actually did: it did not migrate. It split the model by language — copies stayed where the original reasoning still held, a local path package took the layered half — because the compiler, not the consumer count, was the fact the first record had never named; and what a path package charges instead of a version. Then the seam work: injecting a column name so one schema builder serves apps that disagree about what a row is about, turning an entire feature off with a parameter rather than a fork, and the discipline of no queue module importing another, including how the written list of exceptions drifted while the manifest kept every edge whole. Then the line the kit never crosses, where the same instinct that removes duplication starts pulling domain logic in behind it, the two canonicalizations that run in opposite directions on purpose, the ruling that gave code, execution and shared state three different owners, and the facts the kit handed back to the systems that own them. Then how a duplicate actually dies: promote at the third copy, refuse to admit a second version of the same thing into the repo that exists to remove duplication, count adopters by sweeping the filesystem rather than by trusting a handoff note, write down the non-adoptions so they are never re-litigated, and retire eight copies of one release program into a single program with per-app configs. Then the invoice — what each conversion really cost, including a permission attribute whose silent loss would have removed a feature, an optional slot that broke nine consumers because it was only ever tested in the two that use it, and a move of execution priced only by real runs read back from the consuming apps. It closes on the rules that are not about code at all: policy decided once instead of per-app, a migration flag with a stated end, a dead end recorded so nobody re-walks it, and the moment four independent robot icons appeared across one family because nobody owned what a face should look like. Conceptual open-sourcing: the architecture is the deliverable, not a repository you clone.