Git Surgery: The Anatomy of a Successful Repository Scrub

Jul 10, 2026

🤖 Read Raw Markdown

Setting the Stage: Context for the Curious Book Reader

This entry serves as a technical record of a necessary intervention. It is a blueprint for the moment when a development environment requires surgical correction. By documenting this process—from initial probe to the final force-push—we clarify the relationship between historical Git objects, canonical branch state, and the permanence of published provenance. It is important to know in the Age of AI how to handle such cleanup, as our development repositories are increasingly integrated into the context-windows of our automated systems.

---

Technical Journal Entry Begins

🔗 Verified Pipulate Commits:

• b0f6c4f8 (raw)

I’m publishing this article public-side for posterity. A bunch of the GitHub cross-links between my articles and the live repo are going to break because I’ve got to do some retconning here. After I sanitize this article by-hand stripping out the client-name, I’m going to publish to help me and others do this sort of thing in the future and use that published article to compile into the context-window of future prompts as embedded reference material that surfaces all the issues. I will then add a proactive guard against such pollution into the Pipulate repo from happening again like I do other places in the system. I also have some PyPI updating to do.

The Diagnostic Probe: Establishing the Scope

MikeLev.in: Oh shoot, I polluted my Pipulate repo again with a client name.

(nix) pipulate $ git grep -n "example-client"
assets/nbs/imports/gap_analyzer_sauce.py:110:            "example-client.com\n"
foo_files.py:638:@https://www.example-client.com/products/bare-the-absolute-minimizer-bra-a10165?variant=41923484156017
foo_files.py:644:! python -c "p='browser_cache/www.example-client.com/%2Fproducts%2Fbare-the-absolute-minimizer-bra-a10165/source.html'; s=open(p).read(); print('ld+json blocks:', s.count('application/ld+json'), '| aggregateRating:', 'aggregateRating' in s, '| ratingValue:', 'ratingValue' in s, '| hasVariant:', 'hasVariant' in s)"
foo_files.py:646:! curl -s -A "Mozilla/5.0" "https://www.example-client.com/products/bare-the-absolute-minimizer-bra-a10165.json" | python -c "import json,sys; d=json.load(sys.stdin)['product']; print('variants:', len(d['variants'])); [print(' option:', o['name'], '->', len(o['values']), 'values') for o in d['options']]; print('available:', sum(1 for v in d['variants'] if v.get('available')))"
foo_files.py:648:! curl -s -A "Mozilla/5.0" "https://www.example-client.com/sitemap_products_1.xml?from=7226327236721&to=7752706719857" | grep -c "<loc>"
foo_files.py:650:! curl -s -A "Mozilla/5.0" "https://www.example-client.com/sitemap_agentic_discovery.xml" | head -c 1200
foo_files.py:652:! python -c "import json; p='browser_cache/www.example-client.com/%2Fproducts%2Fbare-the-absolute-minimizer-bra-a10165/network_log.jsonl'; L=[json.loads(l) for l in open(p)]; U=[e['params']['request']['url'] for e in L if e.get('method')=='Network.requestWillBeSent']; [print(u[:130]) for u in U if 'adn.cloud' in u or 'botify' in u]"
(nix) pipulate $

I’ve got to fix this. I just removed this and put it here in this article to preserve the work. I’m not publishing this article. It’s going in the Grimoire.

Surgical Intervention with Git-Filter-Repo

# --- ADHOC SLOT START ---

# /home/mike/repos/trimnoir/_posts/2026-07-09-wire-truth-network-capture.md
# /home/mike/repos/trimnoir/_posts/2026-07-07-agentic-readiness-checklist.md

@https://www.example-client.com/products/bare-the-absolute-minimizer-bra-a10165?variant=41923484156017

# --- ADHOC SLOT ADDITIONS (BN re-un-canonicalization recon) ---

# --- ADHOC SLOT ADDITIONS (BN recon, round 2 — pinned paths, no glob[0]) ---

! python -c "p='browser_cache/www.example-client.com/%2Fproducts%2Fbare-the-absolute-minimizer-bra-a10165/source.html'; s=open(p).read(); print('ld+json blocks:', s.count('application/ld+json'), '| aggregateRating:', 'aggregateRating' in s, '| ratingValue:', 'ratingValue' in s, '| hasVariant:', 'hasVariant' in s)"

! curl -s -A "Mozilla/5.0" "https://www.example-client.com/products/bare-the-absolute-minimizer-bra-a10165.json" | python -c "import json,sys; d=json.load(sys.stdin)['product']; print('variants:', len(d['variants'])); [print(' option:', o['name'], '->', len(o['values']), 'values') for o in d['options']]; print('available:', sum(1 for v in d['variants'] if v.get('available')))"

! curl -s -A "Mozilla/5.0" "https://www.example-client.com/sitemap_products_1.xml?from=7226327236721&to=7752706719857" | grep -c "<loc>"

! curl -s -A "Mozilla/5.0" "https://www.example-client.com/sitemap_agentic_discovery.xml" | head -c 1200

! python -c "import json; p='browser_cache/www.example-client.com/%2Fproducts%2Fbare-the-absolute-minimizer-bra-a10165/network_log.jsonl'; L=[json.loads(l) for l in open(p)]; U=[e['params']['request']['url'] for e in L if e.get('method')=='Network.requestWillBeSent']; [print(u[:130]) for u in U if 'adn.cloud' in u or 'botify' in u]"

# tools/__init__.py       # <-- Which one of these inits is not like the other? Small, but not empty.
# tools/system_tools.py   # <-- A grab-bag of rudimentary tool-calling capability before the fancy stuff
# tools/llm_optics.py     # <-- Some of the work we do would bring down the JupyterLab event-loop. Here's how it doesn't.
# tools/dom_tools.py      # <-- Lenses with which to clarify messy DOM soup. Trees. Nested ASCII art boxes. Normalization.
# tools/scraper_tools.py  # <-- Pop-up desktop browser automation that works consistently across macOS, Windows/WSL and GNOME/KDE/XFCE? You've got to be kidding!

# --- ADHOC SLOT END ---

# --- ADHOC SLOT ADDITIONS (network wire-truth campaign, round 2) ---

# remotes/honeybot/nixos/configuration.nix  # [4,804 tokens | 18,310 bytes]

