What changed in LEF SI Engine's core, and why: how it reads records and judges what it finds. Each build carries its own copy of the engine, so a change reaches a build when that build is regenerated or the idea is carried over and proven again.
The engine can now prepare a source's records for reading from a written plan, without changing a single value, and it tests that promise on every run.
Each gap now says whether the source's own documentation, the records, or both explain it, and names a rule the records keep that the documentation never states.
The engine now reports a source's documentation against its records rule by rule: what agrees, what the records contradict, what is documented but never used, and what is written differently, with counts. A documented missing code changes nothing until the dataset's steward accepts it.
Each read's documentation checks now start fresh, and the shape check states exactly what its chance correction covers. What the engine finds is unchanged.
The engine's default Claude model is now Claude Opus 5.5; what the engine itself reads and computes is unchanged.
Rules about a source are now checked against its records as written, a few stray dates no longer make a short file look long enough to judge over time, and the date a record was last edited is never mistaken for the date of what it describes.
The engine now takes a source's own definitions of its categories, quoted from the source's documentation, and checks every record against them; and each finding's page shows whose rule set it aside or explains it.
A rule the engine is given about a source now says who it rests on: the source itself, another authority, or a named person can set a finding aside, and the page says which; a rule only LEF believes can explain a finding but never remove it; and where a source's own documentation and its records disagree, the engine says so.
The engine now finds a stretch of a measurement that holds far fewer records than the records on both sides predict, not only a stretch that holds none, and a few extreme values no longer hide one.
A measurement is no longer read as a date because of its column's name, several reads at one place no longer overwrite each other's records, a dataset's history is compared only with its own earlier runs, and the pages a person reads no longer show anyone's email address or ORCID iD.
A rule the engine confirms now says whether a second, different source keeps it, or only files from the same source, since files from one source can share how that source keeps its records.
A record filed twice under one identifier, told differently the second time, can no longer hide a gap the rest of the records show, while records that only share a name are still read as distinct.
A licensed build can now tell its licensee, from its own runs and without contacting LEF, which published revisions may answer what its runs keep hitting, and which of its needs are its own.
Rules the records keep can now be confirmed across files of the same source, and only by files whose records are genuinely separate, so a sample of a file never confirms that file's own rules.
A date written as a number is now read as a date in every part of the report, so the report no longer says a file has no dates while reading it by date.
A codebook supplied for a source can now state which values it never writes together, each rule cited to the source; a gap such a rule covers is set aside on the source's word, and the report says how many.
No record is left out of the read because it shares a name or a number with another record; each one is read.
A build's findings are now checked against its engine's own read, and a gap the engine ruled out cannot be presented as standing.
Each run's report now names the model behind every piece of prose it checked, and says when a piece names none.
A single stray value far from the rest no longer makes the engine report an empty range in a measurement.
A field that holds codes or identifiers written as numbers, such as a ZIP code or an award ID, is now kept as written and is never read as a measurement, so a missing region can no longer show up as a gap in one.
When a file covers too short a time to be cut by date, the engine's report now says that, and which field it read, instead of saying the file has no dates.
The engine now reads numeric measurements for gaps, not only categories, and tells a gap from the edge of the data.
The engine no longer dismisses a real gap because two fields are strongly associated; it keeps the gap and names the pattern it rests on.
With no record IDs, the engine no longer reports conflicting IDs between sources.
When records name their source in more than one field the engine checks each for copies, and with no record IDs it no longer mistakes look-alike records for copies.
When the engine cannot cut a body of records into periods, it now gives the true reason.
The engine now reads how a body of records keeps itself over time, which fields stopped or started being filled and which recording channels changed, so a reader knows when a count across years rests on a record that changed.
A person can now state that a ranking or classification should separate an outcome, and the engine checks it step by step, saying where it separates, where it reverses and where it does not.
Tracing each gap forward is now about ninety times faster on wide corpora, with exactly the same results.
The engine now finds gaps among three values, where every pair meets but the three never do together; in this version each is reported as a lead.
When a pairing appears or disappears between periods, the engine now says when the same holders are still there with a code switched: a change in how records are coded, not in who holds them.
When two fields carry the same information, such as a country code and a country name, a gap found through both is now counted once.
A word in a column of numbers is no longer read as missing unless it says so: in a rule table, 'None' can be the rule.
The engine no longer treats words like 'NA', 'None' or 'Unknown' as missing by default: what a code means belongs to the source that wrote it, and a codebook for that source can say so, field by field.
The engine now checks the claims a person states about a body of records, saying for each whether the records support it, contradict it or cannot tell, and how far each is from flipping.
Every run's report now says plainly what no check on its records can see: a gap hidden without any trace takes a second source to find.
When the engine says a pairing opened or closed between periods, it now holds that to the same standard as its gaps; one or two records are reported as too thin to tell.
Every run now checks that the same records and settings give the same result, and compares a later run on the same file with earlier ones.
Two runs of one build started within the same second each keep their own record; the second no longer fails at its end.
Every report now answers whether the read was widened, and a build with no source to widen through says so.
On the engine's own page, each fill proposal now says whether its gap held, became a lead, or was refuted.
A read can now be handed a library of patterns that went with gaps closing or staying empty, and names which each gap carries, withholding a pattern's strength where the records are unlike those it was tested on. A signal says more often, never this one will.
When the engine checks a gap against a whole index, each count now carries the date and time it was asked, so a figure says which reading of a changing index it came from.
For each gap it holds, the engine now also says whether the gap is weakly or firmly held apart right now.
The engine now reads fields that hold long lists of labels and says how much of each it read, where before it read none, and it no longer draws a conclusion from too few gaps.
The engine now says, for each gap, what keeps the two sides apart: the way the records are kept, or the content itself.
The engine can now widen its own read through the source a build declares, read again, and say which gaps ended, opened or held.
The engine can now read several sources together, joining what they share, and compose several reads into one picture, saying plainly when those reads draw on the same corpus and so are not independent confirmations.
The engine now remembers its findings between runs: each gap says whether it is new, recurring or shifted, and each run lists what the last one reported and it no longer does. The memory is context for the reader, never evidence.
The engine now checks the associations it reports as it checks its gaps: one resting on a handful of records, two blanks travelling together, or one association counted twice is marked as such.
A combination the records should hold plenty of, held by only one, two or three holders, is now listed for a person, which is where a supply or coverage risk sits. In a sample, each is counted in the whole source first.
Every gap now carries a pursuit a person can weigh: whether it can be bridged, whether it can be filled, or neither, with the case for and against, what would refute it, and the next step that would settle the most. The engine does not decide what to pursue; the person does.
The engine no longer mistakes a column of codes, such as supplier codes, for a column of numbers, and still flags a real number column that holds a stray word.
A gap's trace now offers only directions its records can support, and never offers a date as a direction.
Every gap now carries its parts, so a reader can check it rather than take it on trust: what it is, how it was counted, why it is there where the records show a reason, what would change it, and a trace to follow.
The engine now lists two more kinds of record for a person to read: one that breaks a pattern the records around it keep, and one record carried under two identifiers. Both are listed, never used to doubt a finding.
When a source the engine counts in stops answering, the engine stops asking it, and the report says how many gaps went unasked and why.
A corpus can now be declared a sample of something larger. A gap found only in the sample is then read as a lead, and where a build can count in the whole source, each gap is counted there and the report says what the whole said.
Where a corpus carries dates, the engine now asks whether each gap's two values ever existed in the same period, and lists pairs that met earlier and stopped meeting. Every gap now names its cause where the records show one, and says the records cannot tell where they do not.
The engine now profiles a corpus itself, and the check a build goes through before it meets a partner's records is the engine's own read of a corpus shaped like theirs, saying which checks that shape lets it answer.
The check of the engine's earlier gaps against what came after now reports by the pair of fields each gap lies between, because what a later fill means depends on what those fields record.
Every run's report now names the model that answered, as the provider named it. A date that cannot exist on a calendar is kept as written instead of being turned into one that looks valid. The engine's own test runs to its end again.
Every check now reads a field that holds a list, such as a work's topics, as the values in it, and two values of one list field can now form a gap. Files with no list field read as before. A field that mixes numbers and words no longer stops the read.
Where the records carry dates, every run now checks its own method against their past, grading the gaps it would have named earlier by what came after. It grades the method on the corpus's own history; it is not a forecast.
When a gap is too rare to tell from coincidence, the report now says so and calls it a lead, without overstating it.
Fields with thousands of values are now read instead of skipped. A gap that restates a stronger regularity in the same records now says so, and is never thrown out on its account.
The engine now traces each gap it holds: what keeps the two sides apart, what a record filling it would have to carry, and whether any record consistent with the file could fill it at all. A gap that rests on another gap says so.
One value written several ways is now read as one value where one spelling clearly dominates, and the correction is stated. A 'not collected' phrase in any spelling is read as missing in a number or date column, and a few stray records no longer become a finding. On clean records the results are unchanged.
The engine now judges every candidate gap on a wide file and says whenever a limit still applies. It no longer takes a row number for a record's identity, it reads a copy filed under a second source as one record carried twice, and padding a file with copies no longer changes its answer.
Values that only look alike in writing are no longer merged, look-alike identifiers no longer drop records, the same records now give the same findings in the same order on every run, and one count no longer stalls on very large files.
Every run now carries a report of its own checks: each says it found something, found nothing, corrected something (and what), or could not run (and why). A check that stays silent is a gap in the report, never a pass. Each finding states its standing in plain words, with what would change it, and what a model writes is checked against what it was shown.