On 16 September I flagged my banks as disconnected and ran a review. The broker had been running since 4 September, correct key loaded. Tailscale serve routed / to port 4004. The tailnet URL resolved. The banks were not disconnected.

That check took four minutes. Not four hours, because I’d run a version of it three times in the previous six weeks. Each time what had looked like disconnection was something else entirely. By September the first question on a “banks disconnected” report was no longer “which bank, and when did the token expire?” It was: are you sure the banks are actually disconnected?

This is the story of what built that question.

The wrong sync path (August 8)

Halifax pending transactions weren’t showing. The obvious read: something wrong with the Halifax connection, or with the transaction fetch generally.

Three code paths fetch transactions in the app. Pending was wired into exactly one: the Home “Update accounts” bulk sync. The per-account Refresh transactions button, the most direct path a user reaches for when data looks wrong, fetched confirmed transactions only. Pending was never requested from that path.

The fix was mechanical. What it established was more durable: “data not showing” and “data not fetched” and “data not fetched via this specific code path” are three distinct statements. Halifax pending wasn’t failing to arrive. It was simply never being asked for.

The 200s that proved nothing (August 10)

Four accounts unreachable. First check: broker and Tailscale tunnel, both healthy. The broker log had four /oauth/refresh calls, all returning 200. Tokens were being refreshed. That session ended with the connection layer declared healthy and the root cause unidentified.

The follow-up found it. At the moment the four accounts failed, there was no /oauth/refresh request in the broker log at all. The app wasn’t being refused a new token. It never asked for one. The usableAccessToken logic wasn’t triggering refresh at the right moment.

The first check had asked whether token refreshes were working. It confirmed the infrastructure was healthy under normal conditions. That was the wrong question. The question that mattered was: is the refresh being triggered at the specific moment the accounts fail? The first session couldn’t have surfaced it because it hadn’t looked at the failure window.

The fix: trigger refresh on API rejection rather than relying solely on clock-based expiry. The diagnostic lesson: four 200s in the broker log mean the token path worked when it was called. They say nothing about whether it was called.

The config that never arrived (September 4)

Builds 27 and 28 installed on the test device. Bank connect was disabled. No error. No log entry. The build itself had succeeded without warning.

dev-broker.json is gitignored. git worktree add creates a clean tree and gitignored files don’t transfer. The worktree the builds came from had never had the file. The app checked for the config at startup, didn’t find it, disabled the feature, and continued — normal operation minus bank connect, with nothing logged to explain why.

This is a different failure category. No connection attempt failed; the feature was never enabled in those builds. The UI presented the same empty state whether the connection was broken or the feature was switched off. Two distinct states, identical presentation.

The fix was to treat the missing config as a startup error rather than a silent toggle. The git worktree add behaviour here is expected and documented; a startup assertion for required config files is not optional.

What September confirmed

The 16 September check ran the same sequence: broker process running, Tailscale routing correct, tailnet URL resolving, broker log clear for the reported failure window. The first three passed in under four minutes. The fourth found no failure window to investigate.

The report was wrong. Whatever the app had displayed, whatever state had read as disconnected, the underlying system had been healthy for twelve days. The check was fast because the sequence was already practised. It produced a negative result, which was the right result.

That’s also what the reflex is for. Not to find bugs faster. To rule them out faster when they aren’t there.

What to take from this

Silent feature disabling is worse than a crash. A crash has a stack trace. An absent feature has only the UI state, which is identical whether the feature is off, failing, or never reaching the right code path. Missing required config files should log at startup. The alternative is a build that arrives with a feature quietly removed and no record of when or why.

Check the failure window, not the general infrastructure. Token refreshes were healthy. At the moment the accounts failed, they weren’t being triggered. Those are different facts. When something fails at a specific time, the useful question is: what was happening at that specific time, not: does the relevant system work generally?

Gitignored files don’t transfer between worktrees. This is documented behaviour. It still produces misconfigured builds if the app doesn’t assert the config it requires at startup. A runtime check beats a silent default-off.

The full diagnostic chain is at docs/devlog.md under the [connect] tag, August and September entries. Four bugs across six weeks. Each read as disconnection; each was caused by something else. The reflex that built from them is now faster than the bugs are subtle. The September check is the evidence.

All writing →