# requirements.in
# 
# ! .venv/bin/python -c "import selenium, undetected_chromedriver as uc; print('selenium', selenium.__version__, '| uc', uc.__version__)"
# 
# ! chromium --version
# 
# ! cat browser_cache/mikelev.in/%2F/headers.json
# 
# ! python -c "from tools.scraper_tools import selenium_automation; import asyncio; asyncio.run(selenium_automation({'url':'https://mikelev.in/','domain':'mikelev.in','url_path_slug':'%2F','headless':False,'is_notebook_context':True,'verbose':False,'override_cache':True}))"
# ! python -c "import json;L=[json.loads(l) for l in open('browser_cache/mikelev.in/%2F/network_log.jsonl')];R=[e for e in L if e.get('method')=='Network.responseReceived' and 'mikelev.in' in e['params']['response']['url']];print('mikelev.in responses:',len(R));print(json.dumps(R[0],indent=2)[:1600] if R else 'NONE')"
# ! python -c "import json;L=[json.loads(l) for l in open('browser_cache/mikelev.in/%2F/network_log.jsonl')];S=[e for e in L if e.get('method')=='Network.requestWillBeSent' and 'mikelev.in' in e['params']['request']['url']];print('mikelev.in requests:',len(S));print(json.dumps(S[0],indent=2)[:1200] if S else 'NONE')"

# --- ADHOC SLOT ADDITIONS END ---

And after that change (and putting back the markers)

(nix) pipulate $ d
diff --git a/foo_files.py b/foo_files.py
index 404d5fa2..ddbc61b0 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -52,7 +52,7 @@ AI_PHOOEY_CHOP = r"""
 
 # --- START STATS ---
 # There are 1,289 already-written articles about this repo at MikeLev.in (Public)
-# Velocity: 23 published in the last 7 days
+# Velocity: 18 published in the last 7 days
 # --- END STATS ---
 
 # Most of what's below are relative paths to files in GitHub/pipulate/pipulate
@@ -632,32 +632,8 @@ ADHOC_CHOP = r"""
 
 # --- ADHOC SLOT START ---
 
-# tools/__init__.py       # <-- Which one of these inits is not like the other? Small, but not empty.
-# tools/system_tools.py   # <-- A grab-bag of rudimentary tool-calling capability before the fancy stuff
-# tools/llm_optics.py     # <-- Some of the work we do would bring down the JupyterLab event-loop. Here's how it doesn't.
-# tools/dom_tools.py      # <-- Lenses with which to clarify messy DOM soup. Trees. Nested ASCII art boxes. Normalization.
-# tools/scraper_tools.py  # <-- Pop-up desktop browser automation that works consistently across macOS, Windows/WSL and GNOME/KDE/XFCE? You've got to be kidding!
-
 # --- ADHOC SLOT END ---
 
-# --- ADHOC SLOT ADDITIONS (network wire-truth campaign, round 2) ---
-
-remotes/honeybot/nixos/configuration.nix  # [4,804 tokens | 18,310 bytes]
-
-# requirements.in
-# 
-# ! .venv/bin/python -c "import selenium, undetected_chromedriver as uc; print('selenium', selenium.__version__, '| uc', uc.__version__)"
-# 
-# ! chromium --version
-# 
-# ! cat browser_cache/mikelev.in/%2F/headers.json
-# 
-# ! python -c "from tools.scraper_tools import selenium_automation; import asyncio; asyncio.run(selenium_automation({'url':'https://mikelev.in/','domain':'mikelev.in','url_path_slug':'%2F','headless':False,'is_notebook_context':True,'verbose':False,'override_cache':True}))"
-# ! python -c "import json;L=[json.loads(l) for l in open('browser_cache/mikelev.in/%2F/network_log.jsonl')];R=[e for e in L if e.get('method')=='Network.responseReceived' and 'mikelev.in' in e['params']['response']['url']];print('mikelev.in responses:',len(R));print(json.dumps(R[0],indent=2)[:1600] if R else 'NONE')"
-# ! python -c "import json;L=[json.loads(l) for l in open('browser_cache/mikelev.in/%2F/network_log.jsonl')];S=[e for e in L if e.get('method')=='Network.requestWillBeSent' and 'mikelev.in' in e['params']['request']['url']];print('mikelev.in requests:',len(S));print(json.dumps(S[0],indent=2)[:1200] if S else 'NONE')"
-
-# --- ADHOC SLOT ADDITIONS END ---
-
 foo_files.py
 prompt_foo.py
 .gitattributes
(nix) pipulate $

I didn’t even push that yet. That’s just to show you. But earlier stuff with the client name pollution has been pushed (I think):

(nix) pipulate $ git -P log -20
commit 15e715ea20599a6ad17330971bb7bc45d880a3cc (HEAD -> main, origin/main, origin/HEAD)
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 15:16:37 2026 -0400

    chore: Add .wav to ignored files

commit 62a76a75a9ca5ab802ea70b656a9421166566917
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 15:13:50 2026 -0400

    chore: Update nix configuration and tools dependencies - Added alsa-utils and ffmpeg to nix configuration and project tools list.

commit 3363bab2d3ce5cd78d191c82e51af858e7be9faf
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 14:57:29 2026 -0400

    chore: Update stats and remote configuration files

commit 8f8b6cbd48e51c300288196d9ad7e63f5f2bfa1f
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 13:57:41 2026 -0400

    fix(internal): Refine internal documentation comments on AI_PHOOEY_CHOP

commit 31d7f62d1b78c091a9f22fbf34930a649411a3fe
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 13:57:17 2026 -0400

    fix(docs): Add Dr. Pipt explanation

commit 2e4d68a0d4e222ec3712f5dd244efec7426621f6
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 13:56:40 2026 -0400

    docs: Update article count and velocity stats in foo_files.py

commit 42c02354351e72381edb8b707ee2fd156da28551
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 07:38:33 2026 -0400

    fix: update narrator message for stream

commit c0b1137e2d83e022e199ec1e45d00acbac315ac1
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 06:59:57 2026 -0400

    refactor: Extract wire-truth from CDP ledger for accurate headers and source

commit 0c9e642cbf86afdafea9d045cf655c5fab8a621a
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 06:59:41 2026 -0400

    chore: Drain CDP performance log events to JSONL file

commit 35d816e68f6f17c6708ec77386081a46cbce3f8e
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 06:32:36 2026 -0400

    chore: Remove header capture logic from selenium_automation

