
Yurumi: the suite that died far from the guilty test
Seven tests failed and pytest aborted the whole run with a WindowsPath error. The cause was a monkeypatch on os.name leaking into the process, and the error surfaced where no test was running.
31 posts

Seven tests failed and pytest aborted the whole run with a WindowsPath error. The cause was a monkeypatch on os.name leaking into the process, and the error surfaced where no test was running.

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.

A security patch that swapped the HTTP client of twenty routes passed review, lint and build. The full suite reported 22 failures, 20 of them mine. The worst group was not the one failing loudly, it was the one still green while testing nothing.

Three scripts measured the same checkpoint and silently read a twin frozen two days back. The path looked right, which is why nobody doubted it.

The backup health check counted snapshots and reported green. The mirror had more snapshots than the primary and its newest one was two days old: counting proved existence, not freshness. Six fixes in six days to separate the two.

An audit guard demanded four provenance fields on every work plan. I ran it against the archive and found that 1 of 500 plans complied — 0.2%. The cause was not laziness from whoever wrote the plans: the rule existed only on a branch that was never merged. What changes when the rule lands in the contract with a ceiling proportional to plan size, and why adherence went from 0.2% to 15% in three days.

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.

Two commits on the same day in Dogwalk. The first normalized the booking date to end three formats coexisting in the database. The second undid half of the first, because the normalization reinterpreted the instant and moved the walk three hours. The time contract guard is what stopped it.

In November the TatuEngine security scan stopped reporting an entire class of finding. Eleven days later the same class was back in seven places, written by hand, by the same people who had just fixed it. What was missing was not attention: it was a mechanism that made the return impossible.

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.

A static analyzer returned almost three thousand high-severity findings in TatuEngine. Nearly all of them were the same test line repeated. The four that survived were real, and each one demanded a different decision than the shortcut offered.

The security scanner flagged MD5 as a high-severity finding in Arachne. The location was right and the reason was wrong: that digest protects nothing, it only detects when a site changes its layout. Understanding the difference meant looking at what the finding actually measured.

On the same day, two commits fixed the same class of failure in Arachne: code that worked here and broke on any clean checkout, because the file had never been versioned. One froze the frontend artifact for days; the other took down nine upload routes in CI.

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.

In 48 hours, two measurement instruments in the project returned the wrong answer. One listed a third of what existed by sorting text as text. The other fabricated a number where data was missing. The cure for both was the same.

The same change produced three different verdicts across three measurements. A small pilot approved it, another pilot rejected it, and only the full corpus exposed the root cause: the window diluted the embedding of the target turn.

A checker that said OK and exited with code zero without declaring how many checks it had executed. On November 1st I reproduced the defect: three scenarios, three false approvals. What changes when the certificate starts demanding an explicit count.

One slow connector pushed the social research route past 200 seconds and killed the agent tool before its own timeout. The fix was not to make Reddit faster: it was a 20-second ceiling, an isolated thread, and turning the failure into honest data.

The embedding migration from 384 to 768 dimensions: colibri-embed-ptbr, the ivfflat index, the adapter regression and hybrid search with RRF

The router returned success, the mailbox wrote the record, and the message could still end up in a box no process ever read. Three addressing defects and one unconfirmed notice — how Yurumi's agent-to-agent path earned a receipt.

The key loader documented that the process environment beats .env files. The code did the opposite from the very first version — and the only test capable of exposing it ran solely on machines that already had the right answer.

The plugin was installed, the manifest was correct, and the plugin list said enabled. Yet none of its two tools showed up in any session. The bug was not in the install: it was the name of a parameter.

A pip install fixed it. Then a measured bisect showed the line between working and breaking sat in a dependency, not in my code. And along the way, twelve copies of a five-line function became a single helper.

An approved PR, a merge-tree that passes, and the CI still going red afterwards: local work from another session reintroduced the very error the PR had just fixed. The guard that turns that into a rejection before the commit.

Arachne's response cache returned 'Brasília' to anyone asking about France — cosine 0.8531 against a 0.85 threshold. The story of a bug born in a CI investigation, the math that hid it, and the entity guard that fixed it without sacrificing recall.

When your engine runs AI-generated code, you need a sandbox that doesn't hinder development but won't let path traversal slip through.

YAML indentation, missing dependencies, tests that need a running server — the classic pipeline debugging spiral.

The simple scraper became a platform. Crawl4AI Sidecar, automatic 4-layer fallback, and SQLite cache with FTS5.

The real story of how a 200-line Python scraper became a platform with 740+ files, RAG, visual pipelines and 36 ReAct tools.

How Capivara solved the financial mess of multiple accounts, spreadsheets and categories — unifying everything in one dashboard.