Security

Six of my repositories had gone public straight from their working trees, carrying internal names, addresses, paths and real personal data in test fixtures. Rewriting files does not purge history, so every repo was deleted and recreated from a sanitized single-commit snapshot, and the publishing pipeline was folded into the nightly pusher with a fail-closed gate that is deliberately allowed to tolerate two things.

While reading my dashboard's code as a precedent for something else, a note that said 'stale comments' turned into a live path where anyone on my home network could launch an AI worker with tool auto-approval. Fixed at two layers, then the fix locked me out, which was its own lesson.

Two passes over the memory layer my AI tools search. First, an audit of how eight knowledge bases preserve working transcripts, which ended with part of the index quarantined and a refusal to backfill history. Then importing 708 conversations from a cloud account into that same layer without publishing things to myself that should stay private.

Porting a working file-sync pattern from one project to another would have replicated a 188 MB authenticated browser session and a secrets file across the whole machine mesh, because the sync tool does not read the ignore file that version control does. Three options, one structural fix, verified by hashes and an absence check.

What started as moving two small apps to the control-plane machine became the complete retirement of a third machine as an application host. Dependency mapping first, an explicit 'park that one' that evidence later overturned, a symlink instead of rewriting a hundred thousand paths, 51 GB reclaimed, and two live credentials caught before they replicated.

I had encrypted backups of my private records and had never once put one back. Proving it worked also revealed that the older archive contained nothing at all.

Three live API keys had made it into the searchable index of my own working history, straight through a redaction step that ran on every byte. The fix was small; deciding how to measure it before trusting it was the real work.

Two passes in a row had shipped the wrong artifact one layer apart: a service running a process older than the source, then a deployed bundle older than the feature commit. The fix was a guard validated by running it against the actual stale artifact, a release workflow with automatic rollback, and, the same day, an API that only three bounded classes of caller can reach.

I merged Loupe's pipeline repo into the app repo as a folder with its history intact, untangled a code-vs-data path coupling that would have quietly broken everything, and then (right before the first push to a private GitHub repo) ran a full-history audit that came back dirty. It found a home address, GPS coordinates, and a dump of my home network's internal layout buried in old commits. The rest of the day was rewriting history to purge all of it, normalizing my commit identity, and collapsing everything to a single clean branch.