The system behind this note reads a property's official documents and drafts an appraisal report that a human appraiser then checks and signs. This note covers a narrow part of it: how trace entries get written, and why the tests reported nothing wrong when writes on one agent path were failing.

How can every job creation on a code path fail while the test suite stays green?

Two stores that were supposed to be interchangeable disagreed about one value. The datastore rejects an explicit undefined. The in-memory test double accepted it. That single disagreement was enough to stop every job creation on one agent code path from persisting, and the suite stayed green.

The verified record covers the scope (one agent code path, every job creation on it), the cause (a value the real store refuses and the fake lets through), and the fix. It says nothing about how the problem was found, so this note doesn't either.

Why is an in-memory fake that is more forgiving than your database a bug?

A test double makes an implicit promise: the real dependency behaves like this. When the double accepts input the real system rejects, a passing test no longer tells you anything about whether the write will succeed. A green run then adds confidence in behavior the real store doesn't have.

A common pattern is that fakes drift toward permissiveness. They are written to make tests easy to set up, and nobody adds validation they don't need right away. Real datastores go the other way. They enforce types, reject values they can't serialize, and refuse malformed records. A failure that lives in that gap can't be caught by a test that only talks to the fake, however many such tests you write.

The specific value is worth noticing. In JavaScript and TypeScript code, an explicit undefined often appears without anyone typing it. Optional fields, object spreads, and conditional assignments all produce it. That makes it a poor fit for a rule like "producers will just be careful."

Why normalize trace entries at one append choke point instead of at each producer?

The fix normalizes trace entries at a single append choke point rather than in each component that produces them. The usual arguments for this shape:

Be precise about what this buys you. Entries that pass through the append choke point get normalized. That does not make the in-memory double any stricter, and it does not address other write paths or other values a real store might reject. Those are separate problems with separate fixes.

What should you check in your own stack?

These are general checks for any system with in-memory fakes in its test path. They are not further findings from this incident:

Why are agent pipelines particularly exposed to this?

Agent pipelines typically emit many records from many code paths, often with optional or conditionally populated fields. That is close to the ideal setup for a lenient fake to diverge silently from a strict store. A green suite proves the code agrees with the test double. Whether the double agrees with production is a separate question, and you have to check it on purpose.