diff --git a/CHANGELOG.md b/CHANGELOG.md
index a065e60..b11a508 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,12 @@ entry per wave, newest first; the first six waves (V1–V6, the MVP) predate the
are recorded in PLAN.md §B and §J. Each entry carries the opening sentence of its row and
the reason the wave was built.
+## V71 — What stood in for a missing cell is counted
+
+G3.
+
+_Why:_ Approved 13/11/2026. A learner who trains here should be able to carry the run to a notebook and see, in figures, what changed on the way.
+
## V70 — Twin columns are flagged, not removed
G2.
diff --git a/PLAN.md b/PLAN.md
index 7dee061..3d7cc6a 100644
--- a/PLAN.md
+++ b/PLAN.md
@@ -680,7 +680,7 @@ defect that produces a wrong number comes first), then extends the lab past
the export: uncertainty with a guarantee, governance, and monitoring after
deployment, with nothing added on a server.
-V53 to V70 are delivered. Every other row is a proposal with its launch
+V53 to V71 are delivered. Every other row is a proposal with its launch
condition, and none starts without an explicit launch command.
| Wave | Content | Why |
@@ -704,16 +704,16 @@ condition, and none starts without an explicit launch command.
| **V68 — delivered** | **Counterfactuals: what would have to change.** F7, the last feature proposed. For a row typed in the what-if panel the lab said what the model predicts, what weighed (Shapley, V28) and what happened (the glass box, V66). It did not answer the question a person told « no » asks: what would have had to be different? The user looked for it by hand, one field at a time. **A search a reader can follow, not an optimisation**: one column at a time, every value the training rows hold tried in place of the row's own, the column keeping the nearest that flips the answer; two columns together only when no single one flips it; never three. Only observed values, no interpolation; free text is never edited; the columns the user locks are left alone, since the lab does not guess that an age cannot change. Nothing found is an answer, given with what was tried. The plan spoke of refining a numeric threshold by bisection; that would have produced values no row holds, against the rule just stated, and was dropped. **Measured on the four classification demos, three seeds, 60 test rows each, seven families.** One column is enough on 63 to 98 % of titanic's rows, 28 to 100 % of fraud's, 96 to 100 % of iris's; two are needed on up to 30 % (titanic, logistic) and 69 % (fraud, forest), so the pair search earns its place. On reviews most families find nothing (100 % of rows for the naive Bayes, 97 % for the tree): the answer is in the text. A search costs 30 ms at most (the forest), 100 to 550 predictions: no progress indicator is needed. **Two findings changed the design.** (1) **Plausibility**: 8 to 60 % of the nearest changes landed farther from every training row than 95 % of training rows are from their nearest neighbour; the model was answering where it had seen nothing. The search now keeps, per column, the nearest flipping value that stays inside that cloud, and flags the rest. It helps where an alternative exists (the tree on titanic from 8 to 4 %, the naive Bayes on fraud from 14 to 0 %) and not where none does: about half of iris's answers stay flagged, its four columns moving together. (2) **Fragility**: of the other trained models that agreed on the row, only 14 to 54 % answered the new class for the same change. A minimal change lands just across one model's boundary; each answer therefore says how many of the others follow. **What the flag does not catch**, seen on the screenshot review: on titanic the forest proposed `adult_male`: True to False while `sex` stayed `male`. Each value exists, the row does not, and a 0/1 column moving alone is not far from the cloud. The lab does not know two columns say the same thing; the panel and the limits page say so and tell the user to lock or drop the duplicate. **Defects of this wave's own making, caught before the push**: (1) the first search returned the nearest change whatever it was, above; (2) a category loaded into the form from a counterfactual could be rarer than the eight the form lists, and the field then showed another value than the one predicted on: the form now lists the loaded value; (3) the lock checkbox was first put inside the label of its field, so one label named two controls: two existing end-to-end tests that fill a field by its label failed, and the lock is now a control of its own beside the label; (4) the new page quoted a duration in milliseconds, which the documentation refuses since a test says so. **What this wave deliberately does not do**: give advice about the world, a counterfactual speaks of the model and the panel says so; search beyond two columns or edit free text; detect redundant columns; apply the chosen decision threshold (the change flips the prediction the what-if panel shows); handle a regression, where « another class » has no meaning, or a re-imported model, which carries no training rows; implement a published method (DiCE and others). A counterfactual is shown and saved nowhere. The list of proposed features is now empty. 1320 unit tests, 134 e2e. | Approved 13/11/2026. A learner who trains here should be able to carry the run to a notebook and see, in figures, what changed on the way. |
| **V69 — delivered** | **A SQL result reaches the lab whole.** G1, the first of the ten proposals a new reading of the repository produced after V68 (the others are listed below). The how-to page presents « filter, join or aggregate in SQL, then send to the ML Lab » as the normal path. **What the code said**: the console paints 200 rows, which is sound, and the three ways out of it were built from those painted rows. `toLab` and the CSV export sent `tableToCsv(result)`, a table already cut to 200. A note in the interface said so; it still emptied the gesture: nobody could train on a SQL result of more than 200 rows, and the demo file, 118 rows long, hid it. The cut saved no memory either, the engine having loaded the whole result before cutting. **Measured before the fix**, in the browser with the real engine, on a query returning 590 rows with a NULL in a numeric column: the lab received **200 rows**, and read the column as **categorical**, the NULL having left as `∅`, the mark the console paints for it, which the lab took for a category. **The fix**: an export is the query, not the screen. `SqlEngine.toCsv` asks DuckDB for the file, `COPY (…) TO … (FORMAT CSV, HEADER)`, as `toParquet` already did; the CSV export, the lab handoff and a Parquet button (the method existed since V40 and no button called it, though the reference announced it) all go through the engine, on the query that produced the result on screen, not on the text of the box, which may have been edited since. **Measured after**: the 590 rows arrive, the column is numeric with missing values, and a plain `SELECT *` over each of the lab's six demos gives back the same rows, the same columns and the same inferred types as the file loaded directly. Writing 118,000 rows took 0.2 s and 4.9 MB, 1,180,000 rows 6.4 s and 49 MB, on the single-threaded engine. The lab's cell budget (V54, 20 million) is applied before anything is built, so a result the lab would refuse is refused in the console, by name. **A file name of its own.** Every handoff was `query.csv`; the test-set ledger (V60) knows a file by its name and shape, and took two queries of the same shape for one file. The name now carries a fingerprint of the query, never its text; the FNV-1a function the ledger had moved to `lib/fingerprint.ts` instead of being copied. **Defects of this wave's own making**: none found by the suites; the fake engine of the panel's test had been answering `total` where the type says `totalRows` since V47, unnoticed because no test read it. **What this wave deliberately does not do**: make SQL read a file the way the rest of the app does (decimal comma, windows-1252, Excel, the cleaned or joined table): what leaves the console is complete, what enters it is still DuckDB's own reading, and the limits page says so; carry the recipe or the contract with the handoff; raise the 200 painted rows or paginate the console; change the engine or its version. 1330 unit tests, 134 e2e. | Approved 13/11/2026. A learner who trains here should be able to carry the run to a notebook and see, in figures, what changed on the way. |
| **V70 — delivered** | **Twin columns are flagged, not removed.** G2. The exclusion suggestions knew an identifier, a constant, a near-empty column and a leak; the functional-dependency test ran from a column to the target only. Titanic kept `class` and `pclass`, `embarked` and `embark_town`, `who` and `adult_male` as separate features. Twins split the importance and the Shapley values between them, and V68 had proposed a passenger who cannot exist by changing one without the other; its limits row told the user to deal with it alone. **The test**: the one `leakSuggestions` runs towards the target, run between columns. Each value of A goes with one value of B, both ways: they say the same thing. One way only: B can be read off A. Two continuous numbers: the near-perfect correlation of the leak test. It is target-independent, so it is computed when the file is read. **Measured before the interface, on the ten demo files.** Titanic: `pclass`/`class`, `embarked`/`embark_town`, `adult_male` read off `who`, and `survived`/`alive`, which is the leak and is flagged as one. Exactly the known truth, and **nothing on the nine other files**: an exact test on values seen at least five times on average produced no false twin, so no tolerance was added. `sex` and `who` are not flagged, rightly: neither determines the other, a child being of either sex. **What removing a twin changes**, titanic, ten seeds, eight families: mean accuracy 0.813 with the thirteen columns, 0.814 without `class`, `embark_town` and `adult_male`. No score moves. Removing `who` as well costs 0.9 point (5.5 for the naive Bayes): a column another is read off is not itself redundant. So this is about reading a model, not about its performance, and **the lab flags and leaves both in**: a redundancy is a note on the card, not an exclusion reason, and which one to keep is the user's call. **What it changes for counterfactuals** (V68), same rows, four families: with the thirteen columns, 296 of 695 first counterfactuals (43 %) changed one column of a pair alone; with the twins excluded, none could. A counterfactual that touches one twin without the other now says so, naming both. **Defect of this wave's own making, caught by the measure**: the first version read and trimmed every cell again for every pair, 34 s on a file of 200 columns and 100,000 rows. Each column is now read once into integer codes, on a sample of 20,000 rows, at most 80 columns: 1.2 s on the same file, the same pairs on every demo. **What this wave deliberately does not do**: exclude a twin or choose which to keep; see a fact carried by three columns together (`who` from `sex` and `age`, `alone` from `sibsp` and `parch`); measure an approximate redundancy (mutual information, VIF). 1344 unit tests, 135 e2e. | Approved 13/11/2026. A learner who trains here should be able to carry the run to a notebook and see, in figures, what changed on the way. |
+| **V71 — delivered** | **What stood in for a missing cell is counted.** G3. The encoder has always replaced a missing or unreadable number by the training median and a missing category by the most frequent one, and left a missing text with no word. It did so with no count anywhere. **Measured on the six demos**: titanic fills `deck` on 688 rows of 891 (77 %, by « C »), `age` on 177 (20 %, by 28.5), `embarked` and `embark_town` on 2; mpg fills `horsepower` on 6 rows of 398; the four others fill nothing. `deck` sits under the 95 % that sets a column aside, so it trained, three quarters of it a value nobody recorded, and neither the run, the report nor the model card said so. **What a mostly filled column is worth**, titanic, ten seeds, eight families, mean accuracy: 0.813 with `deck` as it is, 0.818 without it, 0.817 with `deck` recoded as known/unknown, 0.815 with « unknown » as a category of its own. Half a point at most, inside the noise: filling `deck` neither helps nor hurts, and the fact of being missing carries nothing here. **So the plan's « measured alert threshold » does not exist**: no score separates a harmless share from a harmful one. The mark kept is a reading rule and is called one: past one half, most of what the models read in the column is its fill value, and its importance is to be read as that of a mostly constant column. **What ships**: `countFilled` in `pipeline.ts`, empty cells apart from unreadable ones; the count travels with the run's summary, so with the saved run and the share link, where it is read through a validator that drops anything not shaped as the lab writes it; one sentence per column under the leaderboard, in the HTML report and in the model card, whose limits name the columns filled past one half; and the same count for a scored file, which is filled like the training rows were. Nothing about the filling changes and no figure of any run moves: every existing test passes untouched. **Defects of this wave's own making**: two of the new tests expected the wrong thing, and were right to fail: `n/a` is a marker of a missing value, so it counts as empty and not as unreadable, which the documentation now says; and on a tie the most frequent category is the first in alphabetical order. **What this wave deliberately does not do**: change how a cell is filled or offer other strategies (model-based imputation was refused twice); create a « was missing » column, which the measure did not justify; set aside a column because it is mostly filled; touch the Data Studio's recipe (G10). 1355 unit tests, 136 e2e. | Approved 13/11/2026. A learner who trains here should be able to carry the run to a notebook and see, in figures, what changed on the way. |
Proposed features, ranked by value over effort. Each reuses a module that
exists; none is scheduled.
F1 to F9 were delivered, or measured and closed, through V68. G1 to G10 come from a new
-reading of the repository after V68; G1 shipped as V69, G2 as V70.
+reading of the repository after V68; G1 shipped as V69, G2 as V70, G3 as V71.
| Feature | Content | Reuses |
| ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
-| G3 | **Say how many cells were filled.** A missing or unreadable number becomes the median, a missing category the most frequent one, with no count anywhere. On titanic `deck` is 77 % empty, under the `nearEmpty` cut, and three quarters of it are filled silently. A count per column in the run, the report and the model card; unreadable cells apart from empty ones. | `train/pipeline.ts`, `projects/model-card.ts` |
| G4 | **Rank on the quality of probabilities.** The leaderboard ranks on accuracy, F1, recall, precision, AUC, RMSE, MAE, R². Log loss is computed and shown and cannot rank; nor can Brier. The threshold, conformal and what-if panels all consume probabilities. It is the question V67 left open. Then: the calibration curve for every family, with an ECE. | `train/ranking.ts`, `train/threshold-analysis.ts` |
| G5 | **An honest forecast band.** The band is the 10th and 90th percentiles of one-step errors, applied flat to a horizon of up to 28 steps, on the hold-out that chose the method (the trap V57 measured). Errors per horizon step, a measured coverage, and a download of the forecast. | `timeseries/backtest.ts`, `timeseries/run.ts` |
| G6 | **Decisions travel with the export.** The export keeps the multiclass decision rule, not the binary threshold chosen nor the conformal quantile: the same model decides differently live and re-imported. | `train/serialize.ts`, `train/deserialize.ts` |
diff --git a/README.md b/README.md
index 9c4a252..aeaa5b1 100644
--- a/README.md
+++ b/README.md
@@ -93,6 +93,7 @@ The project follows three non-negotiable principles:
| Glass box | **One row, replayed through the model.** Beside the Shapley explanation (what weighed), a replay tells what happened: the questions a decision tree asked, in the units of the file, and the training rows that share its leaf; the count of a forest's 40 trees; the five rows of the file a k-NN compared it to, with its ties flagged; the prediction a boosting builds round after round, and its error on the validation rows. The replay walks the model itself: measured on 2,560 test rows of the demos, its last step is the model's answer on every one. The replay showed the boosting's validation error turning well before its last round; early stopping was then measured on rows kept away from everything and **not built**: fewer rounds improved the probabilities, not the predictions |
| Counterfactuals | **What would have to change.** For one row of a classification, the smallest change, one column or two, that makes the inspected model answer another class: only values the training rows hold, the columns the user locks left alone, free text never edited, and a plain « nothing found » with what was tried. Each change carries two readings the measure made necessary: whether the changed row still looks like a training row (8 to 60 % of the nearest changes did not), and how many of the other trained models follow it (14 to 54 % did). A counterfactual speaks of the model, not of the world |
| Twin columns | **Two columns that say the same thing are flagged, not removed.** As soon as a file is read, a column that maps one to one onto another (`class` and `pclass`), or can be read off another (`adult_male` off `who`), says so on its card. Twins split the importance between them and let a counterfactual change one without the other: on titanic 43 % of the first counterfactuals did. Removing them moves no score, so the lab leaves the choice to the user |
+| Filled cells | **What stood in for a missing cell is counted.** A missing number has always become the training median and a missing category the most frequent one, in silence. The run, the report, the model card and a scored file now say, per column, how many cells were empty, how many could not be read as a number, and what replaced them. On titanic `deck` is 77 % filled: past one half the run says the column is mostly its fill value. Keeping it, dropping it or recoding it moved no score, so the lab reports and leaves the choice to the user |
| Speed | Heavy families train on **helper cores** (announced on the leaderboard, split by measured cost, never silent), and a model crosses back as JSON so it is rebuilt through the same path an imported model uses. Measured on a 60 000-row run: **74 s → 9.5 s**, with every leaderboard number identical. Every best-effort step that gives up is recorded in a **run journal** shown with the leaderboard and in the report: which step, which family, how many times, and the error it met |
| Persistence | Local run history with attached artifacts, opted-in dataset storage (compressed, explicit 50 MB budget), self-contained HTML reports, data-free share links (a damaged link is refused, never half-rendered) |
| Model card | A page for whoever must **decide to use** the model, in HTML or Markdown: intended use, data, performance with its interval, the selection gap, prediction-set coverage, the decision rule, where it fails, the run journal, and limits. The intended use is typed by the user; left empty the card says « not stated » and calls itself incomplete rather than guessing. Every analysis the run does not carry is listed under « Not assessed », and each section names the model it describes when that is not the winner |
@@ -290,7 +291,7 @@ Wikimedia Commons), the portrait is NASA, public domain._
a doc page carries its whole article, in English until the app mounts); Lighthouse
mobile ≈ 0.99 on `/ml` under real throttling. Heavy dependencies (Dexie, SheetJS, ONNX
Runtime) load lazily.
-- **Quality bar.** 1344 unit tests and 135 Playwright end-to-end tests across five
+- **Quality bar.** 1355 unit tests and 136 Playwright end-to-end tests across five
projects — desktop, a phone viewport in English and in French, dark mode, and
Cloudflare Pages' own routing emulated by `wrangler pages dev` (a real 404, the security
headers as served) — covering offline PWA, a fake webcam, a horizontal-overflow guard on
@@ -411,8 +412,8 @@ that redoes a run outside the browser and measures its own gap (V64), a submissi
for a competition (V65), a step-by-step replay of one row through the model (V66), early
stopping for the boosting, measured and not built (V67), counterfactuals (V68), and a SQL
result that reaches the lab whole instead of its first 200 rows (V69), and twin columns
-flagged before training (V70). Proposed, none scheduled: eight items from a new reading of
-the repository, listed in PLAN.md (a count of filled cells, ranking on probabilities, an honest forecast band, and
+flagged before training (V70), and a count of the cells the lab fills in (V71). Proposed,
+none scheduled: seven items from a new reading of the repository, listed in PLAN.md (ranking on probabilities, an honest forecast band, and
others). The consented generative chat (V12) stays
postponed by product decision. No wave starts without an explicit launch command. The full plan, delivery log and design decisions live in
[PLAN.md](PLAN.md); [CHANGELOG.md](CHANGELOG.md) is extracted from it — one entry per
diff --git a/e2e/filled.spec.ts b/e2e/filled.spec.ts
new file mode 100644
index 0000000..f179041
--- /dev/null
+++ b/e2e/filled.spec.ts
@@ -0,0 +1,29 @@
+import { expect, test } from '@playwright/test';
+
+test.use({ locale: 'en-US' });
+test.setTimeout(120_000);
+
+// NOTE: keep this title ASCII-only: it names the test-results directory.
+test('titanic: the run says which cells it filled in, and how many', async ({ page }) => {
+ await page.goto('/ml?demo=titanic&target=survived');
+ await page.getByTestId('train-button').click();
+ await expect(page.getByTestId('train-again')).toBeVisible({ timeout: 90000 });
+
+ const notice = page.getByTestId('filled-notice').first();
+ await expect(notice).toContainText('Cells the lab filled in before training');
+ // deck is 77 % empty: kept, since under the 95 % that sets a column aside,
+ // and most of what the models read in it is its most frequent value.
+ const deck = notice.getByTestId('filled-deck');
+ await expect(deck).toHaveAttribute('data-mostly', 'true');
+ await expect(deck).toContainText('688 cells were empty of 891 (77 %). Filled with "C".');
+ const age = notice.getByTestId('filled-age');
+ await expect(age).toHaveAttribute('data-mostly', 'false');
+ await expect(age).toContainText('177 cells were empty of 891 (20 %)');
+
+ // Excluded, the column is no longer filled, and no longer counted.
+ await page.getByTestId('column-card-deck').getByRole('button', { name: 'Exclude' }).click();
+ await page.getByTestId('train-button').click();
+ await expect(page.getByTestId('train-again')).toBeVisible({ timeout: 90000 });
+ await expect(page.getByTestId('filled-deck')).toHaveCount(0);
+ await expect(page.getByTestId('filled-age').first()).toBeVisible();
+});
diff --git a/package-lock.json b/package-lock.json
index 9975dde..c0ca5b5 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "labml",
- "version": "1.70.0",
+ "version": "1.71.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "labml",
- "version": "1.70.0",
+ "version": "1.71.0",
"license": "MIT",
"dependencies": {
"@duckdb/duckdb-wasm": "1.28.0",
diff --git a/package.json b/package.json
index d850f31..1e4a4b0 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
{
"name": "labml",
"private": true,
- "version": "1.70.0",
+ "version": "1.71.0",
"license": "MIT",
"type": "module",
"engines": {
diff --git a/src/content/docs/en/limits.md b/src/content/docs/en/limits.md
index fd61ff1..4c21c76 100644
--- a/src/content/docs/en/limits.md
+++ b/src/content/docs/en/limits.md
@@ -69,6 +69,8 @@ They are not equivalent, and mixing them would be dishonest:
| Advice from a counterfactual | It says what would make the model answer otherwise, not what would change the outcome in the world: the model learned which values go together, not what causes what |
| A counterfactual of more than two columns, or one that edits free text | A change of five columns is no longer an explanation, and a sentence has no nearest neighbour to try. When the answer sits in the text, the search finds nothing and says so |
| Removing a twin column, or seeing a fact spread over three | Two columns that map one to one, or one read off another, are flagged on their cards (V70) and left in: which one to keep is your call, and removing them moves no score. A fact carried by three columns together (`who` from `sex` and `age`) is not seen, nor is a redundancy that is only approximate |
+| Another way to fill a missing cell, or a « was missing » column | The median and the most frequent category are the whole of it, and model-based imputation was refused twice. Since V71 the lab counts what it fills and says so; on titanic an indicator for `deck` changed no score, so none is created for you |
+| Setting aside a column that is mostly filled | Under 95 % of empty cells a column stays in. Past one half the run says the column is mostly its fill value, and leaves the decision to you |
| Counterfactuals for a regression, a re-imported model, or with the decision threshold | « Another class » has no meaning for a value; an export carries no training rows to draw observed values from; and the change found flips the prediction the what-if panel shows, not the decision of a chosen threshold |
| SQL reading a file the way the rest of the app does | The console hands the file to DuckDB's own reader: a decimal comma, a windows-1252 file or an Excel sheet are read by the app and not by SQL, which also always sees the original file, before the recipe and before a join. What leaves the console is complete since V69; what enters it is still DuckDB's reading |
| The recipe or the contract travelling with a SQL result | The ML Lab handoff carries the rows and a file name, nothing else |
diff --git a/src/content/docs/en/reference-ml.md b/src/content/docs/en/reference-ml.md
index 3b66107..2db8098 100644
--- a/src/content/docs/en/reference-ml.md
+++ b/src/content/docs/en/reference-ml.md
@@ -69,6 +69,25 @@ over the classes present in the true labels or in the predictions. A class
absent from both does not count as a zero; a class that is predicted but never
true does, because those predictions are all wrong.
+## What stands in for a missing cell
+
+A model cannot read an empty cell. Before training, a missing or unreadable
+number becomes the **median** of the training rows, a missing category the
+**most frequent** one, and a missing text is left with no word at all. The fill
+values are fitted on the training rows only.
+
+Since V71 this is counted. Under the leaderboard, in the report and in the model
+card, each filled column says how many cells were empty, how many held something
+that could not be read as a number (more often a reading problem than a gap),
+and what stood in for them. A scored file says the same for its own rows. The
+usual markers of a missing value (`NA`, `n/a`, and the like) count as empty.
+
+A column filled past **one half** is said to be mostly its fill value. That is a
+reading rule, not a threshold drawn from scores: on titanic, `deck` is 77 %
+empty, and keeping it, dropping it or recoding it as known/unknown gives 0.813,
+0.818 and 0.817 of mean accuracy over ten splits, which is noise. What changes
+is how to read its importance: it is that of a mostly constant column.
+
## The run journal
Some steps of a run are best-effort: the ensemble is optional, the helper
diff --git a/src/content/docs/en/score-a-batch.md b/src/content/docs/en/score-a-batch.md
index 78421e3..f486945 100644
--- a/src/content/docs/en/score-a-batch.md
+++ b/src/content/docs/en/score-a-batch.md
@@ -139,6 +139,13 @@ abstained row is a case to route to human review, not a model error.
With no rule attached to the model, these columns do not appear at all.
+## Cells filled in the scored file
+
+A scored file is filled the way the training rows were: a missing number takes
+the training median, a missing category the most frequent training one. The
+result says how many cells of each column that was, so a file that arrives half
+empty in a column the model relies on does not pass in silence.
+
## Labels never seen
If your batch contains a class absent from training, LabML still predicts it
diff --git a/src/content/docs/fr/limites.md b/src/content/docs/fr/limites.md
index c7ed8e5..5ae6a12 100644
--- a/src/content/docs/fr/limites.md
+++ b/src/content/docs/fr/limites.md
@@ -69,6 +69,8 @@ Elles ne se valent pas, et les mélanger serait malhonnête :
| Un conseil tiré d'un contrefactuel | Il dit ce qui ferait répondre autrement le modèle, pas ce qui changerait le résultat dans le monde : le modèle a appris quelles valeurs vont ensemble, pas ce qui cause quoi |
| Un contrefactuel de plus de deux colonnes, ou qui modifie du texte libre | Un changement de cinq colonnes n'est plus une explication, et une phrase n'a pas de plus proche voisine à essayer. Quand la réponse est dans le texte, la recherche ne trouve rien et le dit |
| Retirer une colonne jumelle, ou voir un fait réparti sur trois | Deux colonnes en correspondance un pour un, ou l'une déduite de l'autre, sont signalées sur leurs cartes (V70) et laissées en place : laquelle garder est votre choix, et les retirer ne déplace aucun score. Un fait porté par trois colonnes ensemble (`who` à partir de `sex` et `age`) n'est pas vu, pas plus qu'une redondance seulement approximative |
+| Une autre façon de remplir une cellule manquante, ou une colonne « était manquant » | La médiane et la catégorie la plus fréquente, c'est tout, et l'imputation par modèle a été refusée deux fois. Depuis V71 le labo compte ce qu'il remplit et le dit ; sur titanic un indicateur pour `deck` n'a changé aucun score, donc il n'en crée pas à votre place |
+| Écarter une colonne surtout remplie | Sous 95 % de cellules vides, une colonne reste. Au-delà de la moitié, le run dit que la colonne est surtout sa valeur de remplissage, et vous laisse décider |
| Des contrefactuels pour une régression, un modèle réimporté, ou avec le seuil de décision | « Une autre classe » n'a pas de sens pour une valeur ; un export ne porte pas de lignes d'entraînement où puiser des valeurs observées ; et le changement trouvé fait basculer la prédiction que montre le panneau « Et si… », pas la décision d'un seuil choisi |
| Le SQL qui lit un fichier comme le reste de l'application | La console confie le fichier au lecteur de DuckDB : une virgule décimale, un fichier windows-1252 ou une feuille Excel sont lus par l'application et pas par le SQL, qui voit en plus toujours le fichier d'origine, avant la recette et avant une jointure. Ce qui sort de la console est complet depuis V69 ; ce qui y entre reste la lecture de DuckDB |
| La recette ou le contrat qui voyagent avec un résultat SQL | L'envoi au ML Lab porte les lignes et un nom de fichier, rien d'autre |
diff --git a/src/content/docs/fr/reference-ml.md b/src/content/docs/fr/reference-ml.md
index 2d6900f..4d75674 100644
--- a/src/content/docs/fr/reference-ml.md
+++ b/src/content/docs/fr/reference-ml.md
@@ -75,6 +75,28 @@ prédictions. Une classe absente des deux ne compte pas comme un zéro ; une
classe prédite mais jamais vraie compte, parce que ces prédictions sont toutes
fausses.
+## Ce qui tient lieu d'une cellule manquante
+
+Un modèle ne sait pas lire une cellule vide. Avant l'entraînement, un nombre
+manquant ou illisible devient la **médiane** des lignes d'entraînement, une
+catégorie manquante la **plus fréquente**, et un texte manquant reste sans aucun
+mot. Les valeurs de remplissage sont ajustées sur les seules lignes
+d'entraînement.
+
+Depuis V71, c'est compté. Sous le classement, dans le rapport et dans la fiche de
+modèle, chaque colonne remplie dit combien de cellules étaient vides, combien
+contenaient quelque chose d'illisible comme nombre (plus souvent un problème de
+lecture qu'un trou), et ce qui les a remplacées. Un fichier scoré dit la même
+chose pour ses propres lignes. Les marqueurs habituels d'une valeur manquante
+(`NA`, `n/a` et semblables) comptent comme vides.
+
+Une colonne remplie à plus de **la moitié** est dite « surtout sa valeur de
+remplissage ». C'est une règle de lecture, pas un seuil tiré des scores : sur
+titanic, `deck` est vide à 77 %, et la garder, la retirer ou la recoder en
+connu/inconnu donne 0,813, 0,818 et 0,817 d'exactitude moyenne sur dix découpes,
+ce qui est du bruit. Ce qui change, c'est la lecture de son importance : celle
+d'une colonne presque constante.
+
## Le journal du run
Certaines étapes d'un run sont facultatives : l'ensemble est optionnel, les
diff --git a/src/content/docs/fr/scorer-un-lot.md b/src/content/docs/fr/scorer-un-lot.md
index bd0159e..8fb97ff 100644
--- a/src/content/docs/fr/scorer-un-lot.md
+++ b/src/content/docs/fr/scorer-un-lot.md
@@ -147,6 +147,14 @@ pas une erreur du modèle.
Sans règle attachée au modèle, ces colonnes n'apparaissent pas du tout.
+## Les cellules remplies dans le fichier scoré
+
+Un fichier scoré est rempli comme les lignes d'entraînement l'ont été : un nombre
+manquant prend la médiane d'entraînement, une catégorie manquante la plus
+fréquente à l'entraînement. Le résultat dit combien de cellules de chaque colonne
+cela représente : un fichier qui arrive à moitié vide dans une colonne dont le
+modèle dépend ne passe pas en silence.
+
## Les étiquettes jamais vues
Si votre lot contient une classe absente de l'entraînement, LabML la prédit
diff --git a/src/features/ml/components/BatchScorePanel.tsx b/src/features/ml/components/BatchScorePanel.tsx
index 2805120..7348c58 100644
--- a/src/features/ml/components/BatchScorePanel.tsx
+++ b/src/features/ml/components/BatchScorePanel.tsx
@@ -5,6 +5,7 @@ import { Badge } from '@/components/ui/badge';
import { Button } from '@/components/ui/button';
import { Eyebrow } from '@/components/ui/eyebrow';
import { SubmissionPanel } from '@/features/ml/components/SubmissionPanel';
+import { FilledNotice } from '@/features/ml/components/FilledNotice';
import { ProductionCheckView } from '@/features/ml/components/ProductionCheckView';
import { useLabStore } from '@/features/ml/lab-store';
import { METRIC_ROWS, metricDelta } from '@/features/ml/train/score-view';
@@ -194,6 +195,8 @@ export function BatchScorePanel() {
+
{t(`ml.lab.filled.title.${scope}`)}
+{t('ml.lab.filled.note')}
+