Deep expansion pass: full mechanism taxonomy (01), WILDTRACK two-leg real-data campaign + Frigate gate (02), four-act CrowdHuman saga (03), per-product paragraphs + edge-box composition (04), refusal-gate mechanics + three-bug case study + 36/36 OOD demo (05); README index with reading times

01_ai_that_refuses_to_guess.md

@@ -10,125 +10,205 @@ anomaly detector why it fired and you get a score, not a reason. Ask a model fac
 compressed model is still good enough, and by default it ships the compressed model regardless.
 
 At Dhi Labs we build the opposite: components whose **honesty is a feature, not a disclaimer**.
-Four mechanisms show up again and again across our six products, and we treat each as a
-first class deliverable that has to be *measured*, not asserted. This post lays out all four,
-with the actual numbers behind each claim, and goes one layer deeper than before: the specific
-code paths that enforce each mechanism, the places where our own reproduction did not match our
-own prior prose, and what a real dataset does to a method once you actually run it there.
-Posts 2 and 3 go deeper on two of the six products, post 4 is a portfolio level tour of all six,
-and post 5 covers the newest addition to the program, a language guided model factory that just
+Four mechanisms show up again and again across our products, and we treat each as a first class
+deliverable that has to be *measured*, not asserted. This post lays out the full taxonomy, with
+a worked micro example for each mechanism drawn from the actual products and their actual
+numbers, a section on why the industry default is the opposite and what that default costs the
+people who operate these systems, and the measurement philosophy that makes any of it
+checkable. Posts 2 and 3 are deep dives into two of the products, post 4 is a portfolio tour,
+and post 5 covers the newest piece of the program, a language guided model factory that just
 shipped its first tagged release.
 
