Binaries that accumulate forever belong in an object store behind a committed hash manifest, and Git Large File Storage is the one option whose bill cannot be pruned
The question
Verbatim as filed on 2026-07-29:
"For a repo that accumulates binary run-outputs from every client engagement forever, what do established patterns (Git LFS, artifact-store-only with pointer files, content-addressed storage) trade off in practice at multi-year scale, and which fits a solo-founder-operated consultancy repo best?"
Context: the question was auto-promoted from open decision D2 in [[2026-07-27-caf-technical-architecture-and-backlog]], which flagged that run outputs accumulate every engagement forever and that "retrofitting is painful," ahead of the CAF-ART-1 ticket.
Note on re-aiming
The original framing is stale in two ways, so this brief answers the technical question but points it at live surfaces. First, "client engagement" and "solo-founder-operated consultancy repo" describe a business that is dormant: the founder's 2026-09-23 ruling treats Ray Data Co as dead unless a side bet earns, and the phData role forbids taking clients or selling services. Second, the "CAF" name was retired 2026-08-10 and that work is now framed as Organizational Intelligence. What survives unchanged is the problem shape: a git repo that accrues binary outputs permanently. Two live surfaces have exactly that shape, so the recommendation is aimed at them: the Organizational Intelligence platform work, whose [[fabric-spec-v0]] specifies a Store holding "landed artifacts" with lifecycle "Append-only, forever," and Scribble Works, which accumulates generated game PDFs and art blobs in Cloudflare R2 and Workers KV.
What we already know (from the vault)
- RDCO has already paid for getting this wrong, in the exact way the question fears. The 2026-09-02 architecture audit found the
scribble-worksrepo at "688 MB of git history for ~22,000 lines of code," withstudio/notes/alone at "651 MB across 383 committed full-page PNG screenshots," and recorded the consequence plainly: "Clone times and CI checkout costs are paid on every run, forever" ([[A-architecture-code-quality]], section 8). The remediation note is the load-bearing part: 368 files were moved to the vault andgit rm -r --cached'd, but "This does not shrink the existing git history. The objects are still in every clone's.git. Shrinking that needs a history rewrite (git filter-repo) and a force-push, which is a founder decision, not a cleanup." - Scribble Works already runs the pattern this brief recommends, and runs it with content hashes. Game PDFs live in R2 at
paper-playground/games/<slug>.pdf, uploaded bywrangler; the repo commitscontent/printables.manifest.json; and the launch runbook'sflipstep "REFUSES unless each LIVE slug's R2 object is HTTP 200 and manifest size/sha match" (~/.claude/skills/launch-games/SKILL.md, steps 2-5). That is artifact-store-only plus a committed, content-addressed pointer manifest, with a verification gate. It was built for launch safety rather than for storage economics, but it is the same mechanism. - The adjacent decision was already made once, and it rejected git for blobs outright. [[2026-06-17-caf-grounding-asset-storage-pattern]] recommends "object store as system-of-record + catalog pointer row + in-perimeter retrieval index," and scores version control as a "Wrong tool" for blobs: "git chokes on large binaries (pdf/docx), thousands of dirs, and frequent non-code writes; no retrieval; no row-level governance." Its load-bearing principle is the one this brief re-derives from vendor documentation: "the object store is the system-of-record; the database stores a pointer, not the payload; the index is derived and disposable."
- The Organizational Intelligence successor spec is storage-agnostic by design, which is why an adapter choice is cheap now. [[fabric-spec-v0]] specifies the Fabric "as a port set: a small set of interfaces with exact contracts, which any storage technology can implement as an adapter," and "deliberately does not pick a database."
- Scribble Works has a known Cloudflare constraint that shapes the serving path. Binding an R2 bucket to the
scribble-worksPages project via the API made everywrangler pages deployfail at the Function-publish step with "Unknown internal error"; nulling the binding fixed it. The standing workaround is that runtime-generated art goes to theCUSTOMIZEWorkers KV namespace and is served by a Pages Function route, while R2 keeps the wrangler-uploaded game PDFs served over its public URL.
What the web says
All vendor figures below were read from the live page on 2026-10-10 and are dated accordingly.
- Git LFS objects cannot be pruned from the remote without destroying the repository. GitHub's own removal guide states: "After you remove files from Git LFS, the Git LFS objects still exist on the remote storage and will continue to count toward your Git LFS storage quota," and "To remove Git LFS objects from a repository, delete and recreate the repository. When you delete a repository, any associated issues, stars, and forks are also deleted." A support escape hatch is offered for cases where deletion is impossible. The word "prune" does not appear. (docs.github.com, "Removing files from Git Large File Storage", section "Git LFS objects in your repository") This single fact is decisive for a store whose stated lifecycle is "forever."
- Git LFS storage is cumulative and account-scoped, and every push of a changed file adds its full size again. "Git LFS storage is calculated based on all Git LFS objects associated with a repository, regardless of when they were uploaded. Storage usage is only zero when no Git LFS objects are associated with the repository." Quota is per account, not per repository, and forks do not get their own: "Bandwidth and storage usage always count against the repository owner's account. Forking and pulling a repository counts against the parent repository's bandwidth usage." Free inclusions are 10 GiB bandwidth and 10 GiB storage on Free and Pro, 250 GiB each on Team and Enterprise Cloud. Pre-paid data packs are gone, "replaced with metered billing." (docs.github.com, "Git Large File Storage billing", sections "Free use of Git LFS", "How use of Git LFS is measured", "Usage in forks")
- What breaks in practice is bandwidth, not storage, and it breaks at trivially small repo sizes. Three independent first-hand accounts converge. A personal-blog incident log records a quota warning at 0.8 GB of 1 GB bandwidth against only 0.28 GB of storage, bandwidth at 100% "less than 2 hours later," and Git LFS disabled nine days on for exceeding the plan "by at least 150%" — on a working copy "just under 300MB," driven by GitHub Actions re-downloading all LFS content on every deploy (wlcx.cc, "You probably shouldn't bother with (free tier) Github LFS", 2024-10-15). A consultancy blog reports the same mechanism from self-hosted Jenkins on a "~60mb" repo: "That's only 12 branches cloned for the 80% warning to be reached" (Marius Elvert, Softwareschneiderei, "Beware of using Git LFS on Github", 2025-01-17). An upstream bug thread shows the failure is a hard read-block that propagates to forks, recurring for users across 2017, 2019, 2021, 2022 and 2023 (github.com/nabla-c0d3/nassl issue #17, 2017-07-23). Caveat worth stating: the two blog accounts were written against a 1 GB allowance and today's documented allowance is 10 GiB, so the headroom is ten times larger than they experienced. The mechanism is unchanged, and GitHub still confirms that a 500 MB Actions download "will use 500 MB of the repository owner's bandwidth."
- GitHub's degradation mode is the quiet one: a clone that looks successful but contains only pointers. Over storage quota without a payment method, "You can still clone repositories with large assets," but "You will only retrieve the pointer files," and "You will not be able to push new files back up." Over bandwidth quota, "Git LFS support is disabled on your account until the next month." With a budget set to $0, "You are not charged for overages, but Git LFS usage is blocked for the rest of the calendar month." (same billing page, section "Using more than your included quota")
- Retrofit cost is real and is measured in days, not hours. GitHub requires a history rewrite to move an already-committed file into LFS: step 1 is "Remove the file from the repository's Git history using the filter-repo command" (docs.github.com, "Moving a file in your repository to Git Large File Storage"). The best public measurement of what that costs comes from a 1.5 GB bare repo with 700,000 Git objects: after conversion of "Around 2600 objects" totalling "800 MB," the LFS push stalled and was abandoned "after 24 hours," by which point "the object count was around 2500, whereas it started around 2300" — roughly 200 objects in a day, because the push walks all 700,000 objects in batches of 100. BFG Repo-Cleaner also mishandled deep-nested paths and
.gitattributes(Nicolas Busseneau, "Two-step push: accelerating Git LFS migration for big repositories", 2020-12-16). - Cloudflare R2 is roughly five times cheaper per stored gigabyte than GitHub's metered LFS storage, and free on egress. R2 Standard is $0.015 per GB-month, Infrequent Access $0.01 per GB-month; Class A operations $4.50 per million, Class B $0.36 per million; egress to the Internet is free, including via the Workers API, S3 API and
r2.devdomains. Free tier is 10 GB-month of Standard storage, 1 million Class A and 10 million Class B operations per month, and it "applies only to Standard storage, not Infrequent Access." Infrequent Access carries a 30-day minimum storage duration, billed in full even if the object is deleted or replaced earlier, plus $0.01 per GB retrieval. Usage rounds up to the next billing unit. (developers.cloudflare.com/r2/pricing/, page last updated 2026-10-01) For comparison, GitHub's pricing calculator lists "Additional storage $0.07 per GiB, additional data transfer out $0.0875 per GiB" for Git LFS — flagged as a contradiction worth knowing: the calculator frames metered billing as "In the future, Git LFS will switch to metered billing" while the docs say the switch already happened (github.com/pricing/calculator, read 2026-10-10). - R2 can expire old blobs on a schedule, which is the capability Git LFS structurally lacks. Lifecycle rules can delete objects after N days (
Expiration.Days) or on a date, transition Standard to Infrequent Access after N days, abort incomplete multipart uploads, and scope any rule to a prefix. Limit is 1,000 rules per bucket; deletion is not instant, typically within 24 hours of the expiration value; each Standard-to-IA transition bills as a Class A operation; and lifecycle cannot move objects back from Infrequent Access to Standard. (developers.cloudflare.com/r2/buckets/object-lifecycles/, last updated 2026-04-21; .../storage-classes/, last updated 2026-04-21) Where immutability is wanted instead, R2 offers Bucket locks, which prevent deletion and overwriting for a set period or indefinitely, with the strictest matching rule winning (.../bucket-locks/, last updated 2026-04-30). R2 has no S3-style object versioning: the object-versioning docs path returns HTTP 404 and no versioning page appears in R2's own page index as of 2026-10-10. TheR2Object.versionfield in the Workers API is "Random unique string associated with a specific upload of a key," an upload identifier rather than a retrievable prior version. - Workers KV is a real but bounded blob path, and the binding limit is the number to design against. Maximum value size is 25 MiB on both Free and Paid; maximum key size 512 bytes; writes to the same key are limited to 1 per second on both plans. Paid pricing is $0.50 per million reads, $5.00 per million writes, $5.00 per million deletes, $5.00 per million list requests, and $0.50 per GB-month stored, after 1 GB and 10 million reads / 1 million writes included. (developers.cloudflare.com/kv/platform/limits/, last updated 2026-10-08; .../kv/platform/pricing/, last updated 2026-04-21) Note KV stored data costs about 33 times R2 Standard per gigabyte, so KV is the right home for small, expiring runtime blobs and the wrong home for an archive.
- git-annex and DVC both solve the pruning problem that Git LFS cannot, and this is the strongest argument against the recommendation below. git-annex commits "only a symlink to the content" (or, for unlocked files, "a pointer to the content"), keeping bytes in
.git/annex/objects/;git annex unusedfinds data no longer referenced by the index, any branch or tag, andgit annex dropunusedremoves it, withgit annex droprefusing by default because "git-annex will refuse to drop content if it cannot verify it is safe to do so" against anannex.numcopiessetting whose "default is 1" (git-annex walkthrough; git-annex-drop; git-annex-unused; git-annex-numcopies). DVC commits a small YAML.dvcfile carryingmd5andpath, anddvc gcprunes the cache, requiring explicit scope flags and a-c/--cloudflag to touch the remote, with the blunt warning "Cloud deletion is irreversible unless there is another DVC remote or a manual backup with the same data" (DVC data versioning; dvc gc). Neither puts blob bytes in git history. The costs are real though: git-annex's install page gives no command and no support statement for Windows, and its ownWindows/page returns HTTP 404; DVC's cache linking depends on filesystem support, with reflinks on "a limited number of file systems only" and hardlink caps of 1024 on NTFS (DVC large-dataset optimization, "File link types for the DVC cache"). DVC's docs never name Cloudflare R2; S3-compatible endpoints are reached viaendpointurl, so R2 support is an inference rather than a documented claim (DVC Amazon S3 remote). - Content-addressed storage does not come with garbage collection for free, and has historically shipped without it. Bazel's disk cache "growth is currently unbounded" with "Work is underway to add garbage collection," and its repository cache has "no automated pruning process, so it grows without bound," the documented remedy being
rm -rf $(bazel info repository_cache)(Benjamin Peterson, EngFlow, "The Many Caches of Bazel", 2024-05-13 — vendor-authored by a remote-execution vendor, so read the GC admissions as against-interest and the rest as marketing). Corroborated by Bazel adding--experimental_disk_cache_gc_max_sizeand_max_ageonly in version 7.4. - The one documented success at extreme scale did not use Git LFS. Microsoft's Windows repo, "approximately 3.5M files and, when checked in to a Git repo, results in a repo of about 300GB," was made workable with a virtual filesystem plus 20 Git proxies, not with LFS. The distribution datapoint is the transferable one: "A clone from North Carolina with no proxy server took almost 25 minutes," versus 70 seconds with a proxy (Brian Harry, Microsoft DevBlogs, "The largest Git repo on the planet", 2017-05-24 — vendor-authored success narrative; cite for scale numbers, not for caution).
Convergences and contradictions
- The vault and the web agree, and they agree from opposite directions. The web evidence says binaries in or behind git history become permanent and the pain surfaces as clone and fetch cost. RDCO's own 2026-09-02 audit found exactly that at 688 MB, and the remediation note independently reached the web's conclusion that only a history rewrite reverses it. The 2026-06-17 storage-pattern note reached the same recommendation from first principles four months before any of this was measured. Three independent derivations landing on the same answer is as much convergence as this question will produce.
- The strongest contradiction is between what Git LFS promises and what its own quota documentation permits. LFS is marketed as the git-native answer for large files, and it genuinely gives the cleanest developer ergonomics:
git cloneyields a working tree with real bytes, no second tool, no credentials beyond the git remote. But a store whose requirement is "append-only, forever" needs the option to expire, and GitHub's documentation is explicit that LFS objects "continue to count toward your Git LFS storage quota" and that removing them means deleting the repository. A pattern that cannot shed data is a poor fit for a problem defined by data that never stops arriving. - One contradiction remains unresolved in the public record, and it is a gap rather than a disagreement. No primary writeup was found reporting how the "artifact store only, repo holds manifests" pattern actually aged over years, and none was found on what content-addressed storage costs a solo operator to run. The widely-repeated "Git LFS considered harmful" post does not appear to exist and should not be cited. So the recommendation below rests on vendor-documented mechanics plus RDCO's own shipped instance, not on third-party longitudinal evidence that the winning pattern holds up. That is the honest confidence boundary.
Synthesis for RDCO
Recommendation: artifact-store-only, with a committed content-addressed manifest. Concretely, Cloudflare R2 for the bytes and a sha256 plus byte-size manifest in git, which is the pattern Scribble Works already ships. Do not adopt Git LFS. Do not adopt git-annex or DVC either, and this one is a closer call that deserves its reason stated: both genuinely fix the pruning hole, since git annex dropunused and dvc gc remove old blobs without rewriting git history. They lose on single-operator burden and on recoverability. Each adds a tool that must be installed and kept working on every machine and in continuous integration, each stores its cache as hash-named blobs rather than by filename, so recovering a file without the tool means reconstructing directory structure from metadata, and neither tool's documentation covers continuous-integration setup at all. A text manifest plus a bucket needs no install anywhere and is readable with cat. The deciding factor against Git LFS specifically is not cost, though R2 wins there at $0.015 per GB-month against GitHub's listed $0.07 per GiB with free versus $0.0875 per GiB egress. The deciding factor is that R2 lifecycle rules can expire or down-tier a prefix on a schedule and Git LFS objects cannot be pruned at all short of deleting the repository. For a store whose declared lifecycle in [[fabric-spec-v0]] is "Append-only, forever," the ability to change your mind about retention later is the whole ballgame.
The condition under which I would pick differently is narrow and worth naming precisely. If the artifacts must be byte-reproducible from a checkout alone, with no network credentials and no second tool, then Git LFS's integration is worth its quota ceiling. That is the handoff case: someone receives the repository and nothing else, and must get real bytes. If that becomes a requirement and total lifetime volume stays inside the documented 10 GiB storage inclusion with few CI fetches, LFS is defensible. Neither live surface has that shape today. Scribble Works serves PDFs to the public over R2's URL, so the bytes are already a network fetch by design, and the Organizational Intelligence Fabric is specified as a port set precisely so the storage adapter can be swapped.
For Scribble Works, the action is mostly to stop the bleeding and name what already works. The R2-plus-manifest rail for game PDFs is correct and should be stated as the standing pattern rather than left as an emergent property of the launch runbook. Two concrete gaps follow from the verified figures. First, generated art currently lives in the CUSTOMIZE KV namespace because the Pages R2 binding breaks Function publish, and KV stored data is $0.50 per GB-month against R2's $0.015, roughly 33 times more. That is fine for small blobs carrying an expirationTtl and wrong for anything retained. Keep KV for expiring runtime art, and if any generated art becomes durable catalog content, it belongs in R2 behind a Function route that fetches over the public URL or the S3 API rather than a binding. Second, the repo still carries 688 MB of history from the screenshot incident. That is a one-time git filter-repo plus force-push, which the remediation note correctly escalated as a founder decision rather than a cleanup, and it should stay escalated rather than quietly executed.
For the Organizational Intelligence platform work, the recommendation slots in as a Store adapter and needs no spec change. [[fabric-spec-v0]] already partitions Store from Queue and already declines to pick a backend. The adapter contract this brief argues for is: artifact bytes go to an object store, the repo or catalog holds a typed pointer carrying path plus sha256 plus size plus a retention class, and the retrieval index is treated as derived and rebuildable. That is identical to the recommendation in [[2026-06-17-caf-grounding-asset-storage-pattern]], which named a Snowflake internal stage as the object store for in-perimeter reasons. The pattern is backend-agnostic, so both readings hold: R2 where RDCO owns the stack, a Snowflake stage where the perimeter is the governing constraint. The retention class field is the piece that was missing, and it is what makes a lifecycle rule expressible later instead of requiring a migration.
The cheapest reversible first step, and it is cheap enough to do before deciding anything: write the manifest, and gate the commit. Before any storage choice, emit a plain-text manifest next to every run output recording relative path, byte size, and sha256. A manifest is a few kilobytes of text, it is readable with no tooling installed, it costs nothing to carry, and it converts every future migration from a judgment call into a mechanical copy-and-verify. The 2026-09-02 screenshot move is the proof: it succeeded safely because it was "Copied, byte-compared (368/368, cmp clean), then git rm -r --cached," and "Nothing was deleted before the compare passed." That is a manifest discipline applied after the fact. The second half of the step is a pre-commit size gate that refuses any new blob over a chosen threshold, which is the only control that actually prevents the retrofit problem D2 was worried about, because it stops the history from accruing objects in the first place.
Why this is in the vault
This answers open decision D2 from [[2026-07-27-caf-technical-architecture-and-backlog]], which gated the CAF-ART-1 ticket, and it supplies the Store-adapter contract that [[fabric-spec-v0]] deliberately left unspecified. It also settles two live Scribble Works calls with verified numbers: whether durable generated art belongs in Workers KV or R2, and whether the existing R2-plus-manifest rail should be named as the standing pattern.
On D2's status: the decision is not still live, and it is not quite settled on the record either. Its original form is moot, because caf-artifacts was scoped around client-confidential engagement material for a consultancy line that is dormant and a role that forbids clients. Its substance was effectively answered twice before this brief: once by [[2026-06-17-caf-grounding-asset-storage-pattern]], which rejected version control for blobs explicitly, and once in shipped code, by the Scribble Works R2-plus-printables.manifest.json rail with its hash-matching launch gate. What this brief adds is the vendor-verified reason the answer is right rather than merely conventional, namely that LFS objects cannot be pruned and R2 lifecycle rules can. The genuinely open descendant is not D2 but CAF-ART-4-shaped retention policy, and R2 object lifecycles plus a retention-class field on the pointer make that mechanical rather than architectural.
Open follow-ups
- Scribble Works' R2 bucket
paper-playgroundis public and its game PDFs are the product. What is the actual unit economics crossover, in monthly downloads, between serving those PDFs from R2's public URL versus putting Cloudflare Cache in front of them, given that R2 Class B operations bill at $0.36 per million and egress is free? This is a desk calculation against published rates, not a build step, and it decides whether a cache layer is worth configuring at all. - No primary writeup was found describing how a Cloudflare R2 bucket under lifecycle-rule retention behaves over multiple years for a small operator, particularly whether the documented "typically within 24 hours" expiration lag degrades on large buckets and whether the Infrequent Access 30-day minimum duration creates a cost trap for artifacts that are regenerated frequently. Worth a focused search once there is a bucket old enough for the question to matter.
Related
- [[2026-07-27-caf-technical-architecture-and-backlog]] — the source of open decision D2 and the
CAF-ART-1ticket scope - [[2026-06-17-caf-grounding-asset-storage-pattern]] — the prior derivation of the object-store-plus-pointer pattern, which rejected git for blobs
- [[fabric-spec-v0]] — specifies the Store as "Append-only, forever" and as a port set, which is where this recommendation lands as an adapter
- [[A-architecture-code-quality]] — the 2026-09-02 audit that measured 688 MB of git history and 651 MB of committed screenshots
- [[2026-09-07-scribble-works-process-map]] — the current R2 upload and manifest steps in the Scribble Works release path
- [[2026-09-06-review-portal-spec]] — the private R2 bucket holding "immutable pre-publication PDFs, page previews, manifests"
- [[2026-09-02-audit-synthesis]] — the audit round this finding came out of
Sources
Vault:
~/rdco-vault/01-projects/phdata/2026-07-27-caf-technical-architecture-and-backlog.md, Section 3 decision table (D2) and Section 4, EPIC B (CAF-ART-1,CAF-ART-4)~/rdco-vault/01-projects/phdata/2026-06-17-caf-grounding-asset-storage-pattern.md, "Recommendation (decision-first)", "The prescribed industry pattern", "Honest evaluation of the four candidates"~/rdco-vault/01-projects/phdata/fabric-spec/fabric-spec-v0.md, Section 0 and "The two planes"~/rdco-vault/01-projects/printables-product/audit-2026-09-02/A-architecture-code-quality.md, Section 8 "Maintainability and onboarding cost"~/rdco-vault/01-projects/printables-product/studio-notes-2026-09/readme.md(the screenshot-move record and the history-rewrite caveat)~/rdco-vault/02-sops/2026-09-07-scribble-works-process-map.md(R2 upload as a publish precondition)~/rdco-vault/01-projects/printables-product/2026-09-06-review-portal-spec.md, Section on bindings (REVIEW_ARTIFACTSprivate R2 bucket)~/.claude/skills/launch-games/SKILL.md, steps 2-5 (upload,refresh,flip) and the rollback note- Agent memory
pages-r2-binding-breaks-function-publish(2026-09-01) andscribble-works-ops-rules(KV namespaces, retention sweeper)
Web, all read 2026-10-10:
- https://docs.github.com/en/billing/concepts/product-billing/git-lfs — "Git Large File Storage billing": "Free use of Git LFS", "How use of Git LFS is measured", "Usage in forks", "Paying for additional Git LFS use", "Using more than your included quota"
- https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-git-large-file-storage — "About Git Large File Storage" (per-plan file-size table; the page's own 2 GB/4 GB/5 GB rows conflict with its "per-file limit of 5 GB" sentence, quoted as found)
- https://docs.github.com/en/repositories/working-with-files/managing-large-files/removing-files-from-git-large-file-storage — "Git LFS objects in your repository"
- https://docs.github.com/en/repositories/working-with-files/managing-large-files/moving-a-file-in-your-repository-to-git-large-file-storage — history-rewrite requirement
- https://github.com/pricing/calculator — Git LFS additional storage and data-transfer rates (flagged: contradicts the docs on whether metered billing is live)
- https://developers.cloudflare.com/r2/pricing/ (page last updated 2026-10-01) — "R2 pricing", "Free tier", "Minimum storage duration", "Data retrieval", "Free operations", "Class A operations"
- https://developers.cloudflare.com/r2/buckets/object-lifecycles/ (last updated 2026-04-21) — "Behavior", "Configure lifecycle rules for your bucket"
- https://developers.cloudflare.com/r2/buckets/storage-classes/ (last updated 2026-04-21) — "Available storage classes", "Change storage class for objects"
- https://developers.cloudflare.com/r2/buckets/bucket-locks/ (last updated 2026-04-30) — retention rules and strictest-rule precedence
- https://developers.cloudflare.com/r2/api/workers/workers-api-reference/ —
R2Object.versiondefinition - https://developers.cloudflare.com/kv/platform/limits/ (last updated 2026-10-08) — "Workers KV" limits table (25 MiB value size)
- https://developers.cloudflare.com/kv/platform/pricing/ (last updated 2026-04-21) — paid-plan rate table
- https://wlcx.cc/blog/github-lfs-rant/ (2024-10-15, independent) — bandwidth-exhaustion incident log with quoted quota emails
- https://schneide.blog/2025/01/17/beware-of-using-git-lfs-on-github/ (Marius Elvert, Softwareschneiderei, 2025-01-17, independent) — "only 12 branches cloned for the 80% warning"
- https://github.com/nabla-c0d3/nassl/issues/17 (2017-07-23, independent) — hard clone failure, fork quota sharing, recurrence across years
- https://nicolas.busseneau.fr/en/blog/2020/12/two-step-push-accelerating-git-lfs-migration-for-big-repositories (2020-12-16, independent) — 24-hour abandoned LFS migration push, ~200 objects moved
- https://devblogs.microsoft.com/bharry/the-largest-git-repo-on-the-planet/ (2017-05-24, vendor-authored, Microsoft) — 300 GB repo, clone 25 minutes without a proxy versus 70 seconds with
- https://blog.engflow.com/2024/05/13/the-many-caches-of-bazel/ (2024-05-13, vendor-authored, EngFlow) — unbounded disk and repository cache growth, no automated pruning
- https://git-annex.branchable.com/walkthrough/ — "adding files", "modifying annexed files", "unused data"
- https://git-annex.branchable.com/git-annex-drop/ and https://git-annex.branchable.com/git-annex-unused/ and https://git-annex.branchable.com/git-annex-numcopies/ — drop safety, unused detection, default numcopies of 1
- https://git-annex.branchable.com/internals/ — ".git/ directory" object layout, "The git-annex branch" append-only logs
- https://git-annex.branchable.com/install/ — package-manager coverage; no Windows command or support statement (the
Windows/page returns HTTP 404) - https://doc.dvc.org/start/data-management/data-versioning —
.dvcpointer file shape (md5,path) - https://doc.dvc.org/command-reference/gc — scope flags,
-c/--cloud, "Cloud deletion is irreversible" - https://doc.dvc.org/user-guide/data-management/large-dataset-optimization — "File link types for the DVC cache", filesystem and hardlink caveats
- https://doc.dvc.org/user-guide/data-management/remote-storage/amazon-s3 —
endpointurlmechanism for S3-compatible stores; Cloudflare R2 not named
Explicitly not verified, so not relied on above: the retrofit and history-rewrite guidance for git-annex and DVC specifically (neither tool's migration page was read from a live source today, so the brief's retrofit claims rest on GitHub's documented filter-repo requirement and the Busseneau measurement, not on git-annex or DVC documentation); git-annex special-remote support for S3 or R2; whether GitHub's $0.07 and $0.0875 per-GiB rates are currently charged, given the calculator's "in the future" framing.
Searched and not found, recorded so it is not re-searched: no primary writeup on how the artifact-store-plus-manifest pattern aged over multiple years; no primary writeup on content-addressed-storage operating cost for a solo operator; no "Git LFS considered harmful" post from the Mercurial community appears to exist, so the frequently-cited reference should be treated as misremembered. No paywalled source was used; nothing was blocked or retried.