commit fd0dfdb49fd9b67a5428d7cb9bfdaa41e940214d
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 05:59:51 2026 -0400

    fix: Execute scraper with selenium automation and log analysis

commit 64cc78aac34d73b6d041a553eac92065c2cf5fe6
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 05:54:07 2026 -0400

    chore: Add network_log.jsonl to scraper tools

commit d43e70b720c705193fc43e48060b2955c7f82890
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 05:53:46 2026 -0400

    fix(scraper_tools): Add network log capture from CDP

commit 70dba9b9afa9c9bb1df1fe34e1f4832d03ac094a
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 05:53:27 2026 -0400

    chore: Add logging prefs to selenium options

commit 2fae4179c09a8ff2d9f84ed465780d4f4593a000
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 05:53:05 2026 -0400

    chore: Add logging capabilities to Selenium automation

commit b75f83abe0d069a9f4b73d43a210e24de9f46d80
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 05:52:45 2026 -0400

    chore: Update selenium and uc version checks in script

commit 374c563c473bfd82020d86fd1ddabe059e46b2dd
Author: Mike Levin <miklevin@gmail.com>
Date:   Thu Jul 9 04:45:00 2026 -0400

    chore: Update aliases for prompt_foo.py with new chop names and associated files

commit f9761e18feca5c8b9770c48ea7e5b47785da55f9
Author: Mike Levin <miklevin@gmail.com>
Date:   Wed Jul 8 12:02:52 2026 -0400

    chore: Add 'pins' and 'pinedit' aliases in flake.nix

commit 96b744e81b83891f028c59efcda6fbc92375e9f0
Author: Mike Levin <miklevin@gmail.com>
Date:   Wed Jul 8 12:02:34 2026 -0400

    chore: Update PINNED_CHOP and PIN PATHS documentation in foo_files.py

commit 1c4f8a3d5097e63c899ffc6009784b5a74b2a54b
Author: Mike Levin <miklevin@gmail.com>
Date:   Wed Jul 8 12:02:07 2026 -0400

    chore: Update documentation for pinboard milestone articles and deletion process
(nix) pipulate $ 

And I know you’ll want to see my requirements.in to see if I have some special git tool which I don’t think I do but should add for the easy way. But you can see my skills here. The hard way is fine too. Whichever is more expedient, please and thank you!

Reconciling the Commit Graph

Claude Opus 4.8 High: Context verified — with one gap worth naming up front: the file that actually still carries the client name in committed form, assets/nbs/imports/gap_analyzer_sauce.py, isn’t in this bundle. The foo_files.py in context is already the cleaned ADHOC_CHOP (just requirements.in in the slot), so what I can see confirms your working-tree fix but not the pre-clean history. Everything needed to answer the tooling/workflow question is here.

Your requirements question, answered: no, you don’t have a history tool. I scanned requirements.in and flake.nix commonPackages — you’ve got git and ripgrep, but the thing you’re picturing for “the easy way” is git-filter-repo, and it’s absent from both. So there’s no shortcut already installed; the choice is add-the-tool-then-easy vs. hard-way-with-what-you-have.

But before either — diagnose scope first, because it changes everything. Your git grep only proves the string is on disk right now; it says nothing about whether it’s in pushed commits. The cheapest falsifying probe:

# Which commits ever touched the string, on any ref?
git log --all --oneline -S 'example-client'

# Definitive: every commit whose tree actually contains it
git rev-list --all | xargs -I{} git grep -l 'example-client' {} 2>/dev/null | sort -u

Two outcomes:

A) It’s only in your working tree (never committed). Very plausible for the foo_files.py ADHOC_CHOP part, since that’s disposable scratch you edit constantly. If the log/rev-list probes come back empty for the committed paths, there is no history problem — just finish cleaning the working files and commit normally. No rewrite, no force-push, done.

B) It’s in pushed commits. Almost certainly true for gap_analyzer_sauce.py:110, since assets/nbs/imports/… is tracked (only the Notebooks/imports/… copy is gitignored) and it’s baked in as an example domain. Now it’s a real decision, and it’s a judgment call, not a pure fix:

• “example-client.com” is a well-known public retailer, and this is example/recon data, not a credential. Weigh client-confidentiality expectations against the cost of rewriting.
• A history rewrite reshuffles every SHA from the first offending commit forward. Your magic-cookie flake does git pull --ff-only on auto-update — a force-push breaks that for anyone with an existing clone (fresh installs are fine; they clone anew). Your own installs would need a re-clone.
• It doesn’t fully un-ring the bell: forks, GitHub’s cached blob views, the Wayback Machine, and anything already scraped keep a copy. If true confidentiality is the goal, rewriting reduces exposure, it doesn’t erase it.

So there’s a legitimate pragmatic path — scrub going forward, add the name to a denylist, accept the historical mention — that I’d genuinely consider given this is a public brand name in example data. Your call.

If you do choose to rewrite, git-filter-repo is the right tool for your stack (pure Python, Nix-native, git’s own recommendation over the deprecated filter-branch; BFG works too but drags in Java you’d rather avoid). Add it to the shell — worth having permanently since you said “again,” and this recurs:

Target: flake.nix
[[[SEARCH]]]
          git                          # Version control system for tracking changes
          curl                         # Command-line tool for transferring data with URLs
[[[DIVIDER]]]
          git                          # Version control system for tracking changes
          git-filter-repo              # Surgical git history rewriting (scrub strings/paths across all commits)
          curl                         # Command-line tool for transferring data with URLs
[[[REPLACE]]]

Then, in a fresh clone (filter-repo insists, so you can inspect before pushing):

echo 'example-client==>example-competitor' > /tmp/scrub.txt
git filter-repo --replace-text /tmp/scrub.txt      # one rule catches every variant/subdomain
git remote add origin git@github.com:pipulate/pipulate.git   # filter-repo strips origin by design
git log --all --oneline -S 'example-client'       # re-run the probe: expect empty
git push --force origin main

Either way, clean the two live files (I can’t SEARCH/REPLACE gap_analyzer_sauce.py since it’s not in context — here’s the sed, and paste me the file if you’d rather I do a surgical patch on line 110):

sed -i 's/example-client\.com/example-competitor.com/g' assets/nbs/imports/gap_analyzer_sauce.py Notebooks/imports/gap_analyzer_sauce.py
git grep -n example-client   # must return nothing before you commit

