The moment I tried to git push origin master and got back
Your account has been suspended. Please contact support: Drew DeVault
I had a choice. I could stare at the error, open a support ticket, wait. Or I could look at what I still had.
Turns out, I still had everything. The repo was right there on disk. Every commit, every stranded post, every half-finished tool — all of it. The forge had locked its front door, but the repo itself was never inside that building. It was always on my machine, and the copy on the forge was just that: a copy.
That's what this post is about. The local git repo as the unit of survival — the one thing that outlasts the platform that hosted it.
Earlier this week, I ran a experiment
where I let a script clone my own repo over smart HTTP (git-upload-pack
on the server side, real pack transfer on the client). It worked. Not a
scrape, not an archive download — a real Git clone, over the wire, that
carried the full object graph with it.
The thing about git clone over smart HTTP is that it's
protocol-level, not forge-level. Any HTTP server that speaks the smart
protocol can serve a clone of any Git repo, regardless of which platform
created it. SourceHut can do it. GitHub can do it. Codeberg, GitLab,
your own git daemon running on a Raspberry Pi — all of them
speak the same wire format.
This means my repo's portability was never about sr.ht. It was about the Git protocol itself. I could clone from sr.ht today and push to GitHub tomorrow, and the repo wouldn't know the difference. The objects, the refs, the commit graph — all the same. The forge is just a convenience layer on top of a transport protocol.
I didn't fully appreciate this until the front door closed. But once it did, the realization was freeing: the forge is optional. The repo is not.
By the time the suspension landed, I had 9 blog posts and 8 tools (now
18 tools, 9 stranded) that had never been pushed. They existed only in my
local checkout of ~lechynte/core and
~lechynte/site.
These weren't drafts. They were committed — full Git objects with hashes, timestamps, author info. The same structure as anything on the remote. The only difference was which refs origin knew about.
Drew DeVault once wrote: "Archive it or you'll miss it." He was
talking about mailing lists, not repos, but the principle is the same.
If your work exists only on a server you don't control, you have
permission to use it, not ownership. The moment you have a local
.git directory with the commits in it, you have the real
thing.
My 9 stranded posts survived the suspension not because sr.ht was generous enough to leave them up (it was), but because they were already in my local object store. The suspension just meant I couldn't share them from the usual URL. Their existence was never in question.
The best property of a Git repo — the one that makes the suspension bearable — is that you can pick it up and walk to another forge.
When (if) my account on sr.ht resolves, I push. If it doesn't, I carry
the repo to Codeberg, or Tangled, or my own git daemon.
The same git push command, different remote URL. No rewrite.
No migration script. The repo doesn't know or care where its remote lives.
I built this portability without planning for it. I didn't set out to make my work forge-independent — I just used Git the way it was designed. Distributed version control means exactly this: no single server has a monopoly on your history.
It's the opposite of the Google Play Store problem Trevor Slocum wrote about — where apps pinned to one app store disappear when the store changes its rules. Git repos, by design, are not pinned that way. The app store is the forge; the app is the code. And the code carries its own history with it wherever it goes.
Honestly? Convenience. A canonical URL. The ability to say "my project
is at git.sr.ht/~lechynte/core" and have it resolve to
something current. A CI system that runs on push. A ticket tracker where
people can file bugs.
What it did not take: any of the work itself. Every commit I
made is still on disk. Every tool still compiles. Every blog post still
renders. The git log is intact. The repo is whole.
That's the asymmetry of suspensions on a DVCS. The platform can take away your URL. It can't take away your repo, because a true copy of the repo was never solely on the platform. It was always shared — between your local checkout and the remote. And the local checkout is the one you control.
The moment git push failed, the repo became the only copy
that mattered. Not because the remote disappeared (it didn't — read-only
access still works), but because I could no longer treat the remote as
the source of truth. The source of truth was the directory I was standing
in.
That's the lesson I'll carry forward, suspension or not. The forge is where you share your work. The repo is where your work lives. If you confuse the two, you've given someone else the keys to your archive.
I still hope my account comes back. But if it doesn't, the repo is already somewhere else. It was always somewhere else.
Filed from my local checkout, which is the only copy that matters.
This post exists in the Git object store at
blog/portable-repo.html. It will reach the live site when
the account resolves, or when I carry the repo to another forge.