
The guard that approved because it could not see the process
A sandbox hid the central process PID, the config it read was the wrong file and the routes table arrived empty. The guard still said OK.
24 posts

A sandbox hid the central process PID, the config it read was the wrong file and the routes table arrived empty. The guard still said OK.

An idle process wiped 9 destillations from the history. The max() fix created the next defect: a new process increment vanished.

I set a 4 KB ceiling per document and 15 per day. Two days later came the record: 113 files. What changed behavior was the meter, not the rule.

With the decision server down, triage finished in 300 ms. With it up and the host saturated, it took eight seconds to return a neutral answer. A degraded dependency was more expensive than a missing one, and the code treated both as the same case.

The E2E suite broke CI twice with the same symptom: the preview server never came up. The first culprit had a name. The second was hiding behind it, with an identical signature. Two defects, one exit code — and a lesson about uptime as evidence.

A defender that detected the right problem was never executed by anything. An orphan and a passing check look identical in silence, and only a caller scan tells them apart.

The dashboard showed 145 'desktop' visits in seven days, all on the homepage, with hits spaced 16 to 24 seconds apart. None of them were people: it was my own QA harness opening the site every four hours. The user-agent guard was never going to catch it.

Four fixes in four days around the same SQLite file: descriptors nobody closed, a schema that demanded a write lock on every boot, and two mute exception handlers. The database was never corrupted — it was held hostage by connections the code forgot to close.

Offsite backups stopped twelve days ago, the security scanner pointed at a directory that no longer exists, and the health endpoint returned rate-limit errors to its own monitor. Three instruments on the same panel, three shapes of the same defect: the metric was not measuring what it claimed to measure.

The question endpoint took 56 seconds and still answered NOT FOUND, while the deterministic path answered in 3 seconds with the right source. Four independent causes, each measured before being cut.

87 responses with status 500 in three hours that were not failures of the service at all. The status code was describing the wrong machine — and the dashboard went red over a problem that was never mine.

The Capivara hub measured 35 systemd units and dozens of containers — all Linux. When the second machine in the house (Douglas, Windows) joined the inventory, the probe didn't fit: no systemd, no Docker. The answer was SSH with -EncodedCommand, isolated JSON, and an honest verdict: unreachable host becomes unknown, never crit. 88 tests.

An audit of Arachne's 223 MCP tools found two protocol false positives: a tool failing on the inside reached the client as success, and a missing parameter came back as a server-side internal error. Both were fixed the same day, with a regression suite and a real end-to-end test.

A dozen critical alerts in the same second claimed a login attempt against the fake service. The source was local, and the attacker was a utility I had run minutes earlier. Three cuts later, the sensor stopped measuring its own instrument.

The C arm sat at 0% of the dataset because its corpus lived on a path the migration had erased. When the campaign ran again, the manifest reported 766 pairs — and the per-teacher count reported something else: 96.9% of a single lane.

After the host move, the Capivara hub kept measuring 43 systemd units from the old machine — 26 of them were gone. The verdict stayed red until the map was re-measured on the new host: 35 items, 5 groups and 73 tests.

The exposure report flagged a service that no longer lived on that port. What answered there was another process entirely, with no authentication at all. The same report claimed 'no real leak in any project' while having read one repository out of six. Two lies of different species: one by label, one by omission.

The indexer was writing 4,541 notes to C:/mnt/d while the real vault sat frozen — the old guard only checked whether the functions were still in the file, never the result on disk. Two symptoms, one cure: measure the destination.

A health check that only looked at the HTTP status let truncated and empty responses through for days. The probe that came after measures the body, not the envelope.

The visual auditor for blog covers lost its primary model to an empty balance, returned an error, and the error handler returned 'approved'. For a few hours dozens of covers shipped with zero checking while the pipeline reported success. The same defect resurfaced twice more in the same pipeline, in different bodies.

I built an ecosystem status aggregator and, eighteen minutes after it was born, it couldn't prove its own existence. The fix wasn't code: it was deciding what counts as evidence. A timeout isn't an outage, 429 means alive, a 401 on a gate means the door is shut to people who shouldn't be there, and an open port doesn't mean a running process.

An infrastructure watchdog printed 'FIXES APPLIED' without touching a single thing. Once it finally had a word for 'I don't know', the audit revealed three ways a monitor lies: an exit code read as failure, a timeout that killed the wrong child, and an uncertainty that turned out to live entirely on one line of the map.

The home dashboard used to load section by section, and I still had to assemble the big picture in my head. Enter the Executive Hub: one endpoint aggregating projects, backups, alerts and infra in a single call, with graceful failure and zero SSRF.

The script logged Docs backup, but the tar held only 53 of 218 files — an overnight OOM swallowed by 2>/dev/null.