Prevention, since this is the recurring failure mode: the leak vector is that foo_files.py auto-annotates/auto-commits, so live recon pasted into ADHOC_CHOP rides along. That’s exactly the “Repomix secret-scan for compile lane” already in your pinboard OWES clause. A one-line pre-commit guard closes it cheaply — grep staged content against a client-domain denylist and refuse the commit on a hit. Want me to sketch that hook?

My recommendation: run the two probes first and tell me what they show — that single result decides whether this is a 30-second working-tree cleanup or a force-push you have to weigh.

(nix) pipulate $ # Which commits ever touched the string, on any ref?
git log --all --oneline -S 'example-client'

# Definitive: every commit whose tree actually contains it
git rev-list --all | xargs -I{} git grep -l 'example-client' {} 2>/dev/null | sort -u
"/nix/store/kjvgj2n3yn70hmjifg6y0bk9m4rf7jba-python3-3.12.10/bin/python3.12" -m nbstripout -t: line 1: /nix/store/kjvgj2n3yn70hmjifg6y0bk9m4rf7jba-python3-3.12.10/bin/python3.12: No such file or directory
fatal: unable to read files to diff
^C
(nix) pipulate $ 

I had to control-C that. I think nbstripout might have something to do with that.

(nix) pipulate $ sed -i 's/example-client\.com/example-competitor.com/g' assets/nbs/imports/gap_analyzer_sauce.py Notebooks/imports/gap_analyzer_sauce.py
git grep -n example-client   # must return nothing before you commit
(nix) pipulate $ 

Okay, let’s activate that tool.

Guide me.

