GitPython's Repo.archive() function accepts arbitrary git options and passes them through to the git archive command. An internal denylist called unsafe_git_archive_options attempts to block dangerous variants, but CVE-2026-73619 shows that --add-file and --add-virtual-file were never added — allowing filesystem read beyond the repository boundary.

The deeper problem isn't two missing entries in a list. It's that denylisting git options is architecturally unsound by design. Git's archive command surface evolves; every new option that enables filesystem access requires someone to remember to update this guard. The denylist was likely incomplete from creation — written under time pressure against the options that existed that week, not against the full manpage. No process exists to re-audit when git adds new options, so the gap persists latently until discovered.

The correct fix isn't a bigger denylist. It's eliminating the option-injection surface entirely. Repo.archive() exists to create archives; there's no legitimate reason for callers to inject arbitrary git flags. The safer design is explicit, named parameters for every supported feature — not a denylist dressed as a security boundary.

For defenders: audit your use of Repo.archive() and check whether any untrusted input reaches the options parameter. More critically, treat this as a signal to audit other GitPython functions that accept arbitrary git options — if they use the same denylist pattern, they likely have the same latent gaps. If your project transitively depends on GitPython through another library, you may be exposed without knowing it. The blast radius of this architectural failure extends to every downstream consumer who never consciously opted into handling git archive semantics.

The recurring failure pattern is clear: security patches get written once, pass review, then enter dormancy while the underlying tool evolves underneath them. This CVE is one instance of that entropy. The question is which other denylists in your dependency tree are sitting in the same dormant state, waiting for the next option discovery.