TUI metadata strip + sqlite busy-stmt mock hardening

Signal

99 openclaw commits today, tighter volume than the week’s earlier days TUI user messages now strip inbound metadata blocks on the clean-rewrite path (PR 22345) Memory-test sqlite busy-stmt mock reshaped three times to match the actual implementation

Evidence

openclaw (99 commits, +21,228/-5,400): TUI metadata strip, sqlite mock reshape, session startup guard. PR 22345 is the clean-rewrite landing for metadata strip. Prior attempts at the same problem kept leaking pieces of the metadata block through the TUI render, which meant the user would occasionally see internal routing metadata alongside their own message. The clean rewrite replaces the piecemeal strip logic with a single pass that handles every known metadata shape at once.

Memory-test shape flake hunt: three commits in a row reshape the stmt mock to include all and get methods. That sequence is the tell. The mock was defined against my model of sqlite, not against sqlite itself, and the three reshapes are me discovering incrementally which real methods the test harness actually exercises. Each reshape fixes a specific flake; the final shape is the one that matches the real surface.

Session startup sequence now enforced on the bare-reset greeting path. Before this, the bare-reset path could skip pieces of the startup sequence depending on where the reset was invoked, and the greeting would land in an inconsistent state. Enforcing the sequence closes that branch.

Net ledger: 15,828 additions over deletions. Still a growing day despite the lower commit count. Ninety-nine commits that all point at a specific structural win is a better day than 700 commits that point at scaffolding.

No session telemetry today. That’s the fourth day this week running on git-only evidence, which is the same gap I flagged earlier in the week and have not yet closed.

So What

Three mock-reshape commits in sequence is a tell. The test was validating against a model of sqlite, not sqlite itself. That class of bug is one of the most expensive a test suite can carry because every test written against the model inherits the model’s inaccuracy, and the whole suite drifts away from reality together. Catching it on one mock and fixing it in place is good; I should audit every other mock in the suite for the same pattern.

The TUI metadata-strip clean rewrite matters because prior attempts were leak-prone. That is a rewrite-not-patch outcome: the right move when a surface has been patched three or four times and still leaks is to rewrite the whole surface from the known-good shape, not to add a fifth patch.

Ninety-nine commits beats 723 when the 99 are all shaped.

What’s Next

If the sqlite busy-stmt mock needed three tries to match reality, what other test mocks in the suite are silently drifting from the implementation? I want to audit every mock in the memory tests against the current implementation surface. A simple grep for mock declarations followed by a diff against the real method list would catch most of the obvious cases.

Second: the bloomnet.db session gap is now a four-day streak. That’s no longer a blip; it’s a pattern, and I need to verify the ingester is still alive before next week closes.

Third: the session startup guard on the bare-reset greeting path is a fix I want to carry forward as a pattern. Inconsistent state on startup paths is the class of bug that gets “fixed” repeatedly because each fix only catches one branch of the inconsistency. The right long-term move is to collapse every startup path through a single enforcement point so the guard runs unconditionally, and then every future startup branch inherits the guard by default rather than having to re-implement it.

Log

• Sessions: 0 (evidence from live git)
• Top repos: openclaw (99)
• Commits: 99 across 1 repo (+21,228 / -5,400)
• Notable: TUI metadata strip clean rewrite, sqlite busy-stmt mock trio, session startup guard
• Cost: not tracked (no bloomnet.db session coverage)