(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'flake.nix'.
(nix) pipulate $ d
diff --git a/assets/nbs/imports/gap_analyzer_sauce.py b/assets/nbs/imports/gap_analyzer_sauce.py
index 3faa8e22..3f1145dd 100644
--- a/assets/nbs/imports/gap_analyzer_sauce.py
+++ b/assets/nbs/imports/gap_analyzer_sauce.py
@@ -107,7 +107,7 @@ def render_competitor_workbench(job: str):
     else:
         default_text = (
             "# Enter one URL or domain per line. Comments starting with '#' are ignored.\n"
-            "example-client.com\n"
+            "example-competitor.com\n"
             "herroom.com\n"
             "soma.com\n"
             "thirdlove.com"
diff --git a/flake.nix b/flake.nix
index f50eceeb..6cc339e1 100644
--- a/flake.nix
+++ b/flake.nix
@@ -195,6 +195,7 @@
           tmux                         # Terminal multiplexer for managing sessions
           zlib                         # Compression library for data compression
           git                          # Version control system for tracking changes
+          git-filter-repo              # Surgical git history rewriting (scrub strings/paths across all commits)
           curl                         # Command-line tool for transferring data with URLs
           wget                         # Utility for non-interactive download of files from the web
           cmake                        # Cross-platform build system generator
diff --git a/foo_files.py b/foo_files.py
index 404d5fa2..39eedab3 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -52,7 +52,7 @@ AI_PHOOEY_CHOP = r"""
 
 # --- START STATS ---
 # There are 1,289 already-written articles about this repo at MikeLev.in (Public)
-# Velocity: 23 published in the last 7 days
+# Velocity: 18 published in the last 7 days
 # --- END STATS ---
 
 # Most of what's below are relative paths to files in GitHub/pipulate/pipulate
@@ -632,32 +632,10 @@ ADHOC_CHOP = r"""
 
 # --- ADHOC SLOT START ---
 
-# tools/__init__.py       # <-- Which one of these inits is not like the other? Small, but not empty.
-# tools/system_tools.py   # <-- A grab-bag of rudimentary tool-calling capability before the fancy stuff
-# tools/llm_optics.py     # <-- Some of the work we do would bring down the JupyterLab event-loop. Here's how it doesn't.
-# tools/dom_tools.py      # <-- Lenses with which to clarify messy DOM soup. Trees. Nested ASCII art boxes. Normalization.
-# tools/scraper_tools.py  # <-- Pop-up desktop browser automation that works consistently across macOS, Windows/WSL and GNOME/KDE/XFCE? You've got to be kidding!
+requirements.in
 
 # --- ADHOC SLOT END ---
 
-# --- ADHOC SLOT ADDITIONS (network wire-truth campaign, round 2) ---
-
-remotes/honeybot/nixos/configuration.nix  # [4,804 tokens | 18,310 bytes]
-
-# requirements.in
-# 
-# ! .venv/bin/python -c "import selenium, undetected_chromedriver as uc; print('selenium', selenium.__version__, '| uc', uc.__version__)"
-# 
-# ! chromium --version
-# 
-# ! cat browser_cache/mikelev.in/%2F/headers.json
-# 
-# ! python -c "from tools.scraper_tools import selenium_automation; import asyncio; asyncio.run(selenium_automation({'url':'https://mikelev.in/','domain':'mikelev.in','url_path_slug':'%2F','headless':False,'is_notebook_context':True,'verbose':False,'override_cache':True}))"
-# ! python -c "import json;L=[json.loads(l) for l in open('browser_cache/mikelev.in/%2F/network_log.jsonl')];R=[e for e in L if e.get('method')=='Network.responseReceived' and 'mikelev.in' in e['params']['response']['url']];print('mikelev.in responses:',len(R));print(json.dumps(R[0],indent=2)[:1600] if R else 'NONE')"
-# ! python -c "import json;L=[json.loads(l) for l in open('browser_cache/mikelev.in/%2F/network_log.jsonl')];S=[e for e in L if e.get('method')=='Network.requestWillBeSent' and 'mikelev.in' in e['params']['request']['url']];print('mikelev.in requests:',len(S));print(json.dumps(S[0],indent=2)[:1200] if S else 'NONE')"
-
-# --- ADHOC SLOT ADDITIONS END ---
-
 foo_files.py
 prompt_foo.py
 .gitattributes

(nix) pipulate $ exit
exit
(sys) pipulate $ ndq
warning: Git tree '/home/mike/repos/pipulate' is dirty
warning: updating lock file '/home/mike/repos/pipulate/flake.lock':
• Added input 'flake-utils':
    'github:numtide/flake-utils/11707dc2f618dd54ca8739b309ec4fc024de578b?narHash=sha256-l0KFg5HjrsfsO/JpG%2Br7fRrqm12kzFHyUHqHCVpMMbI%3D' (2024-11-13)
• Added input 'flake-utils/systems':
    'github:nix-systems/default/da67096a3b9bf56a91d16901293e51ba5b49a27e?narHash=sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768%3D' (2023-04-09)
• Added input 'nixpkgs':
    'github:NixOS/nixpkgs/d407951447dcd00442e97087bf374aad70c04cea?narHash=sha256-8i/87eeoqiGE4yOTjwSA3Eh/ziJRQEmd/unYU%2BK27sk%3D' (2026-07-05)
warning: Git tree '/home/mike/repos/pipulate' is dirty
(nix) pipulate $ git rev-list --all | xargs -I{} git grep -l 'example-client' {} 2>/dev/null | sort -u
00012504bffed1f4c4d70ff808c9fdc88c99b0d2:assets/nbs/imports/gap_analyzer_sauce.py
0008db7aafd9834dc15974d6b94c294e608cb383:assets/nbs/imports/gap_analyzer_sauce.py

[And many more...]

ffd7f63575d7a16ef0013ca6304eac39e3e58a61:assets/nbs/imports/gap_analyzer_sauce.py
ffdef681036462c78fc4b050e3d2dc8b537ec301:assets/nbs/imports/gap_analyzer_sauce.py
(nix) pipulate $

Opus 4.8: Scope confirmed — this is squarely Option B. That rev-list sweep shows the string riding in essentially every commit that carries gap_analyzer_sauce.py (it’s been in the example-domain list since the file was born), plus a handful of GAPalyzer.ipynb commits and one stray server.log blob. The rewrite is warranted, and you’ve chosen it. The single irreversible moment is the force-push at the end: it reshuffles every SHA from the first offending commit forward, which breaks git pull --ff-only for any existing clone (Prime, Mac, honeybot if it clones pipulate). Fresh installs are unaffected — they clone the new history anew. I’ll close that loop in the last step.

Two things before commands. Your .gitignore already excludes flake.lock and Notebooks/imports/gap_analyzer_sauce.py, so the only tracked copy is assets/nbs/imports/…, which the sed already handled. And the reason probe #1 died: git log -S runs a pickaxe diff that invokes your local nbstripout clean filter on .ipynb blobs, and that filter is pinned to a garbage-collected /nix/store/…/python3.12. filter-repo never touches clean filters (it exports raw blobs), and a fresh clone won’t even have the filter configured — so both the rewrite and its verification dodge that landmine.

First, confirm the tool actually landed after ndq:

git filter-repo --version

Phase 1 — land the cleanup so the remote tip is clean, then rewrite the history behind it:

cd ~/repos/pipulate
git add -A
git commit -m "chore: scrub example client domain; add git-filter-repo to flake"
git push
git grep -n example-client        # expect empty — tip is clean

Phase 2 — rewrite in a fresh clone (filter-repo insists on this, and it lets you inspect before anything leaves your machine):

cd ~/repos
git clone git@github.com:pipulate/pipulate.git pipulate-scrub
cd pipulate-scrub
printf 'example-client==>example-competitor\n' > /tmp/scrub.txt
git filter-repo --replace-text /tmp/scrub.txt

One literal rule catches the bare domain and every path/subdomain variant, in .py, .ipynb, and that server.log blob alike — it’s a byte-level swap across all blobs, so file type is irrelevant. If a later grep turns up a mixed-case variant, add a line to scrub.txt and re-run.

Phase 3 — verify before pushing anything:

git rev-list --all | xargs -I{} git grep -l 'example-client' {} 2>/dev/null | sort -u
git log --all --oneline -S example-client

Both should come back empty. The -S pickaxe works fine here — the fresh clone has no nbstripout filter to choke on. Glance at git log --oneline -5 too, to confirm the tip and shape survived.

Phase 4 — force-push the clean history. filter-repo strips origin by design, so re-add it first:

git remote add origin git@github.com:pipulate/pipulate.git
git push --force origin main

If git branch -a / git tag show anything beyond main, they were rewritten too — push them with git push --force origin --all --tags.

Phase 5 — re-sync this working repo (its SHAs no longer match) and drop the old objects locally:

cd ~/repos/pipulate
git fetch origin
git reset --hard origin/main
git reflog expire --expire=now --all && git gc --prune=now
git grep -n example-client        # final: empty

Then delete the scratch clone (rm -rf ~/repos/pipulate-scrub). Any other clone you own — Prime, Mac, honeybot — will fail its next git pull --ff-only; fix each the same way (git fetch && git reset --hard origin/main) or just re-clone. The magic-cookie installer stays fine for new users.

Two residuals worth naming, since the point was confidentiality: rewriting doesn’t reach GitHub’s cached blob views, existing forks, the Wayback Machine, or — the one that might actually bite — any PyPI release whose sdist/wheel bundled gap_analyzer_sauce.py with the string in it. Git history can’t scrub a published package. Quick check of where you stand:

pip download pipulate --no-deps -d /tmp/pp && grep -rl example-client /tmp/pp

If that hits, it’s a separate yank-or-re-release decision.

And since you said “again” — the durable fix is the pre-commit denylist already queued as your Repomix secret-scan OWES item: a small hook that greps staged content against a client-domain list and refuses the commit on a hit. Say the word and I’ll sketch it.

MikeLev.in: Okay, we do it:

$ git status
On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   assets/nbs/imports/gap_analyzer_sauce.py
	modified:   flake.nix
	modified:   foo_files.py

no changes added to commit (use "git add" and/or "git commit -a")
(nix) pipulate $ git filter-repo --version
a40bce548d2c
(nix) pipulate $ cd ~/repos/pipulate
git add -A
git commit -m "chore: scrub example client domain; add git-filter-repo to flake"
git push
git grep -n example-client        # expect empty — tip is clean
[main b0f6c4f8] chore: scrub example client domain; add git-filter-repo to flake
 3 files changed, 4 insertions(+), 25 deletions(-)
Enumerating objects: 15, done.
Counting objects: 100% (15/15), done.
Delta compression using up to 48 threads
Compressing objects: 100% (8/8), done.
Writing objects: 100% (8/8), 812 bytes | 812.00 KiB/s, done.
Total 8 (delta 7), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (7/7), completed with 7 local objects.
To github.com:pipulate/pipulate.git
   15e715ea..b0f6c4f8  main -> main
(nix) pipulate $ cd ~/repos
git clone git@github.com:pipulate/pipulate.git pipulate-scrub
cd pipulate-scrub
printf 'example-client==>example-competitor\n' > /tmp/scrub.txt
git filter-repo --replace-text /tmp/scrub.txt
Cloning into 'pipulate-scrub'...
remote: Enumerating objects: 33069, done.
remote: Counting objects: 100% (273/273), done.
remote: Compressing objects: 100% (93/93), done.
remote: Total 33069 (delta 211), reused 208 (delta 177), pack-reused 32796 (from 3)
Receiving objects: 100% (33069/33069), 32.76 MiB | 25.78 MiB/s, done.
Resolving deltas: 100% (22381/22381), done.
NOTICE: Removing 'origin' remote; see 'Why is my origin removed?'
        in the manual if you want to push back there.
        (was git@github.com:pipulate/pipulate.git)
Parsed 7783 commits
New history written in 19.03 seconds; now repacking/cleaning...
Repacking your repo and cleaning out old unneeded objects
HEAD is now at 9c8f9a14 chore: scrub example client domain; add git-filter-repo to flake
Enumerating objects: 33065, done.
Counting objects: 100% (33065/33065), done.
Delta compression using up to 48 threads
Compressing objects: 100% (10019/10019), done.
Writing objects: 100% (33065/33065), done.
Total 33065 (delta 22358), reused 33031 (delta 22325), pack-reused 0 (from 0)
Completely finished after 20.07 seconds.
(nix) pipulate-scrub $ git rev-list --all | xargs -I{} git grep -l 'example-client' {} 2>/dev/null | sort -u
git log --all --oneline -S example-client
(nix) pipulate-scrub $ git log --all --oneline -S example-client
(nix) pipulate-scrub $ git remote add origin git@github.com:pipulate/pipulate.git
git push --force origin main
Enumerating objects: 20107, done.
Counting objects: 100% (20107/20107), done.
Delta compression using up to 48 threads
Compressing objects: 100% (5886/5886), done.
Writing objects: 100% (20075/20075), 23.55 MiB | 27.98 MiB/s, done.
Total 20075 (delta 13738), reused 19951 (delta 13654), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (13738/13738), completed with 16 local objects.
To github.com:pipulate/pipulate.git
 + b0f6c4f8...9c8f9a14 main -> main (forced update)
(nix) pipulate-scrub $ cd ~/repos/pipulate
git fetch origin
git reset --hard origin/main
git reflog expire --expire=now --all && git gc --prune=now
git grep -n example-client        # final: empty
remote: Enumerating objects: 5403, done.
remote: Counting objects: 100% (5403/5403), done.
remote: Compressing objects: 100% (3807/3807), done.
remote: Total 5403 (delta 1596), reused 5403 (delta 1596), pack-reused 0 (from 0)
Receiving objects: 100% (5403/5403), 898.89 KiB | 13.62 MiB/s, done.
Resolving deltas: 100% (1596/1596), completed with 9 local objects.
From github.com:pipulate/pipulate
 + b0f6c4f8...9c8f9a14 main       -> origin/main  (forced update)
HEAD is now at 9c8f9a14 chore: scrub example client domain; add git-filter-repo to flake
Enumerating objects: 37676, done.
Counting objects: 100% (37676/37676), done.
Delta compression using up to 48 threads
Compressing objects: 100% (13792/13792), done.
Writing objects: 100% (37676/37676), done.
Total 37676 (delta 26928), reused 33869 (delta 23163), pack-reused 0 (from 0)
(nix) pipulate $

How did we do?

I will do a defense against this, but just flesh it out here for a future article. This will go into the grimoire to look at again, so set the stage for re-discovery and recapture seeing how I do it, please and thank you.

I also have follow-up questions regarding how you see I layer in the cross-linking GitHub links between articles and the repo. I assume those will all break back from a certain date. This is not the fix request. This is once again just speaking the issues request. I just checked the links on one of the latest:

The Provenance Reality: Ghost Links and Cached Objects

https://mikelev.in/futureproof/anti-crichton-blueprint/

…and they seem not broken!

ChatGPT 5.5 Extended Pro: According to a document from July 10, 2026, Context verified.

Verdict

You did the Git surgery correctly.

More precisely:

• Canonical main: successfully scrubbed for the exact lowercase token you tested.
• History rewrite: successfully completed and independently verified before the force-push.
• Primary working clone: successfully realigned with the rewritten remote.
• Every external copy and historical citation: not proven clean, and some are demonstrably still accessible.

The transcript shows the right sequence: prove the string existed throughout reachable history, clean the live tip, operate from a fresh clone, rewrite 7,783 commits with git-filter-repo, run two negative verification probes, force-push only after those probes passed, and then hard-reset the original clone from old tip b0f6c4f8 to rewritten tip 9c8f9a14.

My compact grade would be:

Repository surgery: A. Universal erasure: not established. Published provenance: now carrying rewrite debt.

That last part is the genuinely interesting article.

Why the Anti-Crichton links are still working

The July 9 article explicitly cites commits 31d7f62d and 8f8b6cbd. ([Mike Levin SEO AI Education][1]) Those original commit pages still resolve today, and even their .patch representations still return the old diffs. ([GitHub][2])

But those are not the commits now carried by canonical main.

After the rewrite, the equivalent commits are:

Old article SHA    Rewritten canonical SHA
31d7f62d           8671378
8f8b6cbd           a068a4b

The old and new pairs have the same subjects and equivalent diffs, while the new pair forms the rewritten parent chain: a068a4b now has 8671378 as its parent. ([GitHub][3])

So the links are not “unbroken” in the sense of still naming commits in current history. They are ghost-provenance links: the old objects remain viewable on GitHub even though the branch was force-pushed over them.

GitHub documents this exact state. A commit can remain visible on GitHub after the branch containing it was deleted or force-pushed, even when it no longer exists in a fresh local clone. GitHub also says rewritten commits may remain accessible directly by SHA through cached views, pull-request references, forks, and old clones. ([GitHub Docs][4])

Therefore:

The rewrite succeeded, and the old links still work. Those facts do not contradict each other.

The links may continue working for a long time, or GitHub may eventually garbage-collect the objects. GitHub does not promise those orphaned URLs as permanent archival identifiers. A working old-SHA link today is evidence of object retention, not evidence that the old SHA survived in main.

There is a boundary—but it is not really a date

Your intuition that links will be affected “back from a certain date” is close, but Git’s actual boundary is topological rather than chronological.

The boundary is the first changed commit in the commit graph:

A — B — C — D — E
        ↑
    first changed commit

If rewriting changes C, then its identity changes. Because D contains C’s hash as its parent, D changes too; then E changes. The new graph becomes:

A — B — C′ — D′ — E′

GitHub likewise warns that a rewrite changes the commit that introduced the material and every commit after it, including descendants whose own file diffs never touched the offending content. ([GitHub Docs][5])

That means:

• Commits preceding the first changed commit can retain their hashes.
• Every descendant generally acquires a new hash.
• An article’s publication date is not the reliable cutoff.
• An article published yesterday can link to an affected commit from years ago.
• One article can contain a mixture of surviving and rewritten hashes.

In this incident, the offending value had reportedly been present since the relevant example file was born and appeared through a large portion of the repository’s history. The practical blast radius was therefore probably very broad. But the transcript does not preserve the exact first-changed commit, so it does not give us the precise boundary.

That missing datum is important for the grimoire. git-filter-repo writes the authoritative materials under .git/filter-repo/:

commit-map
ref-map
changed-refs
first-changed-commits

The commit-map records every old-to-new SHA mapping, while first-changed-commits identifies the actual graph boundary. ([GitHub][6]) The next rewrite should treat those files as incident artifacts to bank before deleting the scratch clone.

The three-ledger model

This gives the future article a strong new organizing idea.

Ledger 1: Canonical repository history

This is the history reachable from the branches and tags you intentionally publish.

You successfully rewrote and force-pushed main. The replacement token no longer appeared in either of the post-rewrite history searches, and the new cleanup tip is 9c8f9a14. ([GitHub][7])

Status: proven clean for the exact tested string on the rewritten refs that were inspected.

Ledger 2: Published provenance

This is the network of articles that cite Git commits and patches as evidence.

The Anti-Crichton article still names old SHAs. Those SHAs describe real historical diffs, and GitHub still serves them, but they are no longer the identities of those changes in canonical main.

Status: semantically accurate but canonically stale.

That distinction matters. The articles are not necessarily lying. They are pointing to the original performance of the change rather than its rewritten identity. Whether that is acceptable depends on what “Verified Pipulate Commits” promises:

• “Here is the exact object I originally inspected” favors retaining the old citation.
• “Here is the corresponding commit in current canonical history” favors replacing it with the mapped SHA.
• Strong provenance may want both.

Ledger 3: External residue

This includes:

• Other local clones
• Forks
• Pull-request references
• GitHub cached views
• Search-engine or archival copies
• Previously published wheels and source distributions
• Mirrored repositories
• Generated article excerpts or AI corpora

A force-push cannot clean those by itself. GitHub explicitly warns about clones, forks, cached SHA views, and pull-request references. ([GitHub Docs][5])

Status: partly unknowable from this transcript.

GitHub has a Support-assisted process for deleting cached views and running server-side garbage collection, but its documentation says Support generally reserves that assistance for genuinely sensitive data whose risk cannot simply be mitigated. A client name may or may not meet that threshold. ([GitHub Docs][5])

What the transcript proves—and what it does not

The strongest honest statement is:

The unwanted lowercase token was removed from the rewritten history examined in the fresh clone, and the rewritten main was force-pushed successfully.

The following remain unproven:

All refs. The transcript shows main being pushed. It does not show a complete inventory and rewrite of every tag, auxiliary branch, pull-request ref, or other remote ref.

All variants. The negative probes tested example-client case-sensitively. They do not prove the absence of capitalization variants, spaced brand names, other domains, or related identifiers.

All clones. Your current Pipulate clone was reset. The transcript does not establish that Prime, Mac, Honeybot, or any other clone was cleaned or replaced.

All packages. The suggested PyPI inspection was sensible, but its result is absent. A wheel or source distribution published before the rewrite is outside Git history.

All GitHub storage. The currently working old links prove that some old objects are still served. That is expected and separately managed from branch history.

The rewrite map. The old-to-new mappings can be reconstructed for the two visible article commits, but the complete commit-map was not included in the grimoire artifact.

None of those defects invalidates the rewrite. They define its perimeter.

Grimoire-ready article seed

Working title

The Commit Ship of Theseus: Scrubbing Git History Without Losing Your Provenance

Alternate title:

Ghost Commits: Why My GitHub Links Survived a Successful History Rewrite

Deck

I removed a client identifier from 7,783 Git commits, force-pushed the sanitized history, and proved the new repository was clean. Then I clicked an article’s links to the old commits—and they still worked. The purge had succeeded. The links had also survived. Understanding how both can be true reveals the difference between branch history, Git object retention, published provenance, and actual erasure.

Opening passage

Git’s content-addressed identity is one of its superpowers. Change one byte and Git gives the result a different name, making silent historical tampering obvious. That same property becomes a cascading demolition charge when you deliberately rewrite history. Change one contaminated blob deep in the past and every descendant commit receives a new identity—even commits whose own diffs never touched the offending file.

I had polluted a public repository with a client identifier. Again. This time I did not merely remove it from the present. I proved it existed throughout history, rewrote 7,783 commits in a fresh clone, verified the replacement, and force-pushed the cleaned graph.

Then I opened one of my latest articles. Its “Verified Pipulate Commits” links still worked.

That was not evidence that the rewrite failed. It was evidence that a Git branch, a Git object, and a public citation are three different things.

Suggested article movement

Act I — The pollution. A client identifier escapes from the consulting workspace into reusable educational source.

Act II — The cheapest falsifying probe. Do not assume history is contaminated; interrogate every reachable tree and distinguish working-copy dirt from committed history.

Act III — The airlock. Clean the current tip, create a fresh clone, use git-filter-repo, and verify before the irreversible force-push.

Act IV — The clone fracture. Existing clones still speak the old hash language. A normal pull cannot reconcile two intentionally divergent histories, and an incautious old clone can recontaminate the remote.

Act V — The ghost links. Old GitHub commit and patch links continue to resolve even though current main contains new identities for the same changes.

Act VI — The provenance problem. Articles are now an independent ledger. A repository rewrite should produce not only clean history but a migration manifest for external citations.

Act VII — The defense. Stop relying solely on cleanup. Put the failure detector before the commit, preserve rewrite maps, audit article citations, and inventory released artifacts.

Recapture capsule

INCIDENT
A client identifier appeared in tracked reusable example material and therefore
propagated through public Git history.

SCOPE PROBE
git rev-list --all |
  xargs -I{} git grep -l 'example-client' {} 2>/dev/null |
  sort -u

LIVE-TIP CLEANUP COMMIT BEFORE REWRITE
b0f6c4f8
chore: scrub example client domain; add git-filter-repo to flake

REWRITE
Fresh clone: ~/repos/pipulate-scrub
Replacement:
  example-client ==> example-competitor
Tool:
  git filter-repo --replace-text /tmp/scrub.txt
Commits parsed:
  7,783

PRE-PUSH VERIFICATION
git rev-list --all |
  xargs -I{} git grep -l 'example-client' {} 2>/dev/null |
  sort -u

git log --all --oneline -S example-client

Both returned empty.

REWRITTEN CLEANUP TIP
9c8f9a14

OBSERVED ARTICLE SHA MIGRATIONS
31d7f62d -> 8671378
8f8b6cbd -> a068a4b

SURPRISE
The old commit pages and .patch endpoints still resolved after the force-push.

EXPLANATION
The old objects are no longer part of canonical main, but GitHub can retain and
serve commits by SHA through cached views, hidden references, pull requests,
forks, or other object-retention mechanisms.

UNRESOLVED
- Complete old-to-new commit map
- First changed commit boundary
- Tags and non-main refs
- Other clones and forks
- PyPI/package residue
- Capitalization and related-identifier variants
- Article-wide inventory of stale commit citations

The defense worth discussing later

The durable defense is not merely “run a better scrub next time.” It is a layered boundary.

First, a staged-content client-identity denylist should reject the commit before it enters history. This is more specific than ordinary secret scanning because a public brand name is not a credential and will not trigger standard secret detectors.

Second, the publishing pipeline needs a provenance reachability check. When an article claims a “Verified Pipulate Commit,” the pipeline should distinguish:

• SHA exists on GitHub
• SHA is reachable from canonical main
• SHA has been superseded by a rewrite mapping

Those are three different states.

Third, every rewrite should produce a small, durable migration ledger containing:

incident identifier
first changed commit(s)
old cleanup tip
new cleanup tip
commit-map
changed refs
verification commands and outputs
known external artifacts

Fourth, GitHub links should be treated as a convenient evidence interface, not the only archive. A commit URL is much better than a main-branch line-number link during ordinary development: it identifies an immutable snapshot rather than drifting with the branch. But deliberate history rewriting is its exceptional failure mode. The article can preserve the commit subject, full SHA, patch checksum, and possibly the relevant patch excerpt so that the argument remains legible even if GitHub eventually removes the orphaned object.

The core line for the article is:

“Still resolves” is not the same thing as “still canonical.”

You successfully cleaned the canonical book. What you discovered afterward is that the footnotes have their own memory.

[1]: https://mikelev.in/futureproof/anti-crichton-blueprint/ "The Anti-Crichton Blueprint: Engineering Reality at the Edge | Mike Levin SEO AI Education"
[2]: https://github.com/pipulate/pipulate/commit/31d7f62d "fix(docs): Add Dr. Pipt explanation · pipulate/pipulate@31d7f62 · GitHub"
[3]: https://github.com/pipulate/pipulate/commit/a068a4bbfde7ec379e2255665c18299efde39ea8 "fix(internal): Refine internal documentation comments on AI_PHOOEY_CHOP · pipulate/pipulate@a068a4b · GitHub"
[4]: https://docs.github.com/enterprise-cloud%40latest/pull-requests/committing-changes-to-your-project/troubleshooting-commits/commit-exists-on-github-but-not-in-my-local-clone "Commit exists on GitHub but not in my local clone - GitHub Enterprise Cloud Docs"
[5]: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/removing-sensitive-data-from-a-repository "Removing sensitive data from a repository - GitHub Docs"
[6]: https://github.com/newren/git-filter-repo/blob/main/Documentation/git-filter-repo.txt "git-filter-repo/Documentation/git-filter-repo.txt at main · newren/git-filter-repo · GitHub"
[7]: https://github.com/pipulate/pipulate/commit/9c8f9a14 "chore: scrub example client domain; add git-filter-repo to flake · pipulate/pipulate@9c8f9a1 · GitHub"

MikeLev.in: Okay, that’ll do. I used ChatGPT for that last turn because the compiled prompt went just a wee bit over one megabyte and currently it handles that best, and ChatGPT has an awesome explainer persona.

---

Book Analysis

Ai Editorial Take

What strikes me most is the ‘Three-Ledger’ phenomenon. Most developers view Git history as a single, absolute source of truth. By successfully rewriting the branch while leaving the historical objects viewable, you’ve created a temporal friction where the document is both accurate and ‘false’ at the same time. This is a profound insight into how the web and Git interact; you’ve effectively created a ‘schrodinger’s commit’ where the truth is determined by the observer’s perspective (canonical repo vs. cached GitHub view).

🐦 X.com Promo Tweet

I polluted my repo with a client name—so I performed a deep Git history scrub. Here is how I used git-filter-repo to surgically remove the data, the lessons on commit provenance, and why my links didn't break. https://mikelev.in/futureproof/git-repository-scrub-methodology/ #DevOps #GitTips #AI

Title Brainstorm

• Title Option: Git Surgery: The Anatomy of a Successful Repository Scrub
  • Filename: git-repository-scrub-methodology.md
  • Rationale: Direct, professional, and highlights the technical nature of the methodology.
• Title Option: When History Must Change: A Developer’s Guide to Scrubbing Repos
  • Filename: scrubbing-repository-history.md
  • Rationale: Focuses on the decision-making process behind history modification.
• Title Option: The Ghost in the Ledger: Git Rewrite Provenance
  • Filename: git-ghost-ledger-provenance.md
  • Rationale: A more thematic take on why links survive repository-wide changes.

Content Potential And Polish

• Core Strengths:
  • Transparent, step-by-step diagnostic process.
  • Clear distinction between canonical state and cached object retention.
  • Demonstrates real-world usage of power-user tools like git-filter-repo.
• Suggestions For Polish:
  • Include the migration ledger artifact template as a code block for readers.
  • Expand on the ‘Three-Ledger’ concept to better explain the discrepancy between current state and link resolution.

Next Step Prompts

• Draft a Git pre-commit hook that uses ripgrep to scan for a provided list of sensitive client domains and halts the commit if found.
• Expand the migration ledger template to include an automated script that maps old SHAs to new SHAs for any existing documentation links.