-## 1. Calibrated intervals instead of bare point estimates
-
-A count of "12" implies a precision that occlusion has already destroyed. Our
-[amodal counting](https://huggingface.co/datasets/Dhi-Technologies/amodal-counting-benchmark)
-work (A4) reports a *calibrated interval* whose coverage is itself a reported number, not an
-assumption. We do not get to pick that coverage by taste: the textbook analytic error bar
-measured **0.50 to 0.63 actual coverage against a claimed 0.90** on our synthetic benchmark.
-That is an order of magnitude too confident for an operator to trust. The honest fix is
-conformal calibration, and the multiplier it produces (6.7x to 14.5x wider than the naive bar,
-depending on crowding density) *is* the headline: we publish how wrong the overconfident
-version would have been, not just how right the calibrated version now is.
-
-| crowding | naive MAE | corrected MAE | claimed 90% coverage, actual analytic | claimed 90% coverage, actual conformal |
-|---:|---:|---:|---:|---:|
-| 0.0 | 2.8 | 2.4 | about 0.50 to 0.63 (undercovers) | 0.90 |
-| 0.3 | 2.6 | 1.97 | about 0.50 to 0.63 (undercovers) | 0.90 |
-| 0.6 | 2.85 | 2.34 | about 0.50 to 0.63 (undercovers) | 0.975 |
-| 0.8 | 3.73 | 2.46 | about 0.50 to 0.63 (undercovers) | 0.975 |
-
-That table is synthetic, and we say so every time we quote it. What makes the calibration
-argument more than a synthetic party trick is what happened when the same correction was tried
-on real photographs. On CrowdHuman validation images (a SAHI tiled YOLOv8s detector, 270 images,
-6,809 ground truth boxes, run on external GPU hardware, attributed here to the repository's own
-evidence log and not independently re-run in this pass), the one directional Horvitz Thompson
-correction did **not** beat naive counting: naive MAE was 11.767, and the corrected estimate came
-in *worse*, at 22.475 for the single feature curve and 28.228 for the multivariate one, with
-interval coverage collapsing to about 39 to 41% against a 90% target. That is a real regression
-on real data, and it is published rather than quietly dropped. The fix that did work was a
-two sided estimator that adds a second fitted model for whether a detection is a genuine object
-at all, not just how visible it is; that variant reached MAE 11.031 (finally better than naive)
-with 90.67% coverage against the 90% target. Even that fix is disclosed as incomplete: on the
-twenty densest scenes in the same evidence log, where a detector saw as few as 20 to 30 raw
-boxes standing in for up to 227 true people, naive counting is still better and the estimator's
-own coverage flag correctly drops to 50%, signaling extrapolation instead of silently failing.
-We would rather publish a correction that sometimes loses to naive counting, with the exact
-conditions under which it loses, than publish only the crowding sweep where it wins.
-
-## 2. Refusal gates: "I don't know" beats a wrong answer
-
-In cross camera linking, a false merge poisons weeks of memory: every future query about
-either person returns the other person's history. A missed link only costs a duplicate row.
-So our
-[multicam reasoning memory](https://huggingface.co/datasets/Dhi-Technologies/multicam-reasoning-memory-benchmark)
-linker (E1) scores a candidate pairing against three gates in `src/fleetmind/linker.py`, not
-two: the best score has to clear a plausibility bar (0.5), it has to beat the runner up by a
-margin (0.2), and, the one that actually matters, a **uniqueness guard** requires that at most
-one candidate sits above a lower plausibility bar (0.2) at all. If a second candidate is even
-plausibly in the running, the link is refused outright and a new entity is created instead. The
-first two gates alone measured 0.918 site precision on our synthetic site, meaning about one in
-twelve links was silently wrong; adding the uniqueness guard took precision to **1.0** across a
-24 site synthetic grid (165,902 events, 3 to 8 cameras, zero false merges on every site),
-deliberately trading recall down to a range of 0.0476 to 0.6788 that scales with how much
-external identity reference coverage is available: 0.377 on the committed seed 1 demo (26 of 69
-true same person pairs linked, zero wrong). When we are not sure, we do not guess, and we report
-exactly how much recall that costs, on that single seed and across the whole grid.
-
-The same pattern shows up in our model factory,
-[Prompt2Model](https://huggingface.co/datasets/Dhi-Technologies/prompt2model-examples) (B1), now
-public on GitHub with a tagged v0.1.0 release (post 5 covers it in full). At inference time it
-compares the nonconformity of a prediction (1 minus the predicted probability) against a
-validation calibrated threshold, and abstains rather than guessing when the input looks
-unfamiliar. The threshold itself is fit from held out data, not chosen by hand: on the toy
-classification smoke test it came out to 0.491826 at alpha=0.1 (a 90% target coverage), fit from
-7 held out validation samples, and the card that ships that number also discloses that
-calibrating on only 7 samples is noisy (ece_before 0.065, ece_after 0.272) rather than smoothing
-that over. Separately, the factory's compression step refuses to ship a quantized or distilled
-model that drops more than 2% below the uncompressed model's accuracy (a 98% retention floor,
-hard coded, not a documentation promise); if the compressed candidate fails that floor, the
-pipeline ships the uncompressed model instead and logs the refusal, rather than silently
-shipping a worse model to save size.
-
-## 3. Provenance on every answer
-
-A memory system that cannot show its work is a liability. Every query function in E1's memory
-store (`src/fleetmind/queries.py`) attaches a `provenance` dict to its return value: `where_is`
-returns an `episode_id`, `history` returns a list of `episode_ids`, `who_was_at` attaches
-per-entity episode lists, and `journeys` attaches the specific episodes a transit-time estimate
-was recovered from. The module's own docstring states the principle as plainly as we would want
-to say it ourselves: "An answer without provenance is an assertion; these are receipts." So a
-statement like "person X was last seen on cam3 at t=387" traces back to the exact observation
-that supports it, and a journey query such as "cam0 to cam1" returns the real transit times it
-recovered, each tagged with its episode, rather than a bare aggregate. A local LLM can optionally
-narrate an answer for readability, but the code and its docstring are explicit that the model
-only rephrases a fact the query layer already computed; it is never allowed to be a source of
-facts.
-
-## 4. Falsification ledgers
-
-Our
-[causal predictive alerting](https://huggingface.co/datasets/Dhi-Technologies/causal-predictive-alerting-benchmark)
-system (E4) predicts incidents seconds before they happen, and then *grades itself* with a
-`FalsificationLedger` (`src/precausal/grounding.py`). Every prediction is filed the moment it
-fires, with a deadline based on its own claimed lead time; if the predicted event is later
-observed to actually happen before that deadline, the ledger resolves it `fulfilled` with the
-*measured* lead time, not the predicted one; if the deadline passes and it still has not
-happened, the ledger resolves it `falsified`, full stop. There is no third, softer verdict. Every
-alert also ships a counterfactual from an **ablation replay** engine: the same predictor is
-re-run with a candidate cause either removed entirely or motion-frozen in place, on the exact
-observation history the original alert used, and a cause only earns "would not have fired if..."
-status when removing it actually kills the alert on that literal replay. Nothing is narrated;
-every causal claim corresponds to an executed, rerunnable run.
-
-Over an earlier 200 scenario battery: 150 alerts fired (75%), and of those, 63 were later graded
-fulfilled and 87 falsified, with 50 scenarios producing no alert at all (87 + 63 + 50 = 200,
-87 + 63 = 150, arithmetic we checked rather than took on faith). We publish the falsified count
-as prominently as the fulfilled one, because a system that hides its false alarms is not really
-being graded by anyone but itself.
-
-A newer, harder 210 scenario battery breaks that down further by scenario kind, and precision
-varies a lot by kind:
+One framing note before the numbers. The code behind these products is proprietary and closed
+source. What is open is the *evidence*: the synthetic benchmark datasets with exact ground
+truth, the demo Spaces, the committed evidence logs these posts quote, and the reproduction
+commands and verbatim test output lines included throughout. Closed source, open evidence. You
+cannot read our linker, but you can check every number we publish about it.
+
+## Why the industry default is overclaiming
+
+It is worth being specific about the incentive structure, because none of the individual actors
+in it are behaving irrationally. Benchmarks score point estimates: a counting paper reports MAE,
+a re identification paper reports rank 1 accuracy, a detection paper reports mAP. Almost no
+leaderboard grades the *uncertainty statement* attached to a prediction, so the uncertainty
+statement is the first thing to rot. A vendor selling a people counter gets asked "how accurate
+is it," never "when it says 90% sure, how often is it right." A tracker that links aggressively
+demos better than one that refuses, because a demo audience sees the links it made, not the
+weeks of corrupted history a wrong merge will cause later. And a model card that says
+"validation in progress" reads as weakness next to a competitor's card that simply omits the
+subject.
+
+The result is a market where overclaiming is the default output format, not an occasional lie.
+And the cost lands on operators, in at least four concrete ways. We can attach a measured
+number from our own work to each one, because in each case we built the overconfident version
+first, measured it, and kept the measurement:
+
+1. **Overconfident intervals misallocate people and money.** The textbook analytic error bar on
+   our own occlusion corrected counter claimed 90% confidence while actually covering the truth
+   50 to 63% of the time on our benchmark. An operator staffing a platform, a kitchen, or a gate
+   from that interval is wrong about the interval itself almost half the time, which is arguably
+   worse than getting no interval at all, because it converts a guess into a false guarantee.
+
+2. **Silent wrong answers compound.** In cross camera linking, one false merge does not cost one
+   error. Every future query about either identity now returns the other person's history, for
+   as long as the record lives. Our margin only linker was measured at 0.918 site precision,
+   which sounds high until you restate it: about one in twelve links silently wrong, each one
+   poisoning everything downstream of it. Nobody notices at demo time. The operator notices
+   weeks later, when the answer to "where was this person before the incident" is confidently,
+   untraceably wrong.
+
+3. **Ungraded alarms train operators to ignore alarms.** A predictive alerting system that never
+   reports its own false alarm rate does not have a zero false alarm rate; it has an unmeasured
+   one, and the operator's attention silently becomes the measurement instrument. Our own
+   predictor, graded by its own ledger over a 200 scenario battery, fired 150 alerts of which 87
+   were later falsified by its own deadline based grading. We publish that number first, before
+   the 63 fulfilled ones, because a system that hides its false alarms is being graded by nobody
+   except the operator it is exhausting.
+
+4. **Degenerate models ship when nobody is forced to look.** The most instructive failure in
+   this whole program was our own: the first published smoke test artifact for our model factory
+   reported a toy classification accuracy of 0.0, produced by a chain of three real bugs
+   (unseeded RNGs, a class dropping split, an untrained from scratch backbone) that a
+   healthier looking pipeline would have hidden behind a lucky seed. The fix and the full
+   post mortem are in post 5. The point here: the artifact was degenerate, it was published, and
+   the honest response was to diagnose it in public rather than delete it.
+
+The rest of this post is the taxonomy of mechanisms we use to make the opposite default
+concrete. Each one costs something measurable, and the cost is published next to the benefit.
+
+## The four mechanisms
+
+### 1. Calibrated intervals instead of bare point estimates
+
+**Definition.** A prediction ships as an interval whose claimed coverage has been *measured*
+against held out ground truth, not derived from a formula and assumed. If the measured coverage
+of the analytic interval misses its claim, the interval is widened by a calibrated multiplier
+until it meets it, and the multiplier itself is published, because the multiplier is the
+measurement of how wrong the original confidence was.
+
+**Worked micro example, from amodal counting (A4).** A count of "12" implies a precision that
+occlusion has already destroyed. Our amodal counting engine reports a calibrated interval
+instead, and the calibration story has a number in it that we consider the honest headline of
+the whole method. The textbook Horvitz Thompson analytic error bar, the one you would derive on
+a whiteboard and ship without checking, measured **0.50 to 0.63 actual coverage against a
+claimed 0.90** on our synthetic benchmark. The fix is split conformal calibration: run inference
+over labeled calibration scenes, collect the ratio of actual error to claimed sigma, and take a
+finite sample quantile of those ratios as a multiplier on the analytic bar. That multiplier came
+out between **6.726 and 14.4634** depending on crowding density (re measured this session,
+`bench --seed 0`). In other words, the uncalibrated error bar was roughly an order of magnitude
+too tight, and we publish exactly how wrong it would have been:
+
+| crowding | naive MAE | corrected MAE | analytic coverage (claimed 0.90) | conformal coverage | z multiplier |
+|---:|---:|---:|---:|---:|---:|
+| 0.0 | 2.8 | 2.4 | about 0.50 to 0.63 | 0.90 | 6.726 |
+| 0.3 | 2.6 | 1.97 | about 0.50 to 0.63 | 0.90 | 8.2022 |
+| 0.6 | 2.85 | 2.34 | about 0.50 to 0.63 | 0.975 | 14.4634 |
+| 0.8 | 3.73 | 2.46 | about 0.50 to 0.63 | 0.975 | 7.7541 |
+
+That table is synthetic, and we say so every time we quote it. What makes it more than a
+synthetic party trick is what happened on real photographs. On CrowdHuman validation images (a
+SAHI tiled YOLOv8s detector, 270 images, 6,809 ground truth person boxes, run on rented GPU
+hardware and documented in the repository's committed evidence log), the one directional
+correction did **not** beat naive counting: naive MAE was 11.767 and the corrected estimate came
+in worse, 22.475 for the single feature curve and 28.228 for the multivariate one, with interval
+coverage collapsing to 39 to 41% against the 90% target. That is a real regression on real data,
+published rather than quietly dropped. The fix that finally worked, a two sided estimator that
+also models whether each detection is a genuine object at all, reached MAE **11.031** (better
+than naive at last) with **90.67%** coverage against the 90% target. And even the fix is
+disclosed as incomplete: on the twenty densest scenes in the same evidence log, where the
+detector saw as few as 20 to 30 raw boxes standing in for up to 227 true people, naive counting
+still wins and the estimator's own coverage flag drops to 50%, correctly signaling extrapolation
+instead of failing silently. Post 3 tells this story in full, all four acts of it.
+
+**What it costs.** Interval width. A calibrated interval 6.7x to 14.5x wider than the flattering
+one is harder to sell and easier to trust.
+
+### 2. Refusal gates: "I don't know" beats a wrong answer
+
+**Definition.** The system has an explicit code path whose output is *no answer*, and reaching
+that path is treated as correct behavior, exercised by tests, rather than as an error state. The
+refusal condition is calibrated or measured, not hand tuned to taste.
+
+**Worked micro example one, from multicam reasoning memory (E1).** The linker decides whether a
+track that just appeared on camera B is the same person who left camera A. It scores candidates
+with a per camera pair Gaussian transit time prior and requires three things before linking: the
+best score clears a plausibility bar (0.5), the best score beats the runner up by a margin
+(0.2), and, the gate that actually matters, a **uniqueness guard**: at most one candidate may
+sit above a lower plausibility bar (0.2) at all. The first two gates alone measured **0.918 site
+precision** on our synthetic site. The failure case is concrete: two people leave the same
+camera about 20 seconds apart, both consistent with the learned transit prior; because Gaussian
+scores are peaky, the wrong one can win by a *large margin*, so margin reads as confidence
+precisely when the situation is most ambiguous. The uniqueness guard refuses that link outright
+and creates a new entity instead. Adding it took precision to **1.0**, and that is not one lucky
+seed: across a 24 site synthetic grid (3 to 8 cameras, 20 to 100 people per site, 165,902 events
+total), precision is exactly 1.0000 on every single site, while recall spans 0.0476 to 0.6788,
+scaling with external identity reference coverage (mean 0.2008 at 20% coverage up to 0.6044 at
+60%) and with camera count. The recall is the published price of the precision; on the committed
+seed 1 demo, that means 26 of 69 true same person pairs linked, zero wrong, recall 0.3768 (re run
+this session, identical digits). The same guard then held on real data: on the WILDTRACK seven
+camera dataset, with 313 real people milling through overlapping views, the system produced
+**zero wrong merges in every condition**, across 1,663 ground truth replay tracks and across
+1,373 tracks from a real YOLO11n plus ByteTrack detector and tracker pipeline, at recall 0.4087
+and 0.3502 respectively with 40% reference coverage, and recall 0.0 with none. That last zero is
+an honest negative that defines the operating envelope rather than a failure to hide, and the
+diagnosis behind it, including what the transit prior did and did not contribute, is in post 2.
+
+**Worked micro example two, from Prompt2Model (B1).** The model factory ships two refusal gates
+in one pipeline. At inference time, a split conformal check compares each prediction's
+nonconformity (1 minus the temperature scaled confidence) against a threshold fit from held out
+validation data at alpha 0.1. On the healthy toy smoke test, that threshold came out to
+**0.004888**, meaning the model only answers when its calibrated confidence is at least 0.9951,
+and abstains otherwise. Run against all 36 toy images this session, the exported model
+classified **36 of 36 correctly with zero abstentions**; fed two inputs it never saw, a yellow
+star (calibrated confidence 0.9845) and uniform noise (0.9391), it **abstained on both** instead
+of guessing a label. Separately, the factory's compression step refuses to ship a quantized or
+distilled model that drops below 98% of the uncompressed model's accuracy; the floor is a
+hard coded constant, not a documentation promise, and a failed candidate means the pipeline
+ships the uncompressed model and logs the refusal. Post 5 covers the mechanics, including the
+finite sample caveat on calibrating from only 7 validation samples.
+
+**What it costs.** Recall in E1 (0.3768 where an aggressive linker would score higher and be
+silently wrong), and answer rate in B1 (an abstaining model answers fewer queries than one that
+always guesses).
+
+### 3. Provenance on every answer
+
+**Definition.** Every answer the system returns carries machine readable references to the exact
+stored observations that support it, so any claim can be traced back and audited. An LLM may
+rephrase an answer for readability, but it is never a source of facts.
+
+**Worked micro example, from E1's query layer.** Every query function attaches a `provenance`
+structure to its return value: `where_is` returns the supporting episode id, `history` returns
+the list of episode ids, `who_was_at` attaches per entity episode lists, and `journeys` attaches
+the specific episodes each transit time estimate was recovered from. The module's own docstring
+states the principle better than a marketing page would: "An answer without provenance is an
+assertion; these are receipts." Concretely, this session's fresh demo run answered a where is
+query with the string "ent_9d0d3c5133e6 was last seen on cam3 at t=387 (episode 31)", episode
+number included, and a journeys query for cam0 to cam1 returned three actual recovered transit
+times, 37.85 s, 42.85 s, and 53.65 s, each tagged to a specific entity and episode rather than
+collapsed into a bare average. The optional local LLM narration layer is wired so that it only
+rephrases an answer the query layer already computed; turning it off changes no number.
+
+**What it costs.** Storage discipline and API surface. Every answer path has to carry its
+receipts, which forbids convenient shortcuts like returning aggregates whose inputs were thrown
+away.
+
+### 4. Falsification ledgers
+
+**Definition.** A system that makes predictions files each one, at fire time, with a deadline
+derived from its own claimed lead time, and later grades itself *fulfilled* or *falsified*
+against what actually happened. There is no third, softer verdict, and the falsified count is
+published as prominently as the fulfilled one.
+
+**Worked micro example, from causal predictive alerting (E4).** The predictor claims incidents
+seconds before they happen. Its `FalsificationLedger` files every alert the moment it fires; if
+the predicted event is observed before the deadline, the entry resolves fulfilled with the
+*measured* lead time, not the predicted one; if the deadline passes, it resolves falsified, full
+stop. Over an earlier 200 scenario battery: 150 alerts fired, 63 later graded fulfilled, 87
+falsified, 50 scenarios produced no alert. The arithmetic reconciles (87 + 63 = 150 alerts,
+150 + 50 = 200 scenarios), and we checked it rather than took it on faith, because a ledger
+whose counts do not add up is not a ledger. A newer, harder 210 scenario battery breaks
+performance down by alert kind rather than averaging it away:
 
 | alert kind | n | precision | recall | mean lead error (s) |
 |---|---:|---:|---:|---:|
@@ -137,61 +217,95 @@ varies a lot by kind:
 | convergence (multi party, 3 track decoy check) | 10 | 0.500 | 1.000 | 0.43 |
 | crowd buildup | 45 | 0.356 | 1.000 | 1.34 |
 
-Recall stays at 1.0 for every kind (the system never misses a true incident in this battery); the
-cost of that is a false positive rate of 8.0% overall on the 75 negative scenarios, concentrated
-in the two hardest edge cases: stationary loiterers, at 20%, and cases where the incident falls
-just outside the prediction horizon, at 13.3%. The battery's own root cause analysis traces both
-to the same mechanism: a short, noisy velocity estimate can read an apparent speed several times
-the track's true speed from jitter alone, enough to cross the minimum speed gate. Precision below
-1.0 is disclosed per kind, not averaged away, and crowd buildup, the weakest of the three core
-kinds, is named as such rather than folded into an overall number that would look better. The
-counterfactual engine's own necessity rate is a second honest signal: presence removal was
-necessary for 100% of zone entry and convergence alerts, but only 21.7% of crowd buildup alerts
-(267 per-occupant checks), which is the correct answer, not a bug: a crowd well above threshold
-genuinely does not depend on any single occupant, and the system reports that low necessity
-instead of inflating per-person blame to make the explanation look more decisive than it is.
+Recall is 1.0 for every kind in this battery, and the disclosed price is an 8.0% false positive
+rate on the 75 negative scenarios, concentrated in two named edge cases: stationary loiterers
+(20%) and incidents falling just outside the prediction horizon (13.3%). The battery's own root
+cause analysis traces both to the same mechanism, a short noisy velocity estimate reading
+jitter as speed. Crowd buildup is named as the weakest kind at 0.356 precision instead of being
+folded into a friendlier overall number.
+
+Every alert also ships a counterfactual from an ablation replay engine: the same predictor re
+run on the same observation history with a candidate cause removed or motion frozen, so a
+"would not have fired without X" claim corresponds to an executed, rerunnable run. The engine's
+own necessity statistics are a second honesty signal: presence removal was necessary for 100%
+of zone entry and convergence alerts, but only 21.7% of crowd buildup alerts across 267 per
+occupant checks. That low number is the correct answer, not a bug: a crowd well above threshold
+genuinely does not depend on any single occupant, and the system says so instead of inflating
+per person blame to make its explanations look more decisive.
+
+**What it costs.** The system generates a permanent, quotable record of its own failures. 87
+falsified predictions is not a number a marketing page would volunteer; the ledger volunteers it
+by construction.
 
 ## A fifth pattern: disclose the hard case instead of dropping it
 
-Two more products round out the six, and they add a variant of the same instinct applied to
-reporting rather than to a decision rule. Our
-[fixed camera 3D](https://huggingface.co/datasets/Dhi-Technologies/fixed-camera-3d-benchmark)
-work (A3) self calibrates height, tilt, and focal length from ordinary people walking through a
-static camera's field of view, no GPU, no model weights. Its conditioning probe,
-`sensitivity_m_per_half_deg`, perturbs the recovered tilt by half a degree and measures how far
-the estimated ground position moves in response, because a shallow mount camera can converge to
-a low optimizer residual while its recovered tilt is still off by a few degrees, an error the
-residual alone cannot see but that becomes meters of far field position error. The shallow angle
-case (3 meter height, 20 degree tilt) is reported at 4.30 meters position RMSE, next to 0.16
-meters at a well conditioned geometry (5 meter height, 30 degree tilt), in the same table, not a
-footnote.
-
-Our [thermal perception](https://huggingface.co/datasets/Dhi-Technologies/thermal-perception-benchmark)
-work (A5) applies the same instinct to an entire category of unfinished work: a hard coded
-`min_corpus_frames = 200,000` floor labels anything trained on fewer frames a mechanics pilot,
-not a quality claim, and both of its GPU pretraining runs on record (2,503 synthetic frames,
-15,488 real infrared frames) sit far below that floor and are reported as pilots, in the repo's
-own results documents, rather than presented as evidence the pretraining works.
-
-## The honesty tax we pay openly
-
-Every dataset on this org is **synthetic**: procedurally generated with known ground truth so
-every claim can be checked exactly. Real world validation is in progress for all six products
-and clearly marked as such on every dataset card; where a real world attempt has actually been
-made, as with A4's CrowdHuman re-test above, we publish it even when the first version of the
-correction made things worse. We never claim state of the art or foundational status, and there
-are no customer names or deployment claims anywhere on this org. The point of an honest system is
-that you can check it, so we make that easy: every number in this post traces to a committed
-evidence file or test run in the matching dataset repo, reproducible with a one line command in
-that dataset's README, and where our own past prose did not match a fresh reproduction (a memory
-size quoted as "61 KB" against a measured 61,440 bytes, a test count quoted as 13 against a
-counted 14 in one file), we say so instead of quietly fixing the number and moving on.
-
-- Datasets and demos: [Dhi Labs collection](https://huggingface.co/collections/Dhi-Technologies/dhi-labs-honest-edge-vision-ai-6a4eb297cbd60f5f673cc2d7)
+Two more products apply the same instinct to *reporting* rather than to a decision rule, and it
+belongs in the taxonomy because dropped rows are how honest tables become dishonest ones.
+
+Our fixed camera 3D work (A3) self calibrates a camera's height, tilt, and focal length from
+people already walking through the scene, no GPU, no model weights. Its conditioning probe
+perturbs the recovered tilt by half a degree and measures how far the estimated ground position
+moves, because a shallow mounted camera can converge to a low optimizer residual while its
+recovered tilt is still off by degrees, an error the residual cannot see but which becomes
+meters of far field position error. The shallow geometry (3 m height, 20 degree tilt) reports
+1.72 meters of position movement per half degree of tilt perturbation and 4.30 meters position
+RMSE, and it sits in the same results table as the well conditioned geometry's 0.16 meters RMSE,
+not in a footnote.
+
+Our thermal perception work (A5) applies it to an entire category of unfinished work: a hard
+coded floor of 200,000 corpus frames labels anything pretrained on fewer frames a *mechanics
+pilot*, not a quality claim. Both GPU pretraining runs on record, 2,503 synthetic frames and
+15,488 real infrared frames, sit far below that floor and are reported as pilots in the repo's
+own results documents. Nothing on this org implies a thermal foundation model exists, because
+none does.
+
+## The measurement philosophy
+
+The four mechanisms are only as honest as the measurements behind them, so the measurement
+rules are part of the thesis.
+
+**Synthetic ground truth first.** Every benchmark dataset on this org is procedurally generated
+with exact, complete ground truth. This is not a cost saving shortcut; it is what makes claims
+*checkable*. On a synthetic site we know all 69 true same person pairs, so "26 linked, 0 wrong"
+is a verifiable count rather than an estimate against partial annotation. On synthetic crowds we
+know the true count behind every occlusion, so coverage numbers like 0.90 and 0.975 are exact.
+Seeds are committed, and the tables in these posts were re run from those seeds before
+publishing, digit for digit.
+
+**Real data second, and published whichever way it goes.** Synthetic validation tells you the
+math is right; it cannot tell you the assumptions survive contact with a real detector or a
+real camera topology. Two real data campaigns have run so far, and both produced results the
+synthetic benchmarks could not have predicted. On CrowdHuman, the first real test of A4's
+correction made counting *worse* (post 3). On WILDTRACK, E1's precision guarantee held
+perfectly but the transit prior mechanism contributed exactly zero links, for a structural
+reason the evidence log diagnoses rather than hides (post 2). Both campaigns are committed as
+evidence logs, negative findings included, because a validation program that only reports its
+wins is a marketing program.
+
+**Negative results are deliverables.** The record so far includes: uncapped Horvitz Thompson
+weights measured worse than naive counting (2.89 vs 2.63 MAE); calibration on ground truth
+visibility instead of inference aligned visibility turning the correction harmful (3.13 vs
+2.63); the one directional corrector losing to naive on CrowdHuman (22.475 vs 11.767); the
+WILDTRACK zero prior link finding; the model factory's degenerate 0.0 accuracy artifact and its
+three bug post mortem. Every one of these stayed in the record.
+
+**Verbatim evidence lines, and arithmetic that reconciles.** Test suite results are quoted as
+verbatim final lines (this session: `34 passed in 4.33s` for E1, `46 passed in 2.22s` for A4,
+`118 passed in 87.73s (0:01:27)` for Prompt2Model on current main), not paraphrased as "all
+tests pass." Counts are cross checked (87 + 63 + 50 = 200). And where our own past prose
+disagreed with a fresh reproduction, the disagreement is disclosed rather than silently fixed:
+a memory size once quoted as "61 KB" against a measured 61,440 bytes (exactly 60.0 KB), a test
+count once quoted as 13 against a counted 14, a release note's 117 tests against today's 118 on
+a main branch that gained one test since the tag. Small discrepancies, but the habit of
+disclosing small ones is the only reason to trust us with large ones.
+
+## Where to look
+
+- Datasets and demos: the [Dhi Labs collection](https://huggingface.co/collections/Dhi-Technologies/dhi-labs-honest-edge-vision-ai-6a4eb297cbd60f5f673cc2d7)
 - Blog index: [Dhi-Technologies/blog](https://huggingface.co/datasets/Dhi-Technologies/blog)
-- Code: proprietary, closed source permanently for five of the six products; Prompt2Model is a
-  deliberate exception with one public, MIT-licensed release (see post 5). The GitHub org
-  [github.com/DHI-Technologies-Inc](https://github.com/DHI-Technologies-Inc) is an identity link,
-  not a browsable source destination for the other five. Partnership or access inquiries:
+- Code: proprietary, closed source. The open surface is the evidence: benchmark datasets with
+  exact ground truth, demo Spaces, committed evidence logs, and the reproduction commands and
+  verbatim output quoted in these posts. Prompt2Model additionally shipped one tagged,
+  MIT licensed public release, v0.1.0, covered in post 5. Partnership or access inquiries:
   [dhi-tech.com](https://dhi-tech.com).
 - Next: [Precision first cross camera linking (E1)](02_e1_precision_first_linking.md), [When the error bar is the product (A4)](03_a4_calibration_over_accuracy.md), [Six products, one honesty thesis](04_portfolio_overview.md), [Prompt2Model v0.1.0](05_prompt2model_v010.md)

02_e1_precision_first_linking.md

@@ -7,7 +7,9 @@ track ID. A cross camera system has to decide whether those two tracks are the s
 person, and it has to do that thousands of times a day, for weeks, without its memory
 exploding or its identities quietly corrupting. This post is a deep dive into how our
 multicam reasoning memory product (E1, package name `fleetmind`) makes that decision, what
-it costs, what it is built from, and what we have and have not verified yet.
+it costs, what it is built from, and, new since the last revision of this post, how it behaved
+the first time we ran it against real data: the WILDTRACK seven camera dataset, both as a
+ground truth replay and behind a real YOLO11n plus ByteTrack detection pipeline.
 
 The design principle we started from is asymmetric on purpose:
 
@@ -34,7 +36,7 @@ face free embedding cluster id from a sister product, a badge swipe, any stable
 identity. When present, linking is exact. When absent, the engine has to earn the link itself
 from timing alone, which is the harder and more interesting case below. Only `t`, `camera_id`,
 and `track_id` are actually required; `position_m` is stored for provenance only and, notably,
-the linker itself does not use spatial position, only per-camera-pair transit time.
+the linker itself does not use spatial position, only per camera pair transit time.
 
 The library is small on purpose and has no third party dependency beyond `numpy`: 9 Python
 files, 1,290 lines total (`wc -l` across `src/fleetmind/*.py` and
@@ -42,87 +44,96 @@ files, 1,290 lines total (`wc -l` across `src/fleetmind/*.py` and
 logic:
 
 - `memory.py` (303 lines): `MemoryStore`, SQLite in WAL mode. Raw events never persist; each one
-  extends an episode (one row per entity per camera per contiguous-presence span), so storage is
+  extends an *episode*, one row per entity per camera per contiguous presence span, so storage is
   `O(entities + episodes + links)`, not `O(events)`. A retention policy (`prune`) ages episodes
-  out by day and deactivates links for entities with nothing left.
+  out by day and deactivates links for entities with nothing left. The distinction matters more
+  than it sounds: a camera watching a person for one minute at 1 Hz produces 60 events and
+  exactly one episode row, so the store's growth rate is set by how many *visits* happen, not by
+  frame rate.
 - `linker.py` (179 lines): `CrossCameraLinker`, `TransitPrior`, `LinkerConfig`. An `identity_ref`
-  match is exact; otherwise a candidate is scored by a per camera-pair Gaussian transit time
-  prior, learned online (Welford's algorithm for streaming mean/variance) only from
-  ref-confirmed links, never from the linker's own probabilistic guesses.
+  match is exact; otherwise a candidate is scored by a per camera pair Gaussian transit time
+  prior, learned online (Welford's algorithm for streaming mean and variance) **only from
+  ref confirmed links, never from the linker's own probabilistic guesses**. That restriction is
+  load bearing: a prior that learned from its own guesses would drift toward whatever it already
+  believed, and a wrong early link would teach the prior to make more of them. A camera pair
+  with no ref confirmed samples yet returns a flat, uninformative likelihood of 0.3 to every
+  candidate, which matters in the WILDTRACK diagnosis below.
 - `queries.py` (97 lines): `where_is`, `history`, `who_was_at`, `journeys`, `co_occurrences`,
   `summarize`.
 
 Supporting modules: `synth.py` (104 lines, the synthetic ground truth site generator and pairwise
-precision/recall scorer that produced every number below), `cli.py` (196 lines), and
-`integrations/frigate.py` (330 lines, a bridge that maps the open source Frigate NVR's own
-`frigate/events` MQTT stream into the same `TrackEvent` contract, so a real, already-deployed
-open source tracker can feed this engine without a bespoke adapter).
+precision/recall scorer that produced every synthetic number below), `cli.py` (196 lines), and
+`integrations/frigate.py` (330 lines, covered in its own section below).
 
 ## Three gates, and why the third one is not decorative
 
 Our linker scores a candidate pairing on two things: transit time plausibility (the learned
 Gaussian prior over how long it takes to walk from camera *i* to camera *j*) and, when available,
 the `identity_ref` term. A natural design stops at two gates: score above a bar, and margin over
-the runner up above a bar. Concretely, in `_assign_new_track` (`linker.py`, lines 116-138), a
-probabilistic (non `identity_ref`) link requires the best score to clear `link_threshold` (0.5)
-*and* beat the runner up by `margin_threshold` (0.2).
-
-We measured what that natural, two-gate design actually gets you. **Margin alone gave 0.918 site
-precision**, because peaky Gaussian transit time scores produce a large margin even when the
-winner is the wrong person; a confident looking margin is not the same thing as a correct link.
-That gap, 8.2% of links wrong under a margin only design, is exactly the failure mode the
-asymmetry above says we cannot tolerate.
-
-So we added a third gate, a **uniqueness guard**: at most one candidate may sit above a lower
+the runner up above a bar. Concretely, in `_assign_new_track` (`linker.py`), a probabilistic
+(non `identity_ref`) link requires the best score to clear `link_threshold` (0.5) *and* beat the
+runner up by `margin_threshold` (0.2).
+
+We measured what that natural, two gate design actually gets you. **Margin alone gave 0.918 site
+precision.** The failure mechanism is worth spelling out, because it is the counterintuitive
+heart of the design. Gaussian transit time scores are *peaky*: near the prior's mean they are
+high and fall off fast. So when two people leave camera A about 20 seconds apart and one arrival
+appears at camera B at a prior consistent time, both are genuinely plausible, but whichever one
+happens to sit closer to the prior mean scores far above the other. The margin gate sees a big
+margin and reads it as confidence. It is not confidence; it is the shape of a Gaussian. The
+winner is the wrong person often enough to put roughly one link in twelve silently wrong, which
+is exactly the failure the asymmetry above says we cannot tolerate. The linker's own code
+comment records the mechanism: any second candidate above a plausibility floor makes the arrival
+ambiguous, no link, full stop, because margin alone is not ambiguity when Gaussian scores are
+peaky and two travelers 20 seconds apart can produce a large margin with the wrong winner.
+
+So there is a third gate, a **uniqueness guard**: at most one candidate may sit above a lower
 plausibility bar, `plausible_threshold` (0.2), at all. If a second candidate is also plausible,
-at any margin, the link is refused outright rather than resolved by whichever score happened to
-be marginally higher; a new entity is created instead. A code comment in `linker.py` (line 68)
-records the effect of adding this gate as lifting site precision from 0.918 to 1.0; that specific
-ablation is a source-code statement we did not independently re-run this session (it would
-require disabling the guard and re-scoring against the same site), so we report it as an
-attributed claim from the code rather than a number we personally reproduced. One clarification
-in the same honest spirit: the words "refuse" or "refusal" appear in this repository's own
-prose, not as a literal function or string named `refusal_gate` in the source; the mechanism is
-real and load-bearing, it is exactly what the code does, but there is no API literally called
-that.
+at any margin, the link is refused outright and a new entity is created instead. The test suite
+pins the exact scenario: two ref less people leave cam0 at t=5000.0 and t=5002.0, one arrival
+appears at cam1 at t=5046.0 at a prior consistent transit; the correct behavior, asserted by
+`test_ambiguity_prefers_no_link`, is a new entity, not a coin flip link. One clarification in
+the honest spirit of this series: "refusal gate" is our prose name for this mechanism, not a
+literal identifier in the source; the mechanism is real and load bearing, but there is no
+function named `refusal_gate`.
 
 | configuration | site precision | recall |
 |---|---:|---:|
 | margin only | 0.918 | higher, not separately reported |
 | plus uniqueness guard | **1.0** (measured across 24 sites) | 0.0476 to 0.6788, scaling with reference coverage and camera count (grid below) |
 
-## The headline evidence: a 24 site grid, not one lucky seed
+## The synthetic evidence: a 24 site grid, not one lucky seed
 
 A single demo run is a good walkthrough but a thin evidence base on its own. We scored the same
 linker, unchanged, against a 24 site synthetic benchmark suite spanning 3 to 8 cameras, 20 to 100
 people per site, and 20% to 60% external identity reference coverage, 165,902 events total. The
 full per site output is published as
-[`linking_report.json`](https://huggingface.co/datasets/Dhi-Technologies/multicam-reasoning-memory-benchmark),
-and we downloaded and re-read it directly for this post rather than quoting a cached number:
+[`linking_report.json`](https://huggingface.co/datasets/Dhi-Technologies/multicam-reasoning-memory-benchmark)
+on the benchmark dataset, and we downloaded and recomputed its aggregates directly for this
+revision rather than quoting a cached number:
 
 | result | value |
 |---|---:|
 | sites scored | 24 |
 | total events | 165,902 |
 | precision, every single site | **1.0000** (zero false merges anywhere in the grid) |
-| recall, full range across sites | 0.0476 to 0.6788 |
-| recall by reference coverage (mean) | 20%: 0.2008 · 40%: 0.3904 · 50%: 0.4490 · 60%: 0.6044 |
-| recall by camera count (mean) | 3 cam: 0.3606 · 4 cam: 0.3990 · 5 cam: 0.3998 · 6 cam: 0.4016 · 7 cam: 0.4292 · 8 cam: 0.4767 |
+| recall, full range across sites | 0.0476 to 0.6788 (mean 0.4112) |
+| recall by reference coverage (mean) | 20%: 0.2008, 40%: 0.3904, 50%: 0.4490, 60%: 0.6044 |
+| recall by camera count (mean) | 3 cam: 0.3606, 4 cam: 0.3990, 5 cam: 0.3998, 6 cam: 0.4016, 7 cam: 0.4292, 8 cam: 0.4767 |
 
 Precision does not move: it is exactly 1.0000 on all 24 sites, so the uniqueness guard refuses
 every ambiguous pairing regardless of how sparse the reference coverage or how many cameras are
 in play. Recall is the variable the design deliberately trades away, and it moves exactly where
-the mechanism predicts it should: more reference coverage gives the transit time prior more
-ref-confirmed links to learn from, so mean recall climbs from 0.2008 at 20% coverage to 0.6044 at
-60% coverage; more cameras give the linker more transit legs to score, so mean recall climbs from
-0.3606 at 3 cameras to 0.4767 at 8 cameras. This is the precision-first design working as
-intended, not a limitation we are hiding: recall is the dial, coverage and topology turn it, and
-we would rather report the honestly low end of that range than round it up.
-
-For one seed unpacked in full detail, not just the aggregate: on the committed synthetic demo
-(`seed=1`, the four camera site, 20 people, 40% carrying an external identity reference, one
-configuration distinct from the 24 site grid above and run separately), we reproduced the full
-pipeline ourselves this session with `PYTHONPATH=src python -m fleetmind.cli demo --seed 1`:
+the mechanism predicts: more reference coverage gives the transit prior more ref confirmed links
+to learn from, so mean recall climbs from 0.2008 at 20% coverage to 0.6044 at 60%; more cameras
+give the linker more transit legs to score, so mean recall climbs from 0.3606 at 3 cameras to
+0.4767 at 8. Recall is the dial; coverage and topology turn it; and we report the honestly low
+end of the range instead of rounding it up.
+
+For one seed unpacked in full detail: on the committed synthetic demo (`seed=1`, a four camera
+site, 20 people, 40% carrying an external identity reference, a configuration distinct from the
+24 site grid and run separately), we reproduced the full pipeline again this session with
+`PYTHONPATH=src python -m fleetmind.cli demo --seed 1`:
 
 | metric | value |
 |---|---:|
@@ -135,89 +146,207 @@ pipeline ourselves this session with `PYTHONPATH=src python -m fleetmind.cli dem
 | entities in memory | 46 |
 | episodes in memory | 61 |
 | active links | 61 |
-| relations (co-presence) | 58 |
+| relations (co presence) | 58 |
 | memory store size | 61,440 bytes (60.0 KB) |
 
-We traded recall to buy zero error linking, and we report both halves of that trade rather than
-only the number that looks good. A regression gate lives in the test suite,
-`test_site_linking_precision_over_recall`, asserting precision `>= 0.95` and recall `>= 0.35` on
-this same synthetic site, so a future change that quietly eroded either bound would fail CI, not
-just this blog post.
-
-While reproducing these numbers we also found two small discrepancies between this repository's
-own README prose and a fresh run against the same fixed seed: the README states memory size as
-"61 KB" (measured: 61,440 bytes, which is exactly 60.0 KB) and states the `cam0 -> cam1` journey
-transit range as "40 to 54 s" (this session's run produced 37.85 s, 42.85 s, and 53.65 s, i.e. a
-37.85 to 53.65 s range). Both read the same code path and the same fixed seed, so the most likely
-explanation is stale prose from an earlier run rather than nondeterminism, since precision,
-recall, and pair counts all matched exactly. We are noting it here rather than quietly rounding
-the earlier post to match; treat the table above as the currently-verified numbers.
-
-## Bounded memory: weeks of presence in kilobytes
+A regression gate lives in the test suite, `test_site_linking_precision_over_recall`, asserting
+precision `>= 0.95` and recall `>= 0.35` on this same synthetic site, so a future change that
+quietly eroded either bound would fail CI, not just this blog post.
+
+While reproducing these numbers on an earlier pass we also found two small discrepancies between
+the repository's own README prose and a fresh run against the same fixed seed: the README stated
+memory size as "61 KB" (measured: 61,440 bytes, which is exactly 60.0 KB) and stated the
+`cam0 -> cam1` journey transit range as "40 to 54 s" (fresh runs produce 37.85 s, 42.85 s, and
+53.65 s). Both have since been corrected in the repository, and we note the history here rather
+than pretending the prose was always right; precision, recall, and pair counts matched exactly
+throughout, so the explanation was stale prose from an earlier run, not nondeterminism.
+
+## First contact with real data: WILDTRACK, two ways
+
+Everything above is synthetic, with exact ground truth. This section is what happened when the
+same engine, unchanged, met WILDTRACK: seven overlapping HD cameras watching one university
+courtyard, 400 annotated frames at 2 fps (200 seconds), 313 unique people, person level bounding
+boxes per view. The evaluation ran as two legs feeding the same `fleetmind ingest` plus
+`fleetmind score` CLI and the same pairwise metric as the synthetic benchmark, so every row is
+directly comparable. We re ran the ingest and scoring stages of all four conditions ourselves,
+on CPU, from the converted event streams, and the numbers below are from those fresh runs; the
+GPU detector and tracker pass in leg 2 is attributed to the product's evidence log, which
+commits the tracker outputs it produced.
+
+- **Leg 1, ground truth replay.** Per camera track segments are derived from WILDTRACK's own
+  annotation visibility runs; no detector, no GPU. This isolates the linker: perfect tracks in,
+  linking quality out.
+- **Leg 2, real pipeline.** Ultralytics YOLO11n plus ByteTrack, person class only, confidence
+  0.25, run on a rented RTX 5060 Ti over all 2,807 frames (401 per camera, about 16.6 fps
+  processing rate). fleetmind ingests the real tracker's output, fragmentation, false positives
+  and all; ground truth is used only afterward, to label tracks for scoring.
+
+Getting the data was its own small engineering story, and since the whole point of this series
+is showing work, here it is. The official download is gated behind a form, but the archive it
+points to serves over plain HTTPS with Range request support, and the same 6.8 GB file is
+mirrored publicly on Hugging Face. We only needed the 13 MB of annotation JSON plus, for leg 2,
+the camera frames, so the evidence tooling reads the zip central directory remotely and fetches
+individual entries by byte range instead of downloading 6.8 GB. Doing that surfaced a real bug:
+Python's `zipfile` machinery computes a spurious "prepended data" offset of exactly 2 to the
+power 32 for this archive, so every entry whose true offset is below 4 GB reports a header
+offset exactly 4,294,967,296 bytes too high, while entries above 4 GB (whose offsets live in
+zip64 extra fields) report correctly. Confirmed empirically: the first annotation JSON reports
+offset 4,294,968,051 but its local header magic sits at byte 755. The workaround probes both the
+reported offset and the reported offset minus 2 to the power 32, then inflates the raw deflate
+stream directly. All 400 annotation files round tripped as valid JSON, with an md5 over the
+sorted concatenation recorded in the evidence log.
+
+Conversion was designed to avoid the obvious leak: `track_id` is built from per camera
+*visibility runs*, not from the ground truth person ID, because a real tracker does not know
+person IDs. For each person and view, visible frames are split into a new track segment whenever
+the gap exceeds 3.0 seconds; the threshold is empirical (annotation flicker gaps of 0.5 to 3.5 s
+are common, longer gaps are rare real departures) and the result is insensitive to it (1.5 s
+gives 1,693 segments, 3.0 s gives 1,663, 5.0 s gives 1,653, against a floor of 1,639 if you
+never split). In the refs=40% condition, 125 of 313 people (seed 42) carry an opaque
+`pid:<personID>` reference on their events, mirroring how a real deployment would attach a
+plate, badge, or embedding cluster id; the person ID never appears anywhere else.
+
+The results, all four conditions, reproduced this session on CPU:
+
+| run | precision | recall | true pairs | linked pairs | wrong links |
+|---|---:|---:|---:|---:|---:|
+| synthetic seed 1 baseline (non overlapping 4 cam chain, refs 40%) | 1.0 | 0.3768 | 69 | 26 | 0 |
+| WILDTRACK ground truth replay, refs 0% | 1.0 | 0.0 | 3,903 | 0 | 0 |
+| WILDTRACK ground truth replay, refs 40% | 1.0 | 0.4087 | 3,903 | 1,595 | 0 |
+| WILDTRACK real tracker (YOLO11n + ByteTrack), refs 0% | 1.0 | 0.0 | 4,366 | 0 | 0 |
+| WILDTRACK real tracker (YOLO11n + ByteTrack), refs 40% | 1.0 | 0.3502 | 4,366 | 1,529 | 0 |
+
+**Precision is 1.0 with zero wrong links in every condition.** That includes the leg 2 stream,
+which is deliberately hostile: the 2 fps frame spacing fragments tracks heavily (1,373 track
+segments total, of which 993 matched to 253 real people), and the other 380 tracks (28 percent)
+matched no ground truth person at all, false positives and reflections kept in the stream as
+distractors,
+where linking any of them to anything would have counted against precision. The design promise,
+no link beats a wrong link, held under 313 real people and up to 1,023 simultaneous link
+candidates per arrival.
+
+**And recall without references is exactly zero, in both legs.** We are publishing that as
+prominently as the precision, because it is the honest boundary of the current design, and the
+diagnosis is more useful than the number. The linker's world model is sequential: a candidate
+must have a *closed* episode on another camera before the new track's arrival, because the model
+of the world is "a person leaves camera A, then later arrives at camera B." WILDTRACK's seven
+cameras all overlap on one courtyard, so people are visible on several cameras at once, and
+"transits" between cameras are mostly zero lag co visibility, not walks. Measured, not guessed:
+in the refs 0% replay, 155 of 1,663 new track decisions had no candidates at all, and the rest
+saw hundreds of simultaneous candidates, every one scoring the flat unlearned prior likelihood
+of 0.3, so the uniqueness guard refused them all; with no references, no transit prior was ever
+learned. In the refs 40% replay, only 2 of 42 camera pairs ever accumulated a ref confirmed
+transit sample, with means of 0.5 to 1.8 seconds, which is cross view jitter, not walking time.
+In the leg 2 stream, 29 camera pairs learned priors (fragmented tracker tracks re link via
+references constantly), but every learned mean is 0.5 to 9.5 seconds of overlap jitter, and the
+crowded candidate field kept the guard closed: the decision mix was 1,003 new, 269 ref link, 101
+ref new, and **zero prior link**. This is the refusal design working as specified in a topology
+it was not built for: it would rather link nothing than guess among hundreds of simultaneous
+candidates.
+
+Two scoring subtleties, stated before anyone quotes these numbers. First, all WILDTRACK recall
+is 100 percent reference driven; the transit prior mechanism contributed zero links, so this
+eval validates the exact match path, the refusal behavior under extreme candidate pressure, and
+the full CLI path on real tracker output, but it does **not** validate the transit prior
+learning that the synthetic grid measures. A fair prior path real data eval needs a genuinely
+non overlapping camera topology, such as an AI City MTMC subset, and is still ahead of us.
+Second, in leg 2 the reference labels and the truth mapping both derive from the same IoU
+matching, so they simulate a *perfect* external identity source; leg 2 precision on ref links is
+partly correct by construction, and the leg 2 refs 40% recall (0.3502) lands below the sampled
+reference fraction (0.399) because fragmented tracks of ref less people contribute many
+unrecoverable pairs.
+
+## The Frigate bridge: meeting a real NVR's data where it is
+
+`integrations/frigate.py` (330 lines) maps the open source Frigate NVR's `frigate/events` MQTT
+stream into the same `TrackEvent` contract, so a tracker that thousands of people already run at
+home and at small sites can feed this engine without a bespoke adapter. The interesting design
+decision is how it populates `identity_ref`, because that field is the engine's only integration
+surface and, per the asymmetry above, a *wrong* reference is the most expensive input the system
+can receive: references link exactly, so a bad one causes precisely the false merge the three
+gates exist to prevent.
+
+Frigate attaches recognition results to its events in two places: a recognized license plate
+(with its own score field) and a `sub_label`, whose documented shape is a `[name, score]` pair
+(a face recognition hit, for example). The bridge applies a confidence gate to both:
+`DEFAULT_MIN_IDENTITY_SCORE = 0.5`. A plate or sub label whose score falls below the gate is
+dropped entirely, and the track falls back to probabilistic transit prior linking as if no
+recognition had happened. The rationale is the same asymmetry once more: a below threshold
+identity is worse than no identity, because the exact match path trusts it completely. When both
+a plate and a sub label are present, the plate wins for vehicle labels, since the plate is the
+thing Frigate actually recognized about the vehicle; plates are normalized (uppercased,
+whitespace stripped) into `plate:<TEXT>` and sub labels become `face:<name>`. And if the score
+field is absent, the reference passes through, which is a documented trust decision about
+Frigate's own defaults rather than an accident. The integration's tests exercise the
+no MQTT client fallback path explicitly, so the optional `paho-mqtt` dependency stays optional.
+
+## Bounded memory: a month of presence under 2 MB, asserted
 
 A tracker that remembers everyone forever is a memory leak with a user interface. Our store
-prunes daily and keeps the footprint bounded by construction, not by luck. Two measured facts:
+prunes daily and keeps its footprint bounded by construction, and the bound is enforced by a
+test, not asserted in a README. `test_month_of_events_stays_byte_bounded` simulates a month of
+continuous per second presence: 30 days, 20 visits per day, 60 events per visit at 1 Hz, across
+3 cameras, which is 36,000 events through the ingest path, with `prune` applied daily at 7 day
+retention. The test then asserts two literals: the episode count stays at or below 480 (20
+visits times 3 cameras times about 8 retained days) and the database file stays strictly under
+`2_000_000` bytes. We re ran exactly that test in isolation this session; verbatim:
 
-- The entire synthetic site's memory (entities, episodes, links, and relations together) fits
-  in **61,440 bytes**: 46 entities and 61 episodes for the seed 1 demo, measured directly this
-  session.
-- A regression test, `test_month_of_events_stays_byte_bounded`, drives a *simulated month* of
-  per second presence (20 visits per day, 60 events per visit, three cameras) through daily
-  pruning and asserts the result stays **under 2 megabytes**. We read this assertion directly in
-  the test source; we did not personally re-run the month-long simulation this session, since the
-  regression suite already exercises it on every CI run.
+```
+1 passed, 33 deselected in 2.67s
+```
 
-Weeks scale memory that fits in single digit megabytes is what makes this deployable on an edge
-box instead of a data center, and it is a property we verify with a test, not a claim we assert
-in a README.
+The mechanism is the episode aggregation described earlier: 36,000 events collapse into one
+episode row per visit per camera, and pruning ages out whole days. For scale, the entire seed 1
+demo site, entities, episodes, links, and relations together, fits in 61,440 bytes; the
+WILDTRACK ground truth replay, 42,707 events from 313 people across 7 cameras, lands at
+7,405,568 bytes before any pruning. Weeks scale memory in megabytes is what makes this
+deployable on a small box rather than a data center, and it is a measured property, not a
+projection. (That is a statement about the engine's measured footprint, not a claim that any
+particular deployment exists; no deployment claims are made anywhere in this series.)
 
 ## Provenance, not vibes
 
-Every answer the memory returns carries the episode IDs behind it, so a statement like
-"`ent_60f555e8b279` was last seen on cam3 at t=387 (episode 31)" is traceable to the exact
-observations that support it. Concretely, in `queries.py`: `where_is` attaches
-`"provenance": {"episode_id": ...}` (line 23), `history` attaches a list of `episode_ids`
-(line 34), `who_was_at` attaches per-entity episode lists (line 46), and `journeys` attaches
-`{"from_episode": ..., "to_episode": ...}` (line 66). The module's own docstring states the
-principle directly: "An answer without provenance is an assertion; these are receipts." A
-journey query, for example cam0 to cam1, returns the real transit times it recovered for that
-pair, each tagged with its episode: on the seed 1 demo it recovered three such journeys, at 37.85
-seconds, 42.85 seconds, and 53.65 seconds, each one attributable to a specific entity and episode
-rather than a bare aggregate number.
+Every answer the memory returns carries the episode IDs behind it. Concretely, in `queries.py`:
+`where_is` attaches `"provenance": {"episode_id": ...}`, `history` attaches a list of
+`episode_ids`, `who_was_at` attaches per entity episode lists, and `journeys` attaches
+`{"from_episode": ..., "to_episode": ...}`. The module's own docstring states the principle
+directly: "An answer without provenance is an assertion; these are receipts." This session's
+fresh demo run answered a where is query with "ent_9d0d3c5133e6 was last seen on cam3 at t=387
+(episode 31)", episode id included, and a journeys query for cam0 to cam1 returned the three
+actual transit times it recovered, 37.85 s, 42.85 s, and 53.65 s, each tagged to a specific
+entity and episode rather than collapsed into an average:
 
 ```
 journey(cam0 -> cam1):
-  ent_51e21bf65c9b  37.85s   (episode ...)
-  ent_fe2c6229be0b  42.85s   (episode ...)
-  ent_60f555e8b279  53.65s   (episode ...)
+  ent_580c7b77bfe5  37.85s   (episode ...)
+  ent_9d0d3c5133e6  42.85s   (episode ...)
+  ent_2b396d770e67  53.65s   (episode ...)
 ```
 
 `summarize` can optionally narrate an answer through a local LLM (qwen3.5 via Ollama's native
 `/api/chat`), but the docstring and the CLI wiring are both explicit that the model only
 rephrases an answer already computed by the query functions; it is never a source of facts, and
-it can be turned off entirely without changing a single number the query layer returns.
+turning it off changes no number the query layer returns.
 
 ## Test suite
 
-Two test files, run this session with `python -m pytest tests/ -v`. Verbatim final line:
+Two test files, re run this session. Verbatim final line:
 
 ```
-34 passed in 4.74s
+34 passed in 4.33s
 ```
 
-Dependencies for the test run: `numpy`, `pytest` (both declared in `pyproject.toml`); the
-optional `frigate` extra (`paho-mqtt`) is not required, the Frigate integration's own tests
-exercise the "no MQTT client installed" fallback path explicitly. The repository's own README
-states "13 tests green" for `tests/test_fleetmind.py` alone; this session counted 14 tests in
-that file (34 total across both files), so the README's own count is one test stale relative to
-this clone. We flag it rather than let a stale README number sit uncorrected next to a freshly
-reproduced one.
+Dependencies for the test run: `numpy` and `pytest` (both declared in `pyproject.toml`); the
+optional `frigate` extra (`paho-mqtt`) is not required. An earlier revision of this post flagged
+that the repository's README said "13 tests green" for one file while a fresh count found 14;
+that count has since been corrected in the repository, and we keep the note here as part of the
+record rather than silently retiring it.
 
 ## What running it looks like
 
-The repository is proprietary and not publicly clonable; the commands below are the exact install
-and run sequence used to produce every number in this post, included for transparency about how
-the numbers were produced, not as a public installation guide.
+The repository is proprietary and not publicly clonable; the commands below are the exact
+sequence used to produce the numbers in this post, included for transparency about how the
+numbers were produced, not as an installation guide.
 
 ```bash
 # proprietary repository, shown for reproducibility context only
@@ -225,46 +354,43 @@ cd multicam-reasoning-memory
 python -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
 
-# Run the test suite
-pytest tests/ -q
+# Test suite
+pytest tests/
 
-# Run the synthetic end-to-end demo (ingest + scored linking + sample queries)
+# Synthetic end to end demo (ingest + scored linking + sample queries)
 PYTHONPATH=src python -m fleetmind.cli demo --seed 1
 
-# Ingest a real JSONL event stream and query the resulting memory
-fleetmind ingest --events events.jsonl --memory site.db
-fleetmind query where-is --memory site.db --entity ent_abc123
-fleetmind query journeys --memory site.db --from-camera cam0 --to-camera cam1
+# WILDTRACK evidence, ingest + score (any leg/condition)
+PYTHONPATH=src python -m fleetmind.cli ingest --events evidence/wildtrack/events_refs40.jsonl --memory /tmp/wt.db
+PYTHONPATH=src python -m fleetmind.cli score  --memory /tmp/wt.db --truth evidence/wildtrack/truth.json
 ```
 
-Machine this session's numbers were measured on: macOS, Python 3.12.13, CPU only, fresh
-virtualenv, `numpy` plus stdlib `sqlite3` only, no GPU and no external services running.
-
-## What we have NOT done yet
-
-This is validated on **synthetic** sites with exact ground truth, 24 of them spanning 3 to 8
-cameras. We have written the adapters to score against public multi target multi camera datasets
-(AI City, WILDTRACK); the scoring reduces any such dataset to "person to camera:track" pairs, the
-same reduction our own ground truth already uses, but those benchmark runs are **not yet done**.
-We will publish them when they are, including whatever the uniqueness guard costs in recall on
-real data, which may differ meaningfully from the 0.0476 to 0.6788 range measured across our 24
-site synthetic grid. If it costs more recall on real data, we will say so; the whole point of
-measuring rather than asserting is that we do not get to pick which half of the result we
-publish.
-
-A few more limitations worth stating plainly, drawn directly from the code and its docs:
-
-- Timestamps are assumed clock aligned (NTP) across cameras; there is no per camera clock offset
-  estimation yet.
-- `position_m` is stored as provenance only; the linker does not use spatial position at all,
-  only per camera-pair transit time.
-- No demo assets (images, GIFs, notebooks) exist in the repository itself; the linked HF Space is
-  the closest thing to a visual demo.
-- No model weights ship with this repository, and none are needed; this is an algorithmic
-  engine, not a neural model, so there is nothing to publish to a model hub for this product.
-
-- Dataset: [multicam-reasoning-memory-benchmark](https://huggingface.co/datasets/Dhi-Technologies/multicam-reasoning-memory-benchmark)
+Machine for this session's CPU numbers: macOS, Python 3.12.13, fresh virtualenv, `numpy` plus
+stdlib `sqlite3` only, no GPU. The leg 2 detector and tracker pass ran on a rented RTX 5060 Ti
+(torch 2.12.0+cu130, ultralytics 8.4.90) and is attributed to the committed evidence log and its
+committed tracker outputs.
+
+## What we have NOT done yet, and what the limits are
+
+- **The transit prior path has no real data validation yet.** WILDTRACK's overlapping topology
+  structurally starves it (diagnosed above, zero prior links in all four conditions), so the
+  prior's synthetic grid numbers stand alone until a genuinely non overlapping real dataset,
+  such as an AI City MTMC subset with disjoint coverage, is run. If the uniqueness guard costs
+  more recall there than the 0.0476 to 0.6788 synthetic range suggests, we will publish that.
+- **Timestamps are assumed clock aligned (NTP) across cameras.** There is no per camera clock
+  offset estimation yet; it is the documented v1 non feature and the natural upgrade, since it
+  would tighten transit priors without touching the linking logic. Until then, a site with
+  drifting camera clocks would silently widen or bias the learned priors.
+- **Recall is deliberately partial, and scales with reference coverage.** Concurrent ref less
+  travelers at the same camera pair transit trip the uniqueness guard on purpose. A split costs
+  one duplicate entity row; a wrong merge costs weeks of poisoned history.
+- `position_m` is stored as provenance only; the linker uses per camera pair transit time and
+  nothing spatial.
+- No model weights ship with this product and none are needed; it is an algorithmic engine, so
+  there is nothing to publish to a model hub.
+
+- Dataset (benchmark + per site grid report): [multicam-reasoning-memory-benchmark](https://huggingface.co/datasets/Dhi-Technologies/multicam-reasoning-memory-benchmark)
 - Live demo: [multicam-reasoning-memory-demo](https://huggingface.co/spaces/Dhi-Technologies/multicam-reasoning-memory-demo)
-- Code: proprietary, closed source permanently; not a publicly browsable repository. Partnership
+- Code: proprietary, closed source; the open surface is the evidence quoted above. Partnership
   or access inquiries: [dhi-tech.com](https://dhi-tech.com).
 - Series: [post 1, the thesis](01_ai_that_refuses_to_guess.md), [post 3, A4 calibration](03_a4_calibration_over_accuracy.md), [post 4, portfolio overview](04_portfolio_overview.md), [post 5, Prompt2Model v0.1.0](05_prompt2model_v010.md)

03_a4_calibration_over_accuracy.md

@@ -4,188 +4,256 @@
 
 Counting people through occlusion is the kind of problem where it is easy to publish a good
 looking accuracy number and quietly bury the uncertainty. We want to argue the opposite: for
-occluded counting, **the calibrated interval is the real deliverable, and the point estimate
-is almost a side effect.** This post walks through the method, the numbers, and the failure
-modes we found while building it, in the order we found them, including a real dataset result
-that at first made the method look worse, not better.
+occluded counting, **the calibrated interval is the real deliverable, and the point estimate is
+almost a side effect.** This post walks through the method and its numbers in the order we found
+them, and then tells the story this series exists to tell: what happened when the method met
+real photographs for the first time, failed, was diagnosed, failed again more instructively,
+and finally won, with every intermediate defeat kept in the record. The synthetic results come
+first because they came first chronologically; the real data saga is the second half, and it is
+the longer half on purpose.
 
 ## What this is, and what it is not
 
 `amodal-counting` (package name `amodal`) is a library and CLI, not a hosted model: no detector
-is bundled and no weights ship in the repository. You bring your own box-output detector; this
-library corrects its count. It is not a claim of a universal win, and the evidence below
-includes a real, measured case where the correction did **not** beat naive counting, documented
-in detail rather than hidden. It is not deployed at any customer site, and no customer or
-deployment claim is made anywhere in this post.
+is bundled and no weights ship. You bring your own box output detector; this library corrects
+its count and, more importantly, tells you how much to trust the correction. It is not a claim
+of a universal win: the evidence below includes measured cases where the correction loses to
+naive counting, on synthetic data and on real data, each documented with the conditions under
+which it loses. It is not deployed at any customer site, and no customer or deployment claim
+appears anywhere in this post.
 
 ## The setup
 
 A detector in a crowded scene systematically *undercounts*: it never reports the people it
-cannot see. The textbook fix is Horvitz Thompson estimation: weight each detection by
-1 divided by p(detect given visibility), so a barely visible detection stands in for the
-several similar ones it represents. Visibility itself (`src/amodal/visibility.py`) is computed
-from box geometry alone, the fraction of a detection's box not covered by known occluders, not
-covered by other detections in front of it (bottom edge depth order: lower in frame is closer,
-the standard fixed camera convention), and not truncated by the image border. A missed occluding
-object can only ever make this estimate look *less* occluded than reality, so the bias runs one
-direction, down, which keeps the downstream correction conservative by construction. We fit the
-detectability curve itself from data (a logistic curve with parameters k and v0, refit per
-crowding level), and it carries its own calibrated support: a query outside the 2nd to 98th
-percentile range of visibilities actually seen during fitting is clamped to the boundary and the
-result is flagged `extrapolation_limited`, never silently extrapolated.
-
-The estimator (`src/amodal/estimator.py`) has three honesty gates in the code itself, not just in
-the docs: the corrected estimate can never drop below the raw detection count
+cannot see. The textbook fix is Horvitz Thompson estimation: weight each detection by 1 divided
+by p(detect given visibility), so a barely visible detection stands in for the several similar
+ones it statistically represents. Visibility itself (`src/amodal/visibility.py`) is computed
+from box geometry alone: the fraction of a detection's box not covered by known occluders, not
+covered by other detections in front of it (bottom edge depth order, lower in frame is closer,
+the standard fixed camera convention), and not truncated by the image border. A missed occluder
+can only make this estimate look *less* occluded than reality, so the bias runs one direction,
+down, which keeps the correction conservative by construction. The detectability curve, a
+logistic in visibility with parameters k and v0, is fit from data and refit per crowding level,
+and it carries its own calibrated support: a query outside the 2nd to 98th percentile of
+visibilities seen during fitting is clamped to the boundary and the result is flagged
+`extrapolation_limited`, never silently extrapolated.
+
+The estimator (`src/amodal/estimator.py`) has three honesty gates in the code itself, not just
+in the docs: the corrected estimate can never drop below the raw detection count
 (`estimate = max(estimate, n_detected)`); every per detection weight is capped at `1 / min_p`
-(default `min_p=0.30`, a maximum weight of about 3.3x) so a single deep occlusion detection
+(default `min_p = 0.30`, a maximum weight of about 3.3x) so a single deeply occluded detection
 cannot conjure a crowd on its own; and any detection whose visibility fell outside the curve's
-calibrated support sets `extrapolation_limited=True` on the whole estimate.
-
-## Finding 1: the point estimate helps, but modestly, and not always
-
-On our synthetic benchmark (160 scenes, 40 per crowding level, scored by
-`amodal.cli bench --seed 0`, calibrated on 60 training worlds and evaluated fresh on 40 held out
-worlds per crowding level, so nothing below is computed on data the calibration saw), correction
-lowers mean absolute error at every crowding level tested:
-
-| crowding | naive MAE | corrected MAE | 90% interval coverage (conformal, calibrated) |
-|---:|---:|---:|---:|
-| 0.0 | 2.8 | 2.4 | 0.90 |
-| 0.3 | 2.6 | 1.97 | 0.90 |
-| 0.6 | 2.85 | 2.34 | 0.975 |
-| 0.8 | 3.73 | 2.46 | 0.975 |
-
-We reproduced this table digit for digit this session by re-running the command in a clean
-virtual environment: `PYTHONPATH=.venv/bin/python -m amodal.cli bench --seed 0` against Python
-3.12, dependencies `numpy` and `scipy` only.
-
-But here is the honest part we put in the dataset README, not an appendix: the correction is
-**not** a free lunch. Uncapped Horvitz Thompson weights (`min_p=0.1`, meaning no detection's
-weight is capped below a probability of 0.1) remove the undercount bias in principle, but at
-realistic scene sizes (about 12 objects per scene) the variance from a handful of near zero
-probability detections *swamps* the benefit: per scene MAE actually came out **worse than
-naive**, 2.89 versus 2.63, at crowding 0.6. That is a real regression, measured and kept in
-the record rather than tuned away quietly. A related regression: calibration must be done on
-*inference-aligned* visibility, computed the same way the deployed pipeline computes it, not on
-ground truth visibility. Skipping that step was measured to turn a helpful correction into a
-harmful one: MAE 3.13 versus a naive 2.63 at one crowding level.
-
-The `min_p` weight cap knob exists specifically because we measured that failure and had to
-tune against it. Sweeping the cap at crowding 0.6:
+calibrated support sets `extrapolation_limited = True` on the whole estimate. Hold on to that
+first gate, the never below raw count floor. It encodes an assumption, "detections are real,
+errors are only misses," and the real data section below is largely the story of that assumption
+meeting a detector for which it is false.
+
+## The synthetic results: where the method works, and where it already loses
+
+On our synthetic benchmark (160 scenes, 40 per crowding level, calibrated on 60 training worlds
+and evaluated fresh on 40 held out worlds per level, so nothing below is computed on data the
+calibration saw), correction lowers mean absolute error at every crowding level tested. We
+re ran this table digit for digit this session with `bench --seed 0` in a clean virtualenv
+(Python 3.12, `numpy` and `scipy` only):
+
+| crowding | naive MAE | corrected MAE | 90% interval coverage (conformal) | z multiplier |
+|---:|---:|---:|---:|---:|
+| 0.0 | 2.8 | 2.4 | 0.90 | 6.726 |
+| 0.3 | 2.6 | 1.97 | 0.90 | 8.2022 |
+| 0.6 | 2.85 | 2.34 | 0.975 | 14.4634 |
+| 0.8 | 3.73 | 2.46 | 0.975 | 7.7541 |
+
+The last column is the honest headline of the method, and it needs its own paragraph. The
+textbook analytic error bar, the independent Bernoulli Horvitz Thompson variance formula you
+would derive on a whiteboard, measured **0.50 to 0.63 actual coverage against a claimed 0.90**
+on this benchmark. Shipped as is, it would tell operators "90% sure" while being right barely
+half the time, which is arguably worse than no interval at all, because it converts a guess into
+a false guarantee. We do not hand tune the formula. We calibrate it conformally
+(`fit_interval_scale`, a standard split conformal procedure: run inference over labeled
+calibration scenes, collect the ratios of actual absolute error to claimed sigma, take their
+finite sample quantile as a multiplier `z_scale` on the analytic sigma). The fitted multipliers
+in the table run from **6.726 to 14.4634**: the uncalibrated error bar was roughly an order of
+magnitude too tight, and publishing the multiplier is publishing exactly how wrong the
+overconfident version would have been. After calibration, measured coverage meets or exceeds the
+90% claim at every crowding level. An estimate only reports a calibrated coverage claim if its
+curve actually carries a fitted `z_scale`; otherwise the CLI marks `interval_calibrated: false`
+rather than implying a guarantee that was never measured.
+
+Even on synthetic data, the point estimate correction is not a free lunch, and two measured
+regressions are kept in the record. First, uncapped weights: with `min_p = 0.1`, the variance
+from a handful of near zero probability detections swamps the bias reduction, and per scene MAE
+came out **worse than naive**, 2.89 versus 2.63, at crowding 0.6. Sweeping the cap at that
+crowding level made the tradeoff explicit:
 
 | min_p | 0.1 | 0.2 | 0.3 | 0.4 |
 |---|---:|---:|---:|---:|
 | MAE | 2.89 | 2.21 | 1.71 | 1.52 |
 
-Raising the floor on how much weight any single detection can carry monotonically improved
-MAE across this sweep, at the cost of reintroducing some of the undercount bias the weighting
-was meant to remove; the value we ship is chosen from this measured tradeoff, not from taste.
-When a detector's recall collapses on a truly dense crowd, no reweighting saves you: you are
-extrapolating from detections that are not there, and the honest response is a wider interval,
-not a more aggressive point estimate.
-
-## Finding 2: the interval is where the real value, and the real danger, lives
-
-The reason to care about the interval more than the point estimate: the naive analytic error
-bar is a **lie of overconfidence**. The textbook independent Bernoulli Horvitz Thompson
-variance formula measured **0.50 to 0.63 actual coverage against a claimed 0.90** on our
-benchmark. If you shipped that formula as is, you would be telling operators "90% sure" while
-being right barely half the time, which is arguably worse than reporting no interval at all,
-because it actively misleads.
-
-We do not hand tune the formula to fix this. We calibrate it conformally
-(`fit_interval_scale`, a standard split conformal procedure that runs inference over labeled
-calibration scenes, collects `|error| / sigma_raw` scores, and takes their finite sample
-quantile as a multiplier, `z_scale`, on the analytic sigma), and that multiplier lands in the
-**6.7x to 14.5x** range depending on crowding density. That number is the honest headline of the
-whole method: **the uncalibrated error bar was roughly an order of magnitude too tight.** After
-calibration, coverage meets or exceeds its 90% claim at every crowding level tested (0.90 at
-crowding 0.0 and 0.3, 0.975 at crowding 0.6 and 0.8), and never falls below its claim in this
-benchmark. An estimate only reports a calibrated coverage claim if its curve actually carries a
-fitted `z_scale`; otherwise the CLI marks `interval_calibrated: false` rather than implying a
-guarantee that was never measured.
+The shipped default is chosen from that measured sweep, not from taste. Second, calibration must
+be done on *inference aligned* visibility, computed exactly the way the deployed pipeline
+computes it, not on ground truth visibility; skipping that step was measured to turn a helpful
+correction into a harmful one (MAE 3.13 versus a naive 2.63 at one crowding level). Both
+regressions stayed in the benchmark documentation, because a method whose failure modes you have
+not published is a method whose failure modes you have not finished finding.
+
+## The real data saga: four acts on CrowdHuman
+
+Everything above has exact synthetic ground truth. The repository's evidence log,
+`evidence/a4_realdata/RESULTS.md`, documents what happened when the method was pointed at real
+photographs, in four chronological stages, each committed on 2026-07-09 with its own numbers.
+The setup, fixed across all four acts: CrowdHuman validation images, 270 of them split into 80
+calibration, 40 interval calibration, and 150 evaluation images (disjoint, seed 42), containing
+6,809 ground truth person boxes; a SAHI tiled YOLOv8s detector (640x640 tiles, 20% overlap),
+person class only, run on a rented RTX 5060 Ti. We attribute these numbers to that evidence log
+and its committed per scene outputs rather than re running them for this post, because
+reproducing them needs a GPU, `ultralytics` and `sahi`, and the CrowdHuman images; everything
+synthetic in this post we re ran ourselves.
+
+**Act 1: the fair re test, and a clean failure.** After fixing the detector configuration
+itself (the first, naive full image detector pass had 16% recall, useless for testing a
+correction; SAHI tiling brought recall to 56.25% at IoU 0.5), the one directional correction
+got its first fair test. It failed: naive MAE 14.08, corrected MAE **28.204**, interval coverage
+**0.3933** against the 90% target. The fitted detectability curve told the story of why: it came
+out nearly flat, k = 0.2925, v0 = 0.0603, with p(detect given visibility) spanning only 0.50 to
+0.57 across the whole visibility range. On this detector, geometric visibility barely predicts
+misses. And the error structure was the deeper problem: decomposing naive error across the 150
+evaluation scenes showed 85 scenes *overcounted* (total +1,045) against 55 undercounted (total
+-1,067), a nearly balanced two sided mix, with mean signed error -0.15. Naive counting was
+already nearly unbiased on average. A one directional correction, whose weights are always at
+least 1 and whose floor forbids ever going below the raw count, can only push counts up; applied
+to an already balanced error, its almost constant 1.8 to 2x multiplier turned a mean signed
+error of -0.15 into +21.05. The floor that was an honesty gate on synthetic data, where all
+error is misses, became the mechanism of failure on real data, where half the error is spurious
+detections. The overcount half of the problem traced to SAHI itself: sliding window tiling
+produces duplicate and partial boxes along tile seams that survive fusion.
+
+**Act 2: a richer curve, an unchanged failure, and the diagnosis confirmed.** The obvious
+objection to act 1 is "your visibility feature is just weak; fit a better detectability model."
+So that is what happened next: a multivariate logistic detectability curve over visibility,
+scene relative log scale, local density, and normalized image position, fit on 2,174 calibration
+pairs (1,181 detected, 993 missed). The fit itself confirmed the diagnosis quantitatively: point
+biserial correlations with detection were 0.458 for log scale and 0.433 for vertical position,
+against **0.051 for visibility**. On this detector, size and position predict detection; the
+occlusion geometry the whole method was built around barely does. And the result got *worse*,
+not better: corrected MAE **34.039** (against the same naive 14.08), coverage 0.4067. The
+evidence log's root cause analysis explains why more information can hurt: the correlation
+between a scene's naive error and its mean predicted detectability came out at -0.37, meaning
+the scenes with the most false positives are exactly the scenes where the curve predicts the
+lowest detectability and therefore applies the largest upward multiplier. The failure was
+structural, one directional weights against two sided error, not a fixable weakness in the
+curve. That is worth pausing on, because it is the shape of a lot of real regressions: the first
+fix attempt targets the visible symptom (a weak feature) and instead sharpens the underlying
+mismatch.
+
+**Act 3: fix the detector, watch the correction still lose.** If tiling artifacts cause the
+overcount half, tune the tiling. A 25 configuration sweep over SAHI's postprocessing (algorithm,
+match metric, match threshold, confidence threshold, overlap) found a setting, GREEDYNMM with
+IoU matching at threshold 0.3 and confidence 0.15, that improved recall and precision
+*simultaneously*: recall 56.25% to 61.89%, precision 57.53% to 61.82%, false positives 2,827
+down to 2,603 even as total detections rose. That was the single biggest win in the whole
+evidence trail for the *point estimate*: naive MAE dropped from 14.08 to **11.767**, a 16.4%
+relative improvement, before any correction at all. Rebuilt on the better detector, the
+corrected estimators improved too (one directional: 22.475; multivariate: 28.228) but **still
+lost to naive**, and the error decomposition explained why with the same shape as before: 87
+scenes overcounted (+922) against 51 undercounted (-843). Cleaning up the detector reduced the
+problem's size, not its two sided shape. Act 3's lesson is the cheapest in the saga: before
+correcting a detector statistically, spend a day tuning the detector, because the best
+correction of a bad configuration lost to the uncorrected output of a good one.
+
+**Act 4: make the estimator two sided, and finally win.** The structural diagnosis dictated the
+fix: if detections can be spurious, the estimator needs a model of *that*, not just of misses.
+Act 4 adds a second fitted model, `p_true`, the probability that a detection is a real object
+rather than a duplicate or tiling artifact, fit on 2,196 calibration split detections (1,321
+matched to ground truth, 875 not) over four features that need no ground truth at inference
+time: the detector's own confidence, scene relative log scale, local detection density, and
+proximity to the nearest SAHI tile seam. The fitted coefficients (standardized) came out
+confidence 0.326, log scale 0.687, density -0.181, seam proximity -0.287, every sign in the
+direction it should be, with a held out Brier score of about 0.10. Interestingly, scale, not
+confidence, carried the largest weight; the evidence log flags that rather than tidying it into
+the expected story. Each detection's weight becomes `p_true / max(p_detect, min_p_detect)`
+instead of `1 / p_detect`, and the never below raw count floor is **deliberately dropped**,
+documented in the estimator as an intentional, narrow relaxation: once a detection can itself be
+spurious, forbidding the estimate to go below the raw count would forbid the correction from
+correcting. The one free parameter, `min_p_detect`, was selected by sweeping 0.05 to 0.95 on the
+40 image interval split only, never touching evaluation data; the minimum sat at 0.70 in a broad
+basin, where the interval split already showed the estimator beating naive (11.807 versus
+12.025). Applied once to the held out 150 scene evaluation split:
+
+| estimator | MAE | 90% interval coverage |
+|---|---:|---:|
+| naive count | 11.767 | n/a |
+| one directional (act 3 detector) | 22.475 | ~0.39 |
+| **two sided (p_true / p_detect)** | **11.031** | **0.9067** |
+
+A 6.3% relative MAE improvement over naive, and, for the first time on real data, an interval
+that means what it says: 90.67% measured coverage against a 90% claim. On the pre specified
+occlusion heavy subset (the top 30% of scenes by CrowdHuman's own per box occlusion flags, 45
+scenes with mean ground truth occlusion fraction 0.877), the two sided estimator also wins,
+17.222 versus 18.867 naive, which is exactly the regime where act 3's one directional variant
+had been losing by 1.7 to 2.2x.
+
+**The boundary that remains, disclosed.** On the 20 densest scenes in the evaluation split, up
+to 227 true people represented by as few as 20 to 30 raw detections, naive counting is still
+better: naive MAE 40.0 versus two sided 46.171, and the estimator's own coverage flag drops to
+0.50, correctly signaling extrapolation far outside the calibration density range instead of
+failing silently. Up weighting genuine but sparse detections is inherently unstable when the
+detector has collapsed; the honest response is the wider flagged interval the estimator already
+produces, and the honest scope statement is the one the evidence log makes: the product's valid
+regime is moderate density scenes with a reasonably configured detector, and dense crowd
+counting beyond detector collapse belongs to density map methods, not detection reweighting.
+
+Four acts, one pattern: every failure was measured, diagnosed to a mechanism, and published
+before the next attempt, and the fix that finally worked was dictated by the diagnosis rather
+than by trying harder with the same assumption. The two sided estimator exists *because* acts 1
+through 3 are in the record; a lab that buried act 1 would still be tuning curve features.
 
-```
-crowding 0.0: analytic coverage ~0.50-0.63  ->  conformal multiplier applied  ->  0.90
-crowding 0.3: analytic coverage ~0.50-0.63  ->  conformal multiplier applied  ->  0.90
-crowding 0.6: analytic coverage ~0.50-0.63  ->  conformal multiplier applied  ->  0.975
-crowding 0.8: analytic coverage ~0.50-0.63  ->  conformal multiplier applied  ->  0.975
-```
+## A fifth mechanism: occlusion persistence over time
 
-## Finding 3: what happened when we actually ran this on real photographs
-
-Everything above is synthetic. The repository's own evidence log,
-`evidence/a4_realdata/RESULTS.md`, documents a multi stage external re-test on CrowdHuman
-validation data: a SAHI tiled YOLOv8s detector, person class, 270 images, 6,809 ground truth
-boxes, run on external GPU hardware. We are attributing these numbers to that evidence file, not
-independently re-running them in this post, because reproducing them needs a GPU,
-`ultralytics`/`sahi`, and the CrowdHuman dataset, none of which this drafting pass had access to.
-
-The honest headline: **the one directional correction did not beat naive counting on real
-data.** Naive MAE was 11.767; the corrected estimate came in worse, at 22.475 for the single
-feature detectability curve and 28.228 for the multivariate variant, with interval coverage
-collapsing to about 39 to 41% against the 90% target, the opposite of the synthetic result above.
-The evidence trail's own diagnosis: the geometric visibility signal alone was a weak predictor of
-real misses on this detector (the fitted detectability curve came out nearly flat), because this
-detector's real error was a comparable *two sided* mix of genuine occlusion undercount and
-tiling driven overcount (an artifact of SAHI's sliding-window tiling), which a one directional,
-weight only correction cannot fix by construction, no matter how well calibrated.
-
-The fix that did work adds a second fitted model, `p_true` (the probability a detection is a real
-object rather than a duplicate or tiling artifact, from confidence, scale, local density, and
-tile seam proximity), and reweights each detection by `p_true / p_detect` instead of `1 / p_detect`
-alone. That two sided estimator is the first variant in the evidence trail to beat naive on this
-real dataset: MAE improved from 11.767 to 11.031, and coverage reached 90.67% against the 90%
-target. It comes at a deliberate cost: the two sided estimator drops the never-below-raw-count
-honesty floor by design, documented as an intentional, narrow relaxation once a detection can
-itself be spurious rather than merely hidden. And even this improved variant is disclosed as
-incomplete on the hardest cases: on the 20 single densest scenes in the same evidence log (up to
-227 true people counted from as few as 20 to 30 raw detections), naive counting remains better,
-and the estimator's own coverage flag correctly drops to 50%, signaling extrapolation rather than
-silently failing. We are publishing the regression alongside the fix, and the fix's own remaining
-weak spot, because that is the entire point of measuring instead of asserting.
+Beyond the per frame estimator, `src/amodal/temporal.py`'s `PersistentCounter` treats a tracked
+object that vanishes mid frame, away from any exit region, as probably occluded rather than
+gone, with a survival probability that decays over hidden time. The decay half life is fit from
+observed reappearance gap statistics (`fit_halflife`, a maximum likelihood exponential fit: half
+life equals mean gap times ln 2), not hand picked, and a track last seen near the image border
+is credited as departed rather than occluded, so the persistence model does not fight the
+geometry model's border truncation logic.
 
 ## Test suite
 
 `tests/test_core.py` (37 test functions) and `tests/test_temporal_bench_cli.py` (9 test
-functions), 46 test functions total, counted directly with `grep -c "^def test_"`. Command run
-this session: `PYTHONPATH=src python -m pytest tests/ -q`. Verbatim final line:
+functions), 46 total, counted with `grep -c "^def test_"`. Re run this session,
+`PYTHONPATH=src python -m pytest tests/`; verbatim final line:
 
 ```
-46 passed in 12.76s
+46 passed in 2.22s
 ```
 
-## A fifth mechanism: occlusion persistence over time
-
-Beyond the per-frame estimator, `src/amodal/temporal.py`'s `PersistentCounter` treats a tracked
-object that vanishes mid frame, away from any exit region, as probably occluded rather than gone,
-with a survival probability that decays over hidden time. The decay half life is fit from
-observed reappearance gap statistics (`fit_halflife`, a maximum likelihood exponential fit:
-half life = mean times ln 2), not hand picked, and a track last seen near the image border is
-credited as departed, not occluded, so the persistence model does not fight the geometry model's
-own border truncation logic.
+(An earlier revision of this post quoted `46 passed in 12.76s` from a previous session's run on
+the same suite; the count is what is load bearing, the wall time varies with the machine.)
 
 ## What we have NOT done yet, and will not pretend we have
 
-Beyond the CrowdHuman re-test above (a real but partial and externally run result), the rest of
-this method is validated on **synthetic** scenes with exact ground truth. We have written the
-protocol to adapt further real crowd datasets (ShanghaiTech and JHU CROWD++), including the
-awkward part, deriving ground truth *boxes* from point annotations, but that evaluation has not
-been run yet. When it is, we expect the interesting result to be about *coverage*, not accuracy:
-whether the calibrated 90% interval still covers on a different real dataset, and by how much the
-point estimate advantage shrinks when a real detector's recall falls apart in dense scenes. We
-will publish that honestly, including the unflattering half, the same way we published the
-uncapped weight regression and the CrowdHuman regression above instead of hiding either one. This
-is also still a research stage engine: a GPU phase learned amodal completion model, intended as a
-stronger visibility and detectability source behind the same interfaces, is not yet implemented.
-
-The takeaway is not "we count crowds better." It is: **we tell you how much to trust the
-count, we have measured how wrong the naive confidence would have been, and when a first version
-of the fix made real-world counting worse, we said so and kept working instead of quietly
-retracting the claim.**
+- The CrowdHuman result is one real dataset, one detector family, one tiling configuration. The
+  protocol for adapting further real crowd datasets (ShanghaiTech, JHU CROWD++) is written,
+  including the awkward part, deriving ground truth boxes from point annotations, but those runs
+  have not happened. The interesting question there is coverage, not accuracy: whether the
+  calibrated interval still holds its claim on a dataset it was not developed against.
+- The two sided estimator's `p_true` model includes a SAHI specific feature (tile seam
+  proximity). On a detector that does not tile, that feature is inert and the model would lean
+  on confidence, scale, and density alone; that configuration has not been separately measured.
+- The dense scene boundary above is real and currently unsolved in this product: past detector
+  collapse, reweighting loses to naive counting, and the estimator's contribution is to *flag*
+  that regime (coverage 0.50, extrapolation limited) rather than fix it.
+- A GPU phase learned amodal completion model, intended as a stronger visibility and
+  detectability source behind the same interfaces, is not implemented. This remains a research
+  stage engine.
+
+The takeaway is not "we count crowds better." It is: **we tell you how much to trust the count,
+we measured how wrong the naive confidence would have been (6.7x to 14.5x too tight), and when
+the first real world test made the correction worse, we published the regression, diagnosed it
+to a mechanism, and kept the diagnosis in the record next to the fix it eventually produced.**
 
 - Dataset: [amodal-counting-benchmark](https://huggingface.co/datasets/Dhi-Technologies/amodal-counting-benchmark)
 - Live demo: [amodal-counting-demo](https://huggingface.co/spaces/Dhi-Technologies/amodal-counting-demo)
-- Code: proprietary, closed source permanently; not a publicly browsable repository. Partnership
+- Code: proprietary, closed source; the open surface is the evidence quoted above. Partnership
   or access inquiries: [dhi-tech.com](https://dhi-tech.com).
 - Series: [post 1, the thesis](01_ai_that_refuses_to_guess.md), [post 2, E1 precision first linking](02_e1_precision_first_linking.md), [post 4, portfolio overview](04_portfolio_overview.md), [post 5, Prompt2Model v0.1.0](05_prompt2model_v010.md)

04_portfolio_overview.md

@@ -2,44 +2,52 @@
 
 *Dhi Labs, post 4 of 5: a portfolio overview*
 
-The first three posts in this series made a specific argument about two of our six products:
-that a refusal gate and a calibrated interval are not decoration, they are the actual product,
-verified with numbers rather than asserted with adjectives. This post is the wide angle
-version: a tour of all six Dhi Labs products, each tied back to that same thesis, each with
-its honesty mechanism named, its one clearest measured number attached, and its test suite
-counted rather than assumed. Read it as an index into the rest of the org: every product below
-links to its dataset, its demo Space, and where one exists, its deep dive post. Post 5 covers a
-seventh piece of the program that just crossed from private research into a public, tagged
-release.
-
-Across the six products below, the combined test suite this org's own code carries is 34 (E1) +
-46 (A4) + 27 (A3) + 16 (E4) + 99 (A5) + 117 (B1, at v0.1.0) = 339 tests, each one run and its
-final summary line quoted rather than paraphrased, in the sections below and in the deep dive
-posts. None of that is a claim that 339 passing tests makes a product production ready; it is a
-claim that the honesty mechanisms described below are exercised by code that runs, not only
-described in prose.
+The first three posts in this series made a specific argument about two of our products: that a
+refusal gate and a calibrated interval are not decoration, they are the actual product, verified
+with numbers rather than asserted with adjectives. This post is the wide angle version: a tour
+of all six Dhi Labs products, each tied back to that thesis, each with its honesty mechanism
+named, its clearest measured numbers attached, its stated limitation kept in the same paragraph
+as its headline, and its test suite counted rather than assumed. It closes with the part the
+individual posts cannot show: how the pieces are designed to compose on a single edge box. Read
+it as an index into the rest of the org: every product links to its dataset and demo Space, and
+where one exists, its deep dive post.
+
+Across the six products, the combined test count is 34 (E1) + 46 (A4) + 27 (A3) + 16 (E4) + 99
+(A5) + 118 (B1, current main) = 340 tests; B1's tagged v0.1.0 release carried 117, and current
+main gained one test with the training determinism fix covered in post 5, so the portfolio
+total moved from the previously published 339 to 340. Each suite's final summary line is quoted
+verbatim in its product's section or deep dive rather than paraphrased. None of this is a claim
+that 340 passing tests make a product production ready; it is a claim that every honesty
+mechanism described below is exercised by code that runs, not only described in prose.
 
 ## A4: amodal counting
 
-**One liner:** counts people and objects through occlusion, reporting a calibrated interval
-instead of a bare point count.
-
-**Honesty mechanism:** conformal calibration of the uncertainty interval, checked against
-measured coverage rather than assumed. The textbook analytic error bar undercovers badly
-(about 0.50 to 0.63 actual coverage against a claimed 0.90); the conformally calibrated
-version meets or exceeds its 90% claim at every crowding level tested, at the cost of being
-6.7x to 14.5x wider than the naive bar. On a real, externally run CrowdHuman re-test, the first
-version of the correction made counting *worse* than naive (MAE 11.767 to 22.475) before a
-two-sided estimator fixed it (MAE 11.031, 90.67% coverage) - both numbers are published, not
-just the second one.
-
-**One verified number:** corrected count MAE of 2.46 versus naive MAE of 3.73 at the hardest
-occlusion density tested (crowding 0.8), with 97.5% measured interval coverage against a
-90% claim; 46 tests passed in 12.76s on the synthetic suite.
-
-**Under the hood:** 9 source files, 1,662 lines (`geometry.py`, `synth.py`, `visibility.py`,
-`calibrate.py`, `estimator.py`, `temporal.py`, `bench.py`, `cli.py`), no third party dependency
-beyond `numpy` and `scipy`, no GPU anywhere in the synthetic path.
+Counting through occlusion is a problem where the point estimate gets the attention and the
+uncertainty does the damage, so this product treats the calibrated interval as the deliverable.
+A detector undercounts what it cannot see; the estimator reweights each detection by a fitted
+detectability curve, caps every weight so one deep occlusion cannot conjure a crowd, and clamps
+queries outside the curve's calibrated support with an explicit `extrapolation_limited` flag.
+The honesty mechanism is conformal calibration of the interval, checked against measured
+coverage: the textbook analytic error bar measured 0.50 to 0.63 actual coverage against a
+claimed 0.90 on the synthetic benchmark, and the conformal multiplier that repairs it, 6.7x to
+14.5x wider depending on crowding, is published as the headline rather than hidden as an
+implementation detail. On synthetic scenes the corrected count also beats naive at every
+crowding level tested (2.46 versus 3.73 MAE at the hardest level, with 0.975 measured coverage
+against a 0.90 claim, re run digit for digit this session).
+
+The real data arc is the flagship honesty story of the whole program, told in full in post 3.
+Short version: on CrowdHuman with a SAHI tiled YOLOv8s detector (270 images, 6,809 ground truth
+boxes), the one directional correction *lost* to naive counting, 22.475 versus 11.767 MAE,
+because this detector's real error was a two sided mix of occlusion misses and tiling driven
+false positives that a weights only correction cannot fix by construction. The fix, a two sided
+estimator that also fits a per detection probability of being a genuine object, is the first
+variant to beat naive on real data, 11.031 MAE with 90.67% interval coverage against the 90%
+target. The stated limitation stays next to the win: on the twenty densest scenes (up to 227
+people seen as 20 to 30 raw boxes), naive still wins and the estimator's own coverage flag drops
+to 0.50, correctly signaling extrapolation; dense crowds past detector collapse are outside this
+product's valid regime, and it says so at runtime. Suite: `46 passed in 2.22s`, re run this
+session. Under the hood: 9 source files, 1,662 lines, `numpy` and `scipy` only, no GPU anywhere
+in the synthetic path.
 
 - Dataset: [amodal-counting-benchmark](https://huggingface.co/datasets/Dhi-Technologies/amodal-counting-benchmark)
 - Demo: [amodal-counting-demo](https://huggingface.co/spaces/Dhi-Technologies/amodal-counting-demo)
@@ -47,25 +55,32 @@ beyond `numpy` and `scipy`, no GPU anywhere in the synthetic path.
 
 ## E1: multicam reasoning memory
 
-**One liner:** links the same person or vehicle across cameras and answers where, when, and
-who was there questions, with a provenance trail on every answer.
-
-**Honesty mechanism:** a uniqueness guard refusal gate. A margin only linker measured 0.918
-site precision; adding a gate that refuses to link whenever a second candidate is even
-plausible took precision to 1.0, deliberately trading recall down to buy zero wrong merges,
-because a false merge poisons weeks of memory while a missed link only costs a duplicate row.
-
-**One verified number:** precision **1.0000** across a 24 site synthetic grid (165,902 events, 3
-to 8 cameras, 20% to 60% reference coverage), zero false merges on any site; recall scales with
-reference coverage and camera count from 0.0476 to 0.6788 by design. On the single committed seed
-1 demo: precision 1.0, recall 0.377 (69 true same person pairs, 26 linked, 0 wrong); the entire
-four camera site's memory fits in 61,440 bytes, and a month long simulated stream stays under 2 MB
-by construction, enforced by a regression test, not just documented; 34 tests pass in 4.74s.
-
-**Under the hood:** 9 files, 1,290 lines, stdlib `sqlite3` plus `numpy` only, and a shipped
-`integrations/frigate.py` bridge (330 lines) that maps the open source Frigate NVR's own MQTT
-event stream into the engine's input contract, so a real, already-deployed tracker can feed it
-without a bespoke adapter.
+The linking engine answers where, when, and who was there questions across a camera network,
+and its founding asymmetry is that a false merge poisons weeks of memory while a missed link
+costs one duplicate row. The honesty mechanism is a uniqueness guard refusal gate: a margin only
+linker measured 0.918 site precision because peaky Gaussian transit scores produce confident
+margins for wrong winners; the guard refuses any link where a second candidate is even
+plausible, and took precision to 1.0. The evidence is no longer one seed: across a 24 site
+synthetic grid (3 to 8 cameras, 20 to 100 people, 165,902 events), precision is exactly 1.0000
+on every site while recall spans 0.0476 to 0.6788, scaling with identity reference coverage
+(mean 0.2008 at 20% up to 0.6044 at 60%), the published price of the precision.
+
+It is also the first product in the portfolio with a completed real data campaign, run two
+ways on WILDTRACK's seven overlapping cameras: a ground truth replay and a real YOLO11n plus
+ByteTrack pipeline whose stream included 380 unmatched false positive tracks as live
+distractors. Zero wrong merges in every condition (precision 1.0 across 1,663 replay tracks
+and 1,373 real tracker tracks; recall 0.4087 and 0.3502 at 40% reference coverage), and the
+honest negative published with it: with no references at all, recall is exactly 0.0 on this
+dataset, because WILDTRACK's overlapping topology structurally starves the transit prior
+mechanism, which contributed zero links in all four conditions. That zero is the operating
+envelope stated plainly: the prior path needs non overlapping cameras and reference coverage to
+learn from, and its real data validation is still open until a disjoint topology dataset is
+run. Memory stays bounded by construction, one episode row per contiguous presence rather than
+one row per event: the seed 1 site fits in 61,440 bytes and a simulated month of per second
+presence (36,000 events) stays under 2 MB, asserted by a regression test re run this session.
+Suite: `34 passed in 4.33s`. Under the hood: 9 files, 1,290 lines, stdlib `sqlite3` plus
+`numpy`, and a 330 line Frigate NVR bridge that maps its MQTT events into the input contract
+with a 0.5 confidence gate before trusting any recognized plate or face as an identity.
 
 - Dataset: [multicam-reasoning-memory-benchmark](https://huggingface.co/datasets/Dhi-Technologies/multicam-reasoning-memory-benchmark)
 - Demo: [multicam-reasoning-memory-demo](https://huggingface.co/spaces/Dhi-Technologies/multicam-reasoning-memory-demo)
@@ -73,150 +88,172 @@ without a bespoke adapter.
 
 ## A3: fixed camera 3D
 
-**One liner:** turns an ordinary fixed camera into a metric 3D sensor, self calibrating
-height, tilt, and focal length from people already walking through the scene, no GPU and no
-model weights involved.
-
-**Honesty mechanism:** the hard case is disclosed, not dropped from the table, and it is caught
-by a real conditioning probe in the code, not a post hoc caveat. `sensitivity_m_per_half_deg`
-perturbs the recovered camera tilt by half a degree and measures how far the estimated ground
-position moves in response, because a shallow mount camera can converge to a low optimizer
-residual while the recovered tilt is still off by a few degrees, and at that geometry a few
-degrees of tilt error becomes meters of far field position error that the residual alone cannot
-see. The shallow angle configuration (3 meter camera height, 20 degree tilt) is flagged by this
-probe as reporting 1.72 meters of position movement per half degree of tilt perturbation,
-against 0.72 and 0.20 meters at two well conditioned geometries, and it is reported in the same
-results table as the easy cases rather than excluded as an outlier.
-
-**One verified number:** position RMSE of 0.16 meters at 5 meters height and 30 degree tilt,
-versus 4.30 meters at the disclosed hard case of 3 meters height and 20 degree tilt, both
-measured on the same self calibration and localization pipeline with no configuration specific
-tuning; 27 tests pass in 20.20s (the repo's own docs claim 29, a discrepancy caught and
-disclosed rather than silently repeated).
-
-**Under the hood:** 916 lines across 7 files (`camera.py`, `calibration.py`, `metric.py`,
-`depth_fusion.py`, `bench.py`, `cli.py`), `numpy` and `scipy` only. A depth-fusion path
-(`fit_depth_scale`, Theil-Sen median-of-slopes anchor fitting) takes any relative-depth model as
-a plain callable, so the fusion math is fully unit-tested today with no model plugged in;
-concrete depth-model adapters and an edge TensorRT path are explicit future work, not shipped.
+This product turns an ordinary fixed camera into a metric 3D sensor by self calibrating height,
+tilt, and focal length from people already walking through the scene, no GPU and no model
+weights involved. The honesty mechanism is disclosure backed by a real conditioning probe in the
+code rather than a post hoc caveat: `sensitivity_m_per_half_deg` perturbs the recovered tilt by
+half a degree and measures how far the estimated ground position moves in response. The reason
+it exists is a genuinely nasty failure mode of shallow camera geometry: a shallow mounted camera
+can converge to a low optimizer residual while its recovered tilt is still off by a few degrees,
+an error the residual cannot see but which becomes meters of far field position error. The
+shallow configuration (3 m height, 20 degree tilt) is flagged by the probe at 1.72 meters of
+position movement per half degree of tilt perturbation, against 0.72 and 0.20 meters at two well
+conditioned geometries, and it reports 4.30 meters position RMSE against 0.16 meters at the good
+geometry (5 m height, 30 degree tilt), in the same results table, with no configuration specific
+tuning between them. The hard case is a row, not a footnote.
+
+Suite: 27 tests pass (in 20.20s on the recorded run); the repo's own docs once claimed 29, a
+discrepancy caught and disclosed rather than silently repeated. Under the hood: 916 lines across
+7 files, `numpy` and `scipy` only. A depth fusion path (Theil-Sen median of slopes anchor
+fitting) takes any relative depth model as a plain callable, so the fusion math is fully unit
+tested today with no model plugged in; concrete depth model adapters and an edge TensorRT path
+are explicit future work, not shipped, and the product says so instead of listing them as
+features.
 
 - Dataset: [fixed-camera-3d-benchmark](https://huggingface.co/datasets/Dhi-Technologies/fixed-camera-3d-benchmark)
 - Demo: [fixed-camera-3d-demo](https://huggingface.co/spaces/Dhi-Technologies/fixed-camera-3d-demo)
 
 ## E4: causal predictive alerting
 
-**One liner:** predicts an incident a few seconds before it happens from kinematic
-trajectories, and proves why with a counterfactual replay, rather than shipping a bare anomaly
-score.
-
-**Honesty mechanism:** a falsification ledger plus an ablation-replay counterfactual engine.
-Every prediction is later graded fulfilled or falsified against what actually happened, and the
-falsified count is published as prominently as the fulfilled count. Every "why" is not narration
-but a literal re-run of the same predictor with a candidate cause removed or motion-frozen, so a
-causal claim is either true of an executed replay or it is not made at all.
-
-**One verified number:** across an earlier 200 scenario battery, 63 predictions were later
-graded fulfilled and 87 falsified, out of 150 alerts fired; recall is 1.0 across every scenario
-kind in the newer 210 scenario battery, at a disclosed cost of an 8.0% false positive rate on
-negative scenarios, and the weakest alert kind, crowd buildup, is named as the weakest (0.356
-precision) rather than folded into a friendlier overall average; 16 tests pass in 1.97s.
-
-**Under the hood:** 1,146 lines across 7 modules (`state.py`, `predict.py`,
-`counterfactual.py`, `grounding.py`, `battery.py`, `cli.py`), `numpy` only, no torch, no GPU, no
-network calls anywhere in `src/`. The counterfactual engine's own necessity rate is a second
-honest signal beyond precision and recall: presence removal was necessary for 100% of zone
-entry and convergence alerts but only 21.7% of crowd buildup alerts (267 per-occupant checks
-run), correctly reporting that a crowd well above threshold does not depend on any one occupant
-instead of inflating per-person blame to sound more decisive.
+The predictor claims incidents seconds before they happen from kinematic trajectories, which is
+exactly the kind of claim that is cheap to make and expensive to check, so the product's core is
+the checking machinery. Its falsification ledger files every alert at fire time with a deadline
+derived from the alert's own claimed lead time, then grades it fulfilled (with the measured, not
+predicted, lead time) or falsified, with no third verdict. Over an earlier 200 scenario battery:
+150 alerts fired, 63 fulfilled, 87 falsified, 50 scenarios with no alert, arithmetic that
+reconciles and is published with the falsified count first. The newer 210 scenario battery
+reports per kind rather than averaging: recall 1.0 on every kind, precision 0.667 (zone entry),
+0.657 (convergence), 0.500 (multi party convergence with decoy tracks), and 0.356 (crowd
+buildup), with crowd buildup named as the weakest kind, plus a disclosed 8.0% false positive
+rate on the 75 negative scenarios concentrated in two named edge cases (stationary loiterers at
+20%, incidents just outside the horizon at 13.3%), both root caused to noisy short window
+velocity estimates crossing the minimum speed gate.
+
+Every alert also ships a counterfactual from an ablation replay engine: the same predictor
+re run on the same observation history with a candidate cause removed or motion frozen, so a
+causal claim corresponds to an executed, rerunnable run rather than narration. The engine's
+necessity statistics are themselves honest: presence removal was necessary for 100% of zone
+entry and convergence alerts but only 21.7% of crowd buildup alerts across 267 per occupant
+checks, which is the correct answer for a crowd well above threshold, reported instead of
+inflated. Suite: `16 passed in 1.97s` on the recorded run. Under the hood: 1,146 lines across 7
+modules, `numpy` only, no torch, no GPU, no network calls anywhere in `src/`.
 
 - Dataset: [causal-predictive-alerting-benchmark](https://huggingface.co/datasets/Dhi-Technologies/causal-predictive-alerting-benchmark)
 - Demo: [causal-predictive-alerting-demo](https://huggingface.co/spaces/Dhi-Technologies/causal-predictive-alerting-demo)
 
 ## A5: thermal perception
 
-**One liner:** a radiometric data engine and self supervised pretraining harness for thermal
-native perception, built so the math is CPU verifiable ahead of any GPU pretraining run.
-
-**Honesty mechanism:** no trained checkpoint is published where none was trained. A hard coded
-floor, `min_corpus_frames = 200,000`, labels anything trained on fewer frames a mechanics pilot,
-not a quality claim, in the repo's own training logs, and both of its real GPU training runs to
-date (2,503 and 15,488 frames) sit far below that floor and are reported as such rather than
-presented as validation. The GPU pretraining run itself is emitted as a costed *recipe*, not
-shipped as a model, specifically so nothing on this org implies a thermal foundation model
-exists when it does not.
-
-**One verified number:** `thermalcore.cli selfcheck` passes all four AGC normalization
-variants and the self supervised loss correctness check, with a linear probe separability
-sanity check scoring 0.94, on a CPU only, 99 test suite (`99 passed in 0.39s`); this validates
-the math, not real world thermal accuracy, and the dataset card says so explicitly.
-
-**Under the hood:** 2,222 lines across 21 Python files (synthetic radiometric scene generator,
-an AGC normalization zoo, cross-sensor domain tooling, a pretraining corpus engine, MAE masking
-math, and closed-form evaluation metrics with no `sklearn`/`torch` dependency). Two GPU pilots on
-record (2,503 synthetic frames, 32 minutes; 15,488 real LLVIP infrared frames, 40 minutes, both
-on a rented RTX 5060 Ti) sit far below the repo's own 200,000-frame pretraining floor and are
-both labeled mechanics pilots, not quality evidence, in the repo's own results docs.
+This is the portfolio's discipline case: a radiometric data engine and self supervised
+pretraining harness for thermal native perception, built so every piece of math is CPU
+verifiable ahead of any GPU spend. The honesty mechanism is a refusal to publish a model where
+none was validly trained: a hard coded floor, `min_corpus_frames = 200,000`, labels anything
+pretrained on fewer frames a *mechanics pilot*, not a quality claim, in the repo's own training
+logs. Both GPU runs on record sit far below that floor and are labeled accordingly: a 2,503
+synthetic frame pilot (32 minutes) and a 15,488 real infrared frame pilot on LLVIP data (40
+minutes), both on a rented RTX 5060 Ti, both reported as evidence the machinery runs, not that
+the pretraining works. The GPU pretraining run itself ships as a costed recipe rather than a
+checkpoint, specifically so nothing on this org implies a thermal foundation model exists when
+none does.
+
+What is verified is the math: `thermalcore.cli selfcheck` passes all four AGC normalization
+variants and the self supervised loss correctness checks, with a closed form linear probe
+separability sanity check scoring 0.94, on a CPU only suite whose recorded verbatim line is
+`99 passed in 0.39s`. The dataset card says explicitly that this validates mechanics, not real
+world thermal accuracy. Under the hood: 2,222 lines across 21 files: a synthetic radiometric
+scene generator, an AGC normalization zoo, cross sensor domain tooling, a pretraining corpus
+engine, MAE masking math, and closed form evaluation metrics with no `sklearn` or `torch`
+dependency in the core.
 
 - Dataset: [thermal-perception-benchmark](https://huggingface.co/datasets/Dhi-Technologies/thermal-perception-benchmark)
 - Demo: [thermal-perception-demo](https://huggingface.co/spaces/Dhi-Technologies/thermal-perception-demo)
 
 ## B1: Prompt2Model
 
-**One liner:** a language guided vision model factory: prompt in, dataset config, training,
-calibration, ONNX export, and an optional accuracy gated compression step, out. As of today it
-has its first tagged public release, v0.1.0, covered in full in post 5.
-
-**Honesty mechanism:** two refusal gates in one pipeline. At inference, a split conformal
-abstention check compares each prediction's nonconformity against a validation calibrated
-threshold and abstains rather than guessing on unfamiliar inputs. At the factory level, the
-compression step refuses to ship a distilled or quantized model that drops more than 2% below
-the uncompressed model's accuracy, shipping the uncompressed model instead and logging the
-refusal. What is and is not validated is tracked in the open on GitHub, as numbered issues
-against the release, not smoothed into marketing copy: detection mAP for the emitted artifact
-and on Jetson TensorRT latency are both explicitly flagged as not yet measured.
-
-**One verified number:** the inference time abstention threshold is fit from held out
-validation data, not chosen by hand, at alpha=0.1 (a 90% target coverage); on the toy
-classification smoke test it came out to a conformal threshold of 0.491826 from 7 held out
-samples, and the compression gate's default accuracy floor is 98% of baseline accuracy,
-enforced in code, not documentation. At v0.1.0, the repository's full test suite passed 117
-of 117 tests with zero skips, in roughly 106 seconds.
-
-**Under the hood:** classification and COCO-style detection dataset loaders, a lightweight model
-registry, ONNX export with metadata verification, and pluggable deployment targets (ONNX Runtime
-by default, TensorRT when `trtexec` is present, otherwise a reproducible on-device build recipe).
-The toy smoke test's exported classification model runs at roughly 150 ms per image on CPU
-(1.52M parameters); the toy detection model runs at roughly 36 ms per image on CPU (2.22M
-parameters, mAP@0.5 of 0.053 on a training set of a few dozen images, disclosed as a pipeline
-smoke test, not a benchmark).
+The newest product is a language guided vision model factory: a plain English task description
+compiles into a typed pipeline that runs dataset loading, training, evaluation, calibration,
+ONNX export, and optional accuracy gated compression end to end. It carries two refusal gates.
+At inference, a split conformal check abstains rather than guessing when a prediction's
+nonconformity exceeds a threshold fit from held out validation data; on the healthy toy smoke
+test that threshold is 0.004888 at alpha 0.1, and the exported model, re run this session,
+classified 36 of 36 in distribution toy images correctly with zero abstentions while abstaining
+on both out of distribution probes it was fed (a yellow star, calibrated confidence 0.9845, and
+uniform noise, 0.9391). At the factory level, the compression step refuses to ship a distilled
+or quantized model that falls below 98% of the uncompressed model's accuracy, a hard coded
+floor; a failing candidate means the uncompressed model ships and the refusal is logged.
+
+It is also the program's engineering candor case study: the first published smoke test artifact
+reported 0.0 accuracy, and the diagnosis, a chain of three real bugs (unseeded RNGs, a class
+dropping data split, a from scratch backbone whose BatchNorm statistics collapsed to constant
+logits), is told in full in post 5, along with the deterministic healthy rerun (accuracy 1.0,
+macro F1 1.0 against a 0.33 chance floor) and the corrections it forced to previously published
+numbers. Suite: 117 of 117 at the tagged v0.1.0 release per its release notes; current main,
+re run this session, `118 passed in 87.73s (0:01:27)`. The release ships with eight numbered
+known limitation issues, including no measured detection mAP for the emitted artifact and no on
+device TensorRT latency yet, tracked openly rather than smoothed into marketing copy.
 
 - Dataset: [prompt2model-examples](https://huggingface.co/datasets/Dhi-Technologies/prompt2model-examples)
 - Demo: [prompt2model-demo](https://huggingface.co/spaces/Dhi-Technologies/prompt2model-demo)
-- Code (public, MIT licensed): [Prompt2Model-Language-Guided-Vision-Model-Factory](https://github.com/DHI-Technologies-Inc/Prompt2Model-Language-Guided-Vision-Model-Factory)
 - Deep dive: [Prompt2Model v0.1.0](05_prompt2model_v010.md)
 
+## How the pieces compose on one edge box
+
+The portfolio is not six disconnected experiments; the interfaces were designed so the products
+stack on a single small computer, and the design constraints that make that possible are
+measured properties, not aspirations. To be explicit about framing: what follows describes how
+the components are built to fit together, verified at the interface level; it is not a claim
+that this composed system is deployed anywhere.
+
+Start with what every product above has in common: the decision layers are CPU only. E1 is
+`numpy` plus stdlib `sqlite3`; A4 and A3 are `numpy` and `scipy`; E4 is `numpy` with no network
+calls in its core. The only GPU consumers in the composed picture are the perception models that
+feed them, a detector and tracker producing boxes and track IDs, which is precisely the workload
+a Jetson class device's accelerator is for. That split matters on an 8 GB box: the reasoning
+layer's footprint is measured in megabytes (E1's month of presence stays under 2 MB by asserted
+test; its densest real ingest, 42,707 WILDTRACK events, produced a 7.4 MB store), so adding the
+honesty machinery costs almost nothing next to the models it supervises.
+
+The composition follows the data. A detector's boxes go two places at once. A4 consumes the
+per frame box set and returns a corrected count with a calibrated interval and an extrapolation
+flag, so a crowding dashboard reads "34 to 48, 90% calibrated" instead of a bare "39". The
+tracker's track stream feeds E1 as JSONL events, exactly the contract its Frigate bridge already
+implements for one real NVR; identity references arrive from whatever external identity exists
+at the site, a plate reader, a badge system, or a face free embedding cluster, each gated by
+confidence before it is trusted. A3 calibrates each fixed camera once from pedestrians already
+in the scene and thereafter converts image tracks to metric ground positions, which is the
+coordinate system E4's kinematic predictor needs; E4 then watches those metric trajectories,
+fires ahead of incidents, and grades itself in its ledger. B1 sits beside the pipeline rather
+than in it: it is the factory that produces the site specific classifier or detector variants
+the other components consume, refusing to ship compressed models that fail its floor. Each
+handoff carries the upstream component's honesty signal with it: an extrapolation flagged count,
+a refused link that becomes a new entity rather than a guess, a sensitivity number that says one
+camera's geometry cannot support far field metric claims, a falsified prediction that stays in
+the ledger.
+
+The open integration work is stated as plainly as the finished parts: E1's identity references
+from the face free re identification line are an interface today, not a validated joint run;
+per camera clock offset estimation (which would tighten E1's transit priors) is unbuilt; A3's
+learned depth adapters and TensorRT path are future work; and no composed end to end benchmark
+of the full stack exists yet. When one does, it will be published with the same rules as
+everything else here: synthetic ground truth first, real data second, negative results included.
+
 ## The pattern across all six
 
-Four mechanisms recur across these six products, in different combinations: calibrated
-intervals (A4), refusal gates (E1, B1), provenance (E1), and falsification ledgers (E4). A3
-and A5 add a fifth pattern that is really the same instinct applied to reporting: disclose the
-hard case and the unfinished step instead of smoothing over them, whether that is a shallow
-camera mount's sensitivity number or a GPU pretraining run that is honestly labeled a mechanics
-pilot rather than a quality result. None of these are free. Every one of them costs something
-measurable: recall in E1, interval width in A4, false positives in E4, model size headroom in
-B1, and we publish that cost next to the benefit rather than only the benefit. It also shows up
-in how we handle our own mistakes: three separate reproductions across this org (E1's memory
-size and journey range, A3's test count, A4's real-data regression before the fix) found small
-gaps between prior prose and a fresh run, and every one of them is disclosed in the matching
-post rather than quietly rounded away. That is the whole thesis from post 1, applied six times,
-plus a seventh product now stepping into the same public accountability the moment it ships its
-first release.
+Four mechanisms recur across these products: calibrated intervals (A4), refusal gates (E1, B1),
+provenance (E1), and falsification ledgers (E4), with A3 and A5 applying the same instinct to
+reporting itself, disclosing the hard case and the unfinished step instead of smoothing over
+them. None of these are free, and the price is always published next to the benefit: recall in
+E1 (0.0476 to 0.6788 across the grid, 0.0 without references on WILDTRACK), interval width in A4
+(6.7x to 14.5x), false positives in E4 (8.0%, itemized), answer rate and size headroom in B1. It
+also shows up in how the program handles its own mistakes: stale prose corrected against fresh
+runs (E1's memory size and journey range, A3's test count), a real data regression published
+before its fix existed (A4), and a degenerate published artifact diagnosed in public (B1). That
+is the whole thesis from post 1, applied six times.
 
 - Series: [post 1, the thesis](01_ai_that_refuses_to_guess.md), [post 2, E1 deep dive](02_e1_precision_first_linking.md), [post 3, A4 deep dive](03_a4_calibration_over_accuracy.md), [post 5, Prompt2Model v0.1.0](05_prompt2model_v010.md)
 - Collection: [Dhi Labs, honest edge vision AI](https://huggingface.co/collections/Dhi-Technologies/dhi-labs-honest-edge-vision-ai-6a4eb297cbd60f5f673cc2d7)
 - Org: [Dhi-Technologies](https://huggingface.co/Dhi-Technologies)
-- Code: proprietary, closed source permanently for five of the six products; Prompt2Model (B1) is
-  a deliberate exception with one public, MIT-licensed release, above. The GitHub org
-  [github.com/DHI-Technologies-Inc](https://github.com/DHI-Technologies-Inc) is an identity link,
-  not a browsable source destination for the other five. Partnership or access inquiries:
-  [dhi-tech.com](https://dhi-tech.com).
+- Code: proprietary, closed source across the portfolio; Prompt2Model additionally has one
+  tagged, MIT licensed v0.1.0 release as a deliberate exception (post 5). The open surface for
+  everything is the evidence: benchmark datasets with exact ground truth, demo Spaces, committed
+  evidence logs, and the verbatim reproduction output quoted throughout this series. Partnership
+  or access inquiries: [dhi-tech.com](https://dhi-tech.com).

05_prompt2model_v010.md

@@ -1,133 +1,227 @@
-# Prompt2Model v0.1.0: a language guided vision model factory's first release
+# Prompt2Model v0.1.0: a model factory's first release, bugs and all
 
 *Dhi Labs, post 5 of 5: Prompt2Model (B1) ships its first tagged release*
 
-Today we tagged v0.1.0 of Prompt2Model, publicly and under the MIT license. It is the newest
-product in the Dhi Technologies research program (internal label B1) and the first of the six
-products covered in posts 1 through 4 to cross from private research code into a public GitHub
-release with its own version number, its own test count, and its own numbered list of open
-issues. This post covers what shipped, what is measured, and what is honestly still open, in the
-same style as the rest of this series: real numbers with their source, and a limitations section
-that is not an afterthought.
+Prompt2Model is the newest product in the Dhi Technologies research program (internal label B1)
+and the first to cross from private research code into a tagged public release: v0.1.0, tagged
+and published 2026-07-09 under the MIT license, as a deliberate exception to the closed source
+posture of the rest of the portfolio. This post covers what shipped, how its two refusal gates
+actually work at the mechanical level, and then the part that makes it belong in this series:
+the story of the degenerate artifact this pipeline published before its first release, the
+three real bugs behind it, and the corrections that fix forced to numbers we had already put in
+public. Real numbers with their source throughout, and the limitations section is the longest
+one in the series, because this is the youngest product in it.
 
 ## What it does
 
 Prompt2Model takes a plain English task description, for example "classify red square, blue
 circle, and green triangle images under low light, prioritize speed," and compiles it into a
-typed pipeline configuration that runs dataset loading, training, evaluation, ONNX export, and
-reporting end to end. Concretely:
+typed pipeline configuration that runs dataset loading, training, evaluation, calibration, ONNX
+export, and reporting end to end. Concretely:
 
 - A deterministic regex prompt parser is the default (dependency free), with an optional LLM
-  planner overlay (`planner.py`, offline first, works against any OpenAI compatible
-  `/v1/chat/completions` endpoint) that only overwrites the fields it actually extracts from the
-  prompt, rather than replacing the deterministic parse wholesale.
+  planner overlay that is offline first, works against any OpenAI compatible chat completions
+  endpoint, and only overwrites the fields it actually extracts from the prompt rather than
+  replacing the deterministic parse wholesale.
 - Classification and COCO style detection dataset loaders, a lightweight model registry, and
-  training loops with augmentation injection.
-- ONNX export with metadata injection and verification, so an exported model is checked to
-  actually run, not just checked to exist on disk.
-- An opt-in compression step: knowledge distillation and INT8 quantization, gated by an accuracy
-  floor. If the compressed artifact cannot hold the floor, the factory refuses to ship it and
-  keeps the uncompressed model instead of silently shipping a degraded one.
-- Opt-in calibration (temperature scaling and a split conformal abstain threshold) and a
-  flywheel hard case store for the classification path, so inputs the model is unsure about get
-  surfaced rather than guessed at and forgotten.
-- Pluggable deployment targets: ONNX Runtime by default, plus TensorRT, which builds locally when
-  `trtexec` is present on the machine, and otherwise emits a reproducible on device build recipe
-  instead of silently failing or pretending the export happened.
-
-## The refusal gate this pipeline is really about
-
-The same honesty mechanism named in posts 1 and 4 is the centerpiece here, not a footnote. At
-inference time, a split conformal abstention check compares each prediction's nonconformity (1
-minus the predicted probability) against a validation calibrated threshold, and abstains rather
-than guessing when that threshold is exceeded. The threshold is fit from held out data, not
-chosen by hand: on the repository's own toy classification smoke test, fit at `alpha=0.1` (a 90%
-target coverage) from 7 held out samples, it came out to `conformal_threshold=0.491826`. That
-smoke test's own card also discloses, rather than smooths over, that calibrating from only 7
-samples is noisy: `ece_before` was 0.065 and `ece_after` was 0.272 on that tiny sample.
-
-Separately, at the factory level, the compression step refuses to ship a distilled or quantized
-model that falls below 98% of the uncompressed model's accuracy, the default retention floor,
-hard coded rather than merely documented. If the compressed candidate fails that floor, the
-pipeline ships the uncompressed model instead and logs the refusal in the run report, rather than
-silently shipping a smaller but worse model to hit a size target.
-
-## What the toy smoke test actually measured
-
-The `prompt2model-examples` dataset on this org ships the fixtures and the real output of running
-`prompt2model.cli smoke-test` against them, generated by the repository's own
-`generate-toy-data` command. Read these as a **pipeline smoke test, not a model quality
-benchmark**: the toy sets are a few dozen procedurally drawn shape images per class, by design.
-
-- **Classification**: ONNX export built and verified runnable; 1.52M parameters; about 150 ms
-  per image, roughly 6.6 fps, on CPU for the exported model.
-- **Detection**: mAP@0.5 = 0.053, mAP@[0.5:0.95] = 0.014 on the toy set, numbers we expect to be
-  low given a handful of synthetic training images, not a real detection benchmark; ONNX export
-  built and verified runnable; 2.22M parameters; about 36 ms per image, roughly 27.5 fps, on CPU.
-
-The point of this artifact is that the typed pipeline runs end to end and the exported ONNX
-models are verified runnable, not that these are competitive vision models trained on a few dozen
-images. No trained checkpoint from this toy run is presented as a usable vision model; when the
-pipeline is run on a real task, that model would be published separately, labeled with its actual
-training data and metrics.
+  training loops with augmentation injection derived from the prompt's environment tags ("low
+  light" becomes a low light augmentation policy).
+- ONNX export with metadata injection and verification: an exported model is checked to actually
+  run under ONNX Runtime, not just to exist on disk, and the calibration block travels inside
+  the artifact's metadata so the deployed model carries its own abstention threshold.
+- An opt in compression step (knowledge distillation and INT8 quantization) gated by an accuracy
+  floor, described below.
+- Opt in calibration (temperature scaling plus a split conformal abstain threshold) and a
+  flywheel hard case store, so inputs the model abstains on can be captured for the retrain loop
+  instead of being guessed at and forgotten.
+- Pluggable deployment targets: ONNX Runtime by default, TensorRT when `trtexec` is present on
+  the machine, and otherwise a reproducible on device build recipe rather than a silent failure
+  or a pretended export.
+
+## The refusal gates, mechanically
+
+Posts 1 and 4 name the mechanism; this section shows its gears, because "calibrated abstention"
+is the kind of phrase that deserves to be checked against actual arithmetic.
+
+**The inference gate.** After training, the factory temperature scales the model's logits on a
+held out validation split, then computes each validation prediction's *nonconformity*, defined
+as 1 minus the calibrated confidence of the predicted class. The abstention threshold is the
+split conformal quantile of those scores with the standard finite sample correction: sort the n
+validation scores, take the score at rank ceiling of (n + 1)(1 - alpha), clamped into range, at
+the default alpha of 0.1 (a 90% target). At deployment, the exported model abstains whenever a
+prediction's nonconformity exceeds that threshold. With no calibration data at all, the
+threshold is positive infinity, never abstain until calibrated, which is itself a documented
+choice: an uncalibrated model does not pretend to know its own limits.
+
+The finite sample correction matters at small n, and the toy smoke test is honest about being
+small. With n = 7 validation samples and alpha = 0.1, the required rank is the ceiling of 8
+times 0.9, which is 8, clamped to 7: the threshold is simply the *largest* nonconformity seen in
+validation. That is the weakest form of the guarantee, and it is what a 7 sample calibration can
+legitimately give you; more validation data tightens it, and the run report exposes
+`val_samples: 7` precisely so a reader can see how much the threshold is resting on.
+
+**The factory gate.** Separately, the compression step refuses to ship a distilled or quantized
+model that falls below 98% of the uncompressed model's accuracy. The floor is a typed config
+default (`accuracy_floor_relative = 0.98`), enforced in code; a failing candidate means the
+pipeline ships the uncompressed model and logs the refusal in the run report. One known edge in
+its precedence logic, where the hard coded relative floor can override a more permissive,
+explicitly stated user floor, is tracked as a numbered issue rather than left undocumented (see
+the gaps list at the end).
+
+## The engineering case study: a published 0.0, and the three bugs behind it
+
+Here is the part of the release story a normal announcement would omit. The first published
+smoke test artifact for this pipeline reported toy classification accuracy 0.0 and macro F1 0.0.
+Not "low": zero, on a three class problem with a 0.33 chance floor, in a results file we had
+already made public. The temptation with a number like that is to rerun until it looks better
+and republish. What actually happened is that the rerun was refused until the zero was
+*explained*, and the explanation turned out to be a chain of three real bugs, each of which is a
+small classic. The diagnosis and fix landed as a single reviewed change on 2026-07-09, and the
+commit message records all three mechanisms; the summaries below are drawn from that commit and
+the code it changed.
+
+**Bug one: the RNGs were never seeded.** The dataset split and the augmentation backend already
+threaded a configured seed through, which made the pipeline *look* deterministic in review. But
+the factory's run entry point never seeded torch's global RNG, so model weight initialization
+and DataLoader shuffling changed on every run. On a severely undertrained toy run (a couple of
+epochs, a few dozen images), an unlucky random init can land at or near 0.0 by chance alone. The
+fix seeds Python's `random`, torch, and CUDA (when present) from the same configured seed at the
+top of every run. The lesson is the gap between "the code accepts a seed" and "the run is
+seeded": the former is an API property, the latter is a property of every RNG the run touches.
+
+**Bug two: the data split could drop an entire class.** The splitter did a flat shuffle and
+slice over the whole sample pool with no class balance protection. On the toy set, three classes
+of twelve samples each, a single global shuffle can and, with the default seed, *did* leave an
+entire class out of a validation or test slice. Evaluating a three way classifier on a split
+that never contains one of the three classes produces meaningless, sometimes zero metrics that
+look exactly like a training bug while actually being a sampling bug. The fix is stratified
+splitting via largest remainder apportionment: each class gets the floor of its proportional
+quota in each slice, and leftover slots go to the largest fractional remainders, which keeps the
+overall split sizes identical to the flat split while guaranteeing every class is spread as
+evenly as its size allows.
+
+**Bug three: the smoke test trained a modern backbone from scratch.** The smoke test never set
+`pretrained=True`, so it trained `mobilenet_v3_small` from random initialization with batch size
+8 on about 26 images. BatchNorm running statistics re estimated from batches of 8 over a couple
+of epochs never stabilize, and the backbone collapses to an input independent constant output.
+This was verified, not inferred: the logits were identical across all validation images
+regardless of the true label. Combined with bug two, an unlucky run reports systematic wrong
+answers and lands on exactly 0.0. The fix sets `pretrained=True` for both smoke test tasks,
+matching the model registry's own documented recommendation.
+
+Three observations make this a case study rather than a confession. First, the bugs *compounded*:
+any one of them alone would have produced occasional weird numbers; together they produced a
+stable looking catastrophe with a plausible innocent explanation ("toy set, few epochs") sitting
+right next to it. Second, the degenerate artifact was load bearing for honesty elsewhere: the
+previously published conformal threshold for this smoke test, 0.491826, and its strange
+calibration trace (`ece_before` 0.065, `ece_after` 0.272, calibration making expected
+calibration error *worse*) were measurements of a collapsed model, and we had quoted them in an
+earlier revision of this very blog series as an example of disclosing noisy calibration. The
+disclosure instinct was right; the numbers were describing a broken model. Both are now
+corrected here, which is the third observation: publishing your artifacts means your bugs are
+public, and fixing them means correcting the public record, not just the code.
+
+## The healthy model, re measured for this post
+
+With the three fixes in, the smoke test is deterministic and healthy, and we re ran the whole
+thing fresh for this post on a CPU only machine (macOS, Python 3.12.13, no GPU) rather than
+quoting the repository's committed artifact:
+
+- **Classification:** accuracy 1.0, macro F1 1.0, against a 0.33 chance floor (three classes,
+  36 images). Calibration on the 7 held out validation samples: temperature 0.05, conformal
+  threshold **0.004888** at alpha 0.1, `ece_before` 0.3864, `ece_after` 0.0014. Exported ONNX
+  verified runnable; 1.52M parameters; about 100 ms per image on this machine's CPU.
+- **Detection:** the pipeline runs end to end and exports a verified runnable ONNX artifact
+  (`ssdlite320_mobilenet_v3_large`, 3.73M parameters), with toy set mAP@0.5 of 0.034: a pipeline
+  smoke test on a few dozen synthetic images, not a detection benchmark, and labeled as such.
+  Earlier published toy detection figures (mAP 0.053, 2.22M parameters) predate the determinism
+  fix and no longer describe the current artifact; treat the numbers in this paragraph as the
+  ones that reproduce.
+
+Then the demonstration the abstention gate exists for. The conformal threshold of 0.004888 means
+the deployed model answers only when its calibrated confidence is at least about 0.9951, a very
+sharp gate produced by a temperature of 0.05 on a cleanly separated toy problem. Running the
+exported artifact over all **36** in distribution toy images: **36 of 36 classified correctly,
+zero abstentions**, with every calibrated confidence at or above 0.9951. Then two inputs the
+model has never seen anything like: a yellow star on a dark background scored a calibrated
+confidence of 0.9845, below the gate, **abstained**; uniform random noise scored 0.9391,
+**abstained**. The same artifact that never abstains on its own distribution refuses both out of
+distribution probes instead of confidently naming a shape that is not there.
+
+The plumbing that makes the demonstration meaningful is worth two sentences, because it is easy
+to build an abstention gate that evaporates at deployment. The calibration block (temperature,
+alpha, conformal threshold, validation sample count) is injected into the ONNX artifact's own
+metadata at export, and the edge inference wrapper reads it back from the artifact, applies the
+temperature to the raw logits, and computes `abstained` as nonconformity exceeding the stored
+threshold; the model file and its abstention policy cannot drift apart, because they are one
+file. An artifact exported without calibration reports `calibrated: false` and never abstains,
+rather than pretending to a policy it does not carry, and the abstain path is pinned by its own
+unit test (force the threshold to zero and assert that a model that cannot be perfectly certain
+abstains). The same wrapper accepts an optional hard case store, so abstained frames can be
+captured for the retraining flywheel instead of being dropped on the floor. For the toy runs,
+the whole pipeline configuration is typed and committed alongside the artifact: image size 96,
+validation split 0.2, test split 0.1, seed 42, which is what "deterministic under its seed"
+means concretely.
+
+An honest boundary on that demonstration, so it is not overread: two crafted probes are a
+demonstration of the mechanism working as designed, not a measured out of distribution detection
+rate, and split conformal calibration guarantees coverage on data drawn from the calibration
+distribution; it makes no formal promise about arbitrary OOD inputs. A 7 sample calibration also
+means the threshold itself is only as stable as those 7 points. The right reading is mechanical,
+not statistical: the gate is real, it is fit from data rather than hand set, it travels inside
+the exported artifact, and it fires in the right direction on the obvious probes.
 
 ## The measured test suite
 
-Before tagging v0.1.0, the full test suite was run in the release environment. Verbatim from the
-release notes: **117 passed, 0 failed, full suite, no skips, in about 106 seconds.** That is the
-number we are attaching to this release, sourced from the GitHub release page itself
-(`v0.1.0`, tagged and published 2026-07-09), not re-run independently for this post.
+The v0.1.0 release notes record the release gate: **117 passed, 0 failed, full suite, no skips,
+in about 106 seconds**, sourced from the release itself. Current main, which includes the three
+bug fix and one test it added, re run fresh for this post; verbatim final line:
 
-## What is validated versus what is not
+```
+118 passed in 87.73s (0:01:27)
+```
 
-Stated as plainly as the release notes state it, because a release note is exactly the kind of
-place this kind of claim quietly gets softened elsewhere:
+## What is validated versus what is not
 
 - **Validated end to end:** the classification path, prompt to config to training to metrics to
-  ONNX export to report, on synthetic data.
-- **Integrated but not fully measured:** the detection path is wired through export and a smoke
-  test, but detection accuracy (mAP) for the emitted, deployment-ready artifact is not yet
-  measured on a real detection benchmark (tracked as GitHub issue #10).
-- **Not yet measured at all:** on-device latency for the emitted TensorRT recipe on a Jetson class
-  device. The TensorRT deployment path builds locally or emits a reproducible build recipe, but
-  no Jetson has actually run that recipe and timed it yet (tracked as GitHub issue #12).
+  calibrated ONNX export to report, on synthetic data, deterministic under its seed, with the
+  healthy numbers above reproduced from scratch for this post.
+- **Integrated but not benchmark measured:** the detection path is wired through training,
+  export, and a smoke test, but detection accuracy for the emitted, deployment ready artifact
+  has not been measured on any real detection benchmark.
+- **Not measured at all:** on device latency for the emitted TensorRT recipe on a Jetson class
+  device. The deployment path builds locally when `trtexec` exists and otherwise emits a
+  reproducible build recipe, but no Jetson has run and timed that recipe yet.
 
-## Known gaps, tracked as open issues, not swept under the rug
+## Known gaps, tracked as numbered issues
 
-The release ships with a numbered list of its own known limitations, several of which are more
-interesting than a typical "future work" paragraph because they name a specific, already
-observed failure:
+The release ships with a numbered list of its own limitations in the project tracker, several of
+which name an already observed failure rather than generic future work. All eight, not a
+flattering subset:
 
 - **#7:** dynamic versus static INT8 post training quantization needs a real data sweep; dynamic
   quantization has already been observed to collapse accuracy on one dataset.
 - **#8:** the compression gate's evaluator needs guards against degenerate or tiny validation
-  splits, since a floor computed from too few samples can be misleading.
-- **#9:** there is no zero-shot VLM or CLIP baseline yet to check the augmentation transfer
-  claim against.
-- **#10:** no measured detection mAP yet for the emitted SSDLite artifact (export verified only,
-  as above).
-- **#11:** no fixed RNG seeds or dataset checksums yet, which is reproducibility hardening still
-  to be done.
-- **#12:** no on-Jetson TensorRT latency measurement yet for the emitted artifact, as above.
+  splits, since a floor computed from too few samples can be misleading (the same small n
+  caveat the conformal gate discloses).
+- **#9:** no zero shot VLM or CLIP baseline yet to check the augmentation transfer claim
+  against.
+- **#10:** no measured detection mAP for the emitted SSDLite artifact (export verified only).
+- **#11:** reproducibility hardening beyond the RNG fix: dataset checksums and pinned fixture
+  hashes are still to be done.
+- **#12:** no on Jetson TensorRT latency measurement for the emitted artifact.
 - **#13:** README and report claims need reconciliation with what is actually measured and on
-  which hardware, plus authorship and venue framing, an internal honesty pass still in progress.
-- **#14:** the compression gate's hard coded 0.98 relative retention floor can currently override
-  a more permissive, explicitly stated user accuracy floor, a real edge case in the gate's own
-  precedence logic.
-
-We are listing all eight by number rather than picking the flattering three, for the same reason
-the rest of this series names crowd buildup as the weakest alert kind and the CrowdHuman
-regression as a real regression: an open issue tracker that only shows the easy ones is not
-actually open.
-
-## License, and where to look
+  which hardware; this post is part of that reconciliation, and the degenerate artifact
+  corrections above came out of it.
+- **#14:** the compression gate's hard coded 0.98 relative floor can override a more permissive,
+  explicitly stated user accuracy floor, a real precedence edge case in the gate's own logic.
 
-The repository is MIT licensed, `LICENSE` in the repo root. Everything in this post traces back
-to a source you can check yourself:
+## Where to look
 
-- Code (public, MIT licensed): [Prompt2Model-Language-Guided-Vision-Model-Factory](https://github.com/DHI-Technologies-Inc/Prompt2Model-Language-Guided-Vision-Model-Factory)
-- Release: [v0.1.0](https://github.com/DHI-Technologies-Inc/Prompt2Model-Language-Guided-Vision-Model-Factory/releases/tag/v0.1.0)
-- Examples dataset (toy fixtures plus real smoke test output): [Dhi-Technologies/prompt2model-examples](https://huggingface.co/datasets/Dhi-Technologies/prompt2model-examples)
-- Live demo Space (the refusal-gate mechanism plus a worked abstain/predict example): [prompt2model-demo](https://huggingface.co/spaces/Dhi-Technologies/prompt2model-demo)
+- Examples dataset (toy fixtures plus smoke test output): [Dhi-Technologies/prompt2model-examples](https://huggingface.co/datasets/Dhi-Technologies/prompt2model-examples)
+- Live demo Space (the refusal gate plus a worked abstain and predict example): [prompt2model-demo](https://huggingface.co/spaces/Dhi-Technologies/prompt2model-demo)
 - Collection: [Dhi Labs, honest edge vision AI](https://huggingface.co/collections/Dhi-Technologies/dhi-labs-honest-edge-vision-ai-6a4eb297cbd60f5f673cc2d7)
+- Code: the rest of the portfolio is proprietary and closed source; Prompt2Model's v0.1.0 is a
+  tagged, MIT licensed public release, the program's deliberate exception. Access and
+  partnership inquiries: [dhi-tech.com](https://dhi-tech.com).
 - Series: [post 1, the thesis](01_ai_that_refuses_to_guess.md), [post 2, E1 deep dive](02_e1_precision_first_linking.md), [post 3, A4 deep dive](03_a4_calibration_over_accuracy.md), [post 4, portfolio overview](04_portfolio_overview.md)

README.md

@@ -17,49 +17,65 @@ dataset card, and the [Dhi Labs collection](https://huggingface.co/collections/D
 
 ## Posts
 
-1. **[AI that refuses to guess](01_ai_that_refuses_to_guess.md)** (2026-07-09 update): the
-   thesis. Calibrated intervals, refusal gates, provenance, and falsification ledgers as product
-   features, each measured rather than asserted, across all six products, with the code paths
-   and a real-data regression behind each claim.
-2. **[Precision first cross camera linking (E1)](02_e1_precision_first_linking.md)** (2026-07-09
-   update): a deep dive into multicam reasoning memory. How a uniqueness guard lifted synthetic
-   site precision from 0.918 to 1.0 (recall traded deliberately), how weeks-scale memory stays
-   under 2 megabytes, and two small discrepancies this session found between prior prose and a
-   fresh reproduction.
-3. **[When the error bar is the product (A4)](03_a4_calibration_over_accuracy.md)** (2026-07-09
-   update): a deep dive into amodal counting's calibration honesty. The analytic interval
-   undercovered (0.50 to 0.63 actual versus a claimed 0.90); conformal calibration widened it 6.7x
-   to 14.5x; a real CrowdHuman re-test made the correction *worse* before a two-sided estimator
-   fixed it, and both results are published.
-4. **[Six products, one honesty thesis](04_portfolio_overview.md)** (2026-07-09 update): a
-   portfolio overview tying all six products (A4, E1, A3, E4, A5, B1) back to the thesis in post
-   1, with each product's honesty mechanism, clearest verified number, and test suite count.
-5. **[Prompt2Model v0.1.0](05_prompt2model_v010.md)** (new, 2026-07-09): the seventh piece of the
-   program crosses into a public, MIT-licensed release. What shipped, a measured 117-test suite,
-   and what is explicitly not yet validated (detection mAP, on-Jetson latency), tracked as
-   numbered GitHub issues rather than smoothed over.
+1. **[AI that refuses to guess](01_ai_that_refuses_to_guess.md)** (2026-07-10 update, ~17 min
+   read): the thesis. A full taxonomy of the four honesty mechanisms (calibrated intervals,
+   refusal gates, provenance, falsification ledgers) with a worked, real numbered micro example
+   of each; why the industry default is overclaiming and what it costs operators; and the
+   measurement philosophy: synthetic ground truth first, real data second, negative results
+   published.
+2. **[Precision first cross camera linking (E1)](02_e1_precision_first_linking.md)** (2026-07-10
+   update, ~19 min read): the full method walkthrough (episodes versus events, three gates with
+   their actual thresholds, transit priors learned only from ref confirmed links), the 0.918 to
+   1.0 uniqueness guard story with the failure case that motivated it, the 24 site grid, the
+   under 2 MB month test, the Frigate bridge's confidence gated identity mapping, and the first
+   real data campaign: WILDTRACK two ways (ground truth replay and a real YOLO11n + ByteTrack
+   pipeline), precision 1.0 with zero wrong links in every condition, recall 0.4087 and 0.3502
+   at 40% reference coverage, and an honest recall 0.0 without references, diagnosed rather
+   than hidden.
+3. **[When the error bar is the product (A4)](03_a4_calibration_over_accuracy.md)** (2026-07-10
+   update, ~14 min read): the flagship honesty story, told in four acts from the committed
+   evidence log. Synthetic wins first (analytic interval 0.50 to 0.63 actual coverage against a
+   0.90 claim, conformal multiplier 6.7x to 14.5x); then the first real CrowdHuman test fails
+   (flat detectability curve, one directional correction against two sided error, 28.204 versus
+   naive 14.08); a richer curve fails better; a detector fix improves naive to 11.767 and the
+   correction still loses; and the two sided estimator finally wins (11.031, 90.67% coverage),
+   with the dense scene boundary where naive still wins disclosed.
+4. **[Six products, one honesty thesis](04_portfolio_overview.md)** (2026-07-10 update, ~14 min
+   read): the portfolio tour. Each product in a full paragraph with its headline number and its
+   stated limitation in the same breath (A4, E1, A3, E4, A5, B1), the combined 340 test count
+   with its arithmetic shown, and a new section on how the pieces are designed to compose on a
+   single edge box, CPU only decision layers over GPU perception, stated as design properties
+   rather than deployment claims.
+5. **[Prompt2Model v0.1.0](05_prompt2model_v010.md)** (2026-07-10 update, ~12 min read): the
+   program's public release exception, MIT licensed and tagged. The refusal gate mechanics
+   (conformal threshold with the finite sample correction, the 0.98 relative accuracy floor),
+   the three bug engineering case study behind a published 0.0 accuracy artifact (unseeded
+   RNGs, class dropping splits, from scratch BatchNorm collapse), the healthy re measured
+   result (36 of 36 correct, zero abstentions in distribution, both OOD probes abstained), the
+   corrections that fix forced to earlier published numbers, and all eight numbered known
+   limitation issues.
 
 ## License
 
 This blog is released under **CC BY-NC 4.0** (non-commercial). It stays public and freely
 readable: this dataset is prose meant to be read, and gating it would hide the posts from
-everyone. Reading and citing individual posts is welcome; do not redistribute or re-host the text
-elsewhere without permission. Any use in a publication or downstream work should cite Dhi
+everyone. Reading and citing individual posts is welcome; do not redistribute or re-host the
+text elsewhere without permission. Any use in a publication or downstream work should cite Dhi
 Technologies. Commercial use requires a separate agreement; contact
 [dhi-tech.com](https://dhi-tech.com).
 
 ## Honesty note
 
-Every number in these posts is measured on **synthetic** benchmarks with exact ground truth,
-except where a post explicitly attributes a number to a real-data evidence log or a public
-release note and says so; real world validation is otherwise in progress and marked as such
+Numbers in these posts are measured on **synthetic** benchmarks with exact ground truth, except
+where a post explicitly attributes a number to a real data evidence log (CrowdHuman for A4,
+WILDTRACK for E1), a fresh reproduction run described in the post, or a public release note,
+and says so inline. Remaining real world validation is in progress and marked as such
 throughout. No state of the art claims, no customer or deployment claims.
 
 - Org: https://huggingface.co/Dhi-Technologies
 - Collection: https://huggingface.co/collections/Dhi-Technologies/dhi-labs-honest-edge-vision-ai-6a4eb297cbd60f5f673cc2d7
 - Company site: https://dhi-tech.com/labs
-- Code: proprietary, closed source permanently. Prompt2Model already shipped one public,
-  MIT-licensed release (post 5) as a deliberate exception; the other five products are not public
-  and have no release planned. The GitHub org [github.com/DHI-Technologies-Inc](https://github.com/DHI-Technologies-Inc)
-  is an identity link, not a browsable code destination for those five. Partnership or access
+- Code: proprietary, closed source; the open surface is the evidence these posts quote and link.
+  Prompt2Model shipped one public, MIT licensed release (post 5) as a deliberate exception; the
+  other five products are not public and have no release planned. Partnership or access
   inquiries: [dhi-tech.com](https://dhi-tech.com).