Changelog — 2.84–2.92

Releases 2.84.0 through 2.92.3. Current releases are on the main changelog, and every band is listed in the release archive.

Loading audio...

Version 2.92.3

August 7, 2026

We replaced a word in our editing tools that was precise to us and confusing to everyone else

  • The screen kept saying “narrow”. It is the exact word for what the control does, and it asks the reader to already know which direction that points. It now says what it means: a change can make material less quotable, never more.
  • The rule itself has not changed at all — only how it is described. Making something quotable is still a reviewed change to the code, not a setting anyone can flip.
  • Nothing to do at your end.

Version 2.92.2

August 7, 2026

Files uploaded to our library were being filed in the wrong place, and everything about it looked like it had worked

  • Our store of source texts is one shared collection, not one per environment. It holds thousands of files and several gigabytes, and both our live site and our test site read the same one — duplicating it would be wasteful, and separating it would leave the test site unable to see the material it exists to work with.
  • The new upload feature did not know that. It applied the naming rule every other store follows, and so wrote to a test-only copy that it created on the spot — empty, and read by nothing.
  • Every signal said it worked. The upload succeeded, the summary appeared, the report downloaded, and reading the file back returned exactly what had been written. It was correct about everything except where.
  • The fix removes the step that renamed it, rather than correcting the name. Passing the right name to something that rewrites it is not a fix. And it now refuses outright if the shared store is missing, instead of quietly making an empty stand-in.
  • Found by going and looking. No test caught it, and neither did the round of browser checking done immediately before.
  • Nothing to do at your end — this was caught before any of it reached you.

Version 2.92.1

August 7, 2026

Some buttons in our editing tools have been invisible in dark mode since July, and we only found out by looking

  • What was wrong. A button sitting on a panel was being given exactly the same background colour as the panel it sat on. In dark mode that made it disappear entirely — still there, still clickable, just impossible to see. It had been that way on one of our editing screens since it launched, and two new screens copied it.
  • Nothing was broken, which is why nobody noticed. Everything worked; you simply had to know where to click. That is the most durable kind of defect, because nothing ever complains about it.
  • The correct pattern already existed in the same section. Two other screens had it right all along. This was three files drifting away from a decision that had already been made, not a new decision.
  • Two smaller things, also only findable by looking. Three places where a space between words had silently vanished, so sentences ran together mid-word. And a message that said “one change…” and then referred to it as “they”.
  • Every automated check was passing the whole time. Types, sixteen hundred tests, our own rule checker — all green, all the way through. None of them can see a colour, or a missing space, and it is worth being honest that they never could.
  • So we also checked the things we had only ever tested in isolation. With the tools open in a browser, signed in, we confirmed that the safeguard stopping anyone loosening what may be quoted actually holds — including when the change is written straight into the database, going around the screen entirely. It is ignored, and the screen says so in red.
  • Nothing to do at your end.

Version 2.92.0

August 7, 2026

We can now add a new collection of texts from a file — and building it turned up a way that same process could have deleted one

  • What it does. Someone with the right access can upload a prepared file of passages, see exactly what would happen before anything is added, and then set it going. Adding a large collection takes tens of minutes, so it runs in the background: you can close the page, come back later, and see where it got to.
  • You see the plan before you commit to it. How many passages would be added, how many were skipped and for what reason, which languages, and how long passages would be divided into readable pieces. Nothing is written until you have read that and pressed the button.
  • 🔴 And here is what building it uncovered. When a collection is re-added, the system removes the old version of it — which is right, because otherwise the old passages would linger and could still be quoted. But that step identifies the collection by the name in the file. Once a person can upload a file, that name is whatever they typed. A file naming an existing collection would have replaced it entirely.
  • Nothing had gone wrong, and nothing in that step was badly written. It had always been correct, because until now the only names it could ever see were ones written into our own code. What changed was who gets to choose the name. We would rather say that plainly than describe it as a bug we fixed.
  • So there are two separate protections, and they fail in different circumstances. The first refuses any name belonging to a collection the system builds itself — and it works even against a completely empty database, which the second could not. The second refuses any name that already holds passages unless our own records show we put them there. Either one alone has a gap the other covers.
  • Checked twice, at two different moments. Once when the file is uploaded, and again immediately before anything is written — because you are meant to go away and think about the plan, and the answer could have changed while you did. A check whose answer can go stale between asking and acting is not really a check.
  • And if we cannot check, we refuse. If the library database is unreachable at the moment of upload, we cannot know whether that name is in use, so the upload is declined rather than risked. “We could not tell” must never quietly become “probably fine”.
  • Nothing uploaded can be quoted, and we say so three times. Uploaded material is recorded as unclassified, which is in neither of the lists that decide what published writing may draw on. It can be found and read; it cannot be cited. If a file claims otherwise, the claim is set aside and counted. We state this before the upload, on the plan, and in the result — because a safeguard nobody can see is one somebody eventually removes.
  • We give you the exact shape rather than code to copy. The example file is generated fresh from the live definitions each time it is downloaded, so it cannot teach a shape we no longer accept. And instead of instructions on cleaning your data, you get a downloadable report naming every row we could not read and why — produced by re-running the same check, so it can never describe something different from what would actually happen.
  • Stopping it partway leaves what was added in place. It does not undo anything — deleting on the way out would be a second destructive act at the exact moment someone is trying to make something stop. Run the same file again to finish.
  • Tested by breaking it on purpose. We removed the first protection to confirm the tests notice, and they caught that all eight of our existing collections would have become overwritable. We also removed the safeguard on quoting, and the tests caught ten ways material could have made itself quotable.
  • Nothing to do at your end — this is an editorial tool, and nothing about what is published today has changed.

Version 2.91.0

August 7, 2026

A new screen lets us correct what a library’s own filing says about a book — and it can only ever make the rules stricter, never looser

  • The problem it solves. A large seminary library files every one of its books under a single label, because that is whose library it is. That says nothing about any individual book: a seminary naturally holds other schools’ sources, because students study them. Roughly one book in six is from a different school than the collection’s own label suggests. Taking the label at face value would let material be quoted in our reflections as though it were something it is not.
  • So the library’s own categories are mapped by hand, once. The categories are clear and there are only a few dozen — “sources of exegesis”, “sources on the life of the Prophet”. A person reads each one and decides what kind of text it is and who it belongs to. That is a few dozen decisions instead of several thousand.
  • Those decisions can now be corrected from a screen. Previously changing one meant changing code and deploying. If a category turns out to be more mixed than it looked, someone can now narrow it in a minute and write down why.
  • 🔴 But only in one direction, and we made that impossible to get wrong rather than something to be careful about. The screen can make a category stricter. It cannot make anything quotable that the reviewed decision holds back. Widening what our published religious writing may draw on stays a reviewed change to the code, not a dropdown.
  • We had to build that guard twice, and it is worth saying why once was not enough. Refusing the change when someone clicks Save is the obvious protection, and it is only ever one bad row away from failing — a restore from backup, a future change, someone reaching the data directly. So the system also ignores any such value at the moment it reads it. The first is a courtesy that explains itself to a person; the second is the actual control.
  • And if a change is ever ignored, the screen says so in red. A setting that is saved, shown as saved, and quietly does nothing is worse than one that refuses outright, because you would have no reason to look again.
  • An earlier feature got this for free and this one could not. The filtering screen we shipped last week stores only exclusions, so there is nothing anyone can type into it that widens anything — the safety is in the shape of the data. That trick does not work here, because correcting a label and loosening a label look identical. We would rather explain that than pretend the two were built the same way.
  • 245 files with no category are one fault, not 245 decisions. Every one of them also arrived with its title’s letters in reverse order, no catalogue number and no author — the same extraction fault, on the same files, with the actual text intact. They get repaired automatically when they are added, because reversing a reversal is exact. Nobody has to sit and read 245 books.
  • There is an “ask for a suggestion” button, and it only ever suggests. A language model reads the category name and proposes an answer with its reasoning. Nothing is saved until a person agrees. If a suggestion would loosen the rules it is refused outright, and if nobody confirms it the material simply stays unquotable — so the way this fails is “something never appears”, never “something appears wrongly”.
  • We tested every possible answer, not the ones we thought of. Every reviewed category against every value the system knows — a few thousand combinations — checked to confirm none of them can loosen anything. Then we deliberately removed the guard to confirm the test goes red, and it caught 250 combinations that would have slipped through. A test that has never been seen to fail proves nothing.
  • Nothing to do at your end — this is an editorial tool, and the material it governs has not been added to the site yet. The screen says that plainly rather than looking like it is doing something.

Version 2.90.0

August 7, 2026

We have written down how we work with AI, and why we think a Muslim organisation should

  • Two new pages in the Help Centre. Working With AI explains the reasoning and what a person still decides; AI, Explained sets out in plain English what each part actually does — how a recording becomes text, how a passage gets found, why a synthetic voice needs help to read Arabic properly.
  • We work with it rather than use it, and that wording is the point. You use a hammer; you work with a colleague. What we build drafts, transcribes, searches and translates — and then a person takes over, corrects, rejects and decides. The output belongs to the person, because the person is the one answering for it.
  • The case is not ours alone. The pages quote Imam Sayyed Ali Khamenei and senior figures from the seminaries in Qom, whose position is notably not “this is permitted” but something stronger: that merely being a consumer of this technology is a failure, because the layers underneath belong to somebody else.
  • Which is why we run our own. The systems that draft, translate, transcribe, read aloud and search run on our own equipment, first, at no cost per use. Outside services are the fallback — and for some work, not permitted at all.
  • There is a person between the machine and you, everywhere. Nothing publishes itself. Overnight generation is off by default, so a day nobody writes for is simply blank. We would rather have a visible gap than something published unread.
  • We were careful about what we claimed. One thing we would have liked to say — that quoted references cannot be fabricated at all — is not written on those pages, because the mechanism that would make it true has not been built yet. It will be said when it is true and not before.
  • And careful about the quotations. We dropped three of them rather than publish them hedged: one appeared under two different years in our own source notes, one had no link, and one was sourced only to “various summits”. On a page whose entire purpose is credibility, a wrong date is the first thing a sceptical reader would catch.
  • The pages can be listened to, like the rest of the site.
  • Nothing to do at your end — but if you have ever wondered whether a reflection here was written by a machine, those pages are the honest answer.

Version 2.89.0

August 7, 2026

A reflection could be written and published overnight without anyone reading it first — that is now off by default, and we would rather have a blank day than an unread one

  • 🔴 We believed this only happened on our test system. It was happening everywhere. A job ran every midnight that would write and publish a reflection for the next day if nobody had scheduled one. It almost never fired, because the team is diligent about scheduling — which is exactly why nobody noticed it was there at all.
  • Nothing incorrect was published because of it. Reflections it produced were marked as automatically generated and went through the same checks as any other. The problem is not what it wrote; it is that “a person approves every reflection” and “a person approves every reflection unless we miss a day” are different promises, and only one of them was true.
  • It is now a switch, and it starts off. On means a missed day gets filled automatically, unread. Off means a missed day is simply blank. We have chosen blank as the default: a gap is visible the next morning and takes a minute to fix, whereas something published unread is only noticed if someone happens to read it.
  • If it cannot tell whether the switch is on, it treats it as off. A database hiccup should never be the reason something publishes without review. We wrote tests for that specifically, then deliberately broke the safeguard to confirm the tests catch it — a test that has never been seen to fail proves nothing.
  • Asking for one yourself still works exactly as before. The switch governs the unattended overnight job only. A person pressing the button has already supplied the judgement the switch exists to guarantee.
  • Separately: we removed a way for our library search to break on a deploy. The part of the system that searches our texts lives in a database our normal update process does not reach, so a change to the code could leave the two disagreeing — and every reflection and story would then fail to find anything at all.
  • We chose the version that cannot be forgotten. The alternative was to add a step to our release routine. Steps get skipped exactly when things are busy, and the cost of skipping this one is everything stopping. So the system now does it itself on start-up, and the release routine gets a check instead — a check cannot be forgotten into silence; it just goes red.
  • And it does the smallest possible thing. Rebuilding the search index on start-up would have hung the whole site for as long as that takes, and we already plan to remove that index temporarily during large imports. So start-up touches only the one piece that must match the code, and nothing else.
  • Proven rather than assumed. We deliberately put the old, mismatched version in place, confirmed the check went red, restarted, and confirmed it repaired itself and went green.
  • Nothing to do at your end — though if a day ever appears without a reflection, that is now a gap somebody needs to fill rather than something the machine will quietly cover.

Version 2.88.0

August 7, 2026

We can now tune what each kind of writing is allowed to draw on — and the safety change we made broke something, loudly, which is how we found it

  • Different kinds of writing want different material. A short reflection and an illustrated story are not served by the same passages: one of our largest sources is line-by-line commentary on a verse, which is exactly right for study and often wrong beside a story. There is now a way to say so, per kind of writing, rather than treating the whole library as one undifferentiated pile.
  • There are two ways to do it, and we measured which is safer before offering either. You can hold material back entirely, or you can rank it lower and let it compete. Both produce the same result when the search is going well. Only one of them is free.
  • Holding material back costs us choice; ranking it lower does not. On a real test, both removed the commentary from what the writing was given — but holding it back also shrank the pool of candidates by a quarter, while ranking it lower left the pool untouched. When a request is already finding little, that quarter is the difference between a thin choice and a broken one. So the page offers ranking first and explains why where the choice is made.
  • The settings can only ever narrow, never widen. Nothing on that page can grant access to material the citation rules do not already permit — not by misconfiguration, not by a mistake in the form. That is built into how the setting is stored rather than being a rule someone has to remember, because a safeguard that depends on remembering is not a safeguard.
  • 🔴 And a change we made specifically for safety destroyed something. Correcting how we replace a piece of database machinery, we added a step to remove the old version first. Written without saying where, it removed the live one instead of the copy inside the test. Every search stopped working.
  • What makes that worth telling you is that nothing caught it. Every test passed, the type checker passed, the whole suite passed, our own conventions checker passed. The tests only ever look at their own sandbox, and the damage was outside it. We found it by trying to use the feature.
  • The instruction we used had a “be quiet if it is not there” option, and we had used it. Its whole purpose is to say nothing when the thing is missing — which was precisely the case that needed to shout. A safety option, chosen deliberately, that guaranteed silence at the one moment silence was dangerous.
  • It is fixed, and the fix is proven rather than asserted. The removal is now confined to exactly one place. There is a test that recreates the original mistake in a sandbox, and we deliberately broke the fix to confirm that test goes red — a test that has never been seen to fail is not evidence of anything.
  • We also found a quieter fault the same way. An empty value was being read as “rank this as low as possible” rather than as “no setting”. Every version of that mistake pushed in the same direction — less material, never more — so it would have looked like a source that had simply stopped matching. Nothing would have errored.
  • Nothing you can see has changed, and no settings are in force. Everything above is a tool for us, and the defaults leave the library exactly as it was.
  • Nothing to do at your end.

Version 2.87.0

August 7, 2026

We built ourselves a window into what the writing is actually given — and the first thing it showed us was that we had been about to get something wrong

  • Until now, checking what our library offers a piece of writing meant running commands in a terminal. That is fine for the person who wrote the commands and useless for everyone else. There is now a page for it: what we hold, how each source is labelled, and how much of it our published writing is actually allowed to draw on.
  • The number that matters is not how much we hold. A source can be sitting there in full and still offer nothing, because material has to be labelled before anything may quote it — and anything unlabelled is deliberately left out. So the page leads with what is usable, not with the larger and more flattering figure.
  • You can now type a story idea and see exactly what would come back. Each passage with its source, what kind of text it is, how strongly it matched, and whether it arrives mid-thought without the part that precedes it. It runs the same search the writing itself uses — not a copy of it, which would only ever tell us about the copy.
  • 🔴 And it shows something no other screen could: how much there was to choose between. Our search gathers a shortlist and then a second step ranks it. If the shortlist comes back thin, that second step has little to work with and the ordering suffers — but the result still looks like a normal page of results. That gap is now on screen.
  • That turned out to matter more than we expected. We were about to let ourselves hold back one kind of material — sustained commentary, which is roughly two thirds of our largest source. We measured the cost first, expecting it to be high. It is not: for eleven of twelve real story ideas, holding it back costs the ranking step nothing at all.
  • The twelfth is the whole finding. The one idea that suffered was already the weakest — a vague prompt that found little to begin with. So filtering is free when the search is going well and harmful precisely when it is already struggling. Which means anyone testing a filter would try ideas they had thought about, see no harm, and be wrong.
  • We would rather report that than the tidy version. We predicted this would come out the other way. Publishing the prediction alongside the result is the only thing that makes the next prediction worth anything.
  • We also spent an hour chasing a fault that did not exist. A styling change looked as though it had not taken effect, and the tool we used to check was itself being fed an out-of-date copy — so it confidently reported a problem in something that was correct all along. It is a trap we have written down before, and we walked into it anyway, which is worth saying out loud.
  • Nothing you can see has changed. This is a tool for us, and the rest of it — adding new material through the browser rather than a terminal — is next.
  • Nothing to do at your end.

Version 2.86.1

August 7, 2026

Yesterday’s improvement quietly broke something else, and we would rather tell you than tidy it away

  • Dividing passages into readable pieces had an unintended effect on how we match a text to its original. We hold most of our material in two languages, and we divide each one according to the punctuation it actually carries — which means an English passage might become twelve pieces where its Arabic becomes eight. We were then treating “piece three” of one as the counterpart of “piece three” of the other. It usually is not.
  • It affected two thirds of the divided passages. The earlier version of this had the same flaw and affected about thirty of them, which is small enough to go unnoticed for a long time. Yesterday’s change made it the normal case — which is the only reason we found it.
  • Nothing incorrect reached anything you can read. The mismatched original was never part of what the writing was built from. But it would have become visible the moment we started showing passages alongside their original text, which is work already planned — so it is fixed now rather than discovered then.
  • The fix is to stop claiming a relationship we cannot verify. Where a passage has been divided, we now use only that piece’s own text rather than guessing at its counterpart. Nothing is lost from what gets quoted; we simply stop asserting something that is not reliably true.
  • We also started recording what KIND of passage each comparison offered. Some of our material is self-contained — a narration, a saying — while some is sustained commentary where the middle of an argument depends on what came before it. Knowing which is which lets a person’s judgement tell us something we cannot measure: whether a passage makes sense on its own.
  • And a measurement we deliberately did not trust. We can measure whether a passage is distinctive, and it told us these two kinds of material are identical. They are not — it was answering a different question from the one we asked. We would rather say that plainly than quote a number that sounds reassuring.
  • Nothing to do at your end.

Version 2.86.0

August 7, 2026

The passages we quote were being cut off mid-thought, and we had been measuring the damage on the wrong thing

  • Only the opening of each passage ever reached the writing. Everything past a few hundred characters was dropped — so a long commentary arrived as its first sentence and a bit, which is often the preamble rather than the point. We had put the figure at a quarter of the text being lost. Measured against what our search actually returns rather than against the library as a whole, it was closer to two thirds, because search naturally favours longer passages.
  • We fixed the split rather than the limit, and the difference matters. Simply showing more of each passage would have meant fewer passages, and we checked: every one of the eight we retrieve is carrying real relevance, so dropping any of them costs something. Instead each passage is now divided into pieces that are complete in themselves.
  • Both ends of “the right size” were measured rather than picked. Too long and it gets cut off; too short and it sits so close to the centre of everything that it matches every request weakly — which is exactly the fault that let a nonsense question score well earlier this month. The upper end turned out to be arithmetic we had been sitting on by accident, so a number that looked arbitrary for years was right all along.
  • How to divide a book is now worked out from the book itself. Not configured by us. It reads what punctuation and structure the text actually carries and chooses accordingly — and the answer genuinely differs between books, and between the two languages of the same book.
  • 🔴 And where a text cannot be divided cleanly, it is left alone and says so. Some of our source material carries no sentence marks at all — not a full stop, not a comma, not even a line break. Dividing that by counting characters would cut words in half, in scripture. So it is left whole, with a plain explanation of why, which is also what someone adding new material will be shown.
  • The result: passages now arrive complete nineteen times out of twenty, against roughly one in three before. The longest passages are a fifth of their previous length. Just as importantly, the number of passages that ended up too short did not go up — that was the real risk, and it did not happen.
  • What gets quoted is now drawn from six of our sources rather than dominated by one.
  • A setting we fixed last week turned out to have been fixed only some of the time. Roughly one connection in thirty still used the old value, at random. Nothing looked wrong: the other twenty-nine were fine, and the affected ones returned a full page of results with no error. A fault that happens every time gets found in a minute; one that happens three per cent of the time can hide indefinitely.
  • We also found our own comparison had been unfair, after we had already run it. When we asked a human which of two passages suited a story better, we were showing one of them cut short and the other in full — and the cut-short one still won or drew nineteen times out of twenty-two. Hiding which side is which does not make the two sides comparable, and we had only checked the first.
  • Nothing you can see has changed yet, and no published writing has been altered. The comparison that says whether this improved what gets quoted is next, and it is judged by a human. We will report it either way, including if we made things worse.
  • Nothing to do at your end.

Version 2.85.0

August 7, 2026

Our library search had been reading a fraction of what it was asked to, and had been for as long as it has existed

  • The second stage we described last time is now actually used when choosing what gets quoted. Until today it existed and was measured, but nothing called it. It reads the request and the passage together rather than comparing them at arm’s length, and on our own material it roughly doubled how often the best passage came out on top.
  • What you ask it matters far more than we expected. Given no explicit instruction it silently assumes it is answering a search query — so when we handed it the premise of a story, it judged the passage on whether it answered that premise. Nothing answers a premise. Correcting the question we were asking changed one real score by a factor of sixty, with no other change at all.
  • So the question is now chosen to match what is being asked. A ruling needs a passage that settles it; a story needs one that resonates alongside it. We measured that a wording excellent for the first is actively worse for the second — correctly so — which means there is no single wording that serves both.
  • 🔴 And then the real finding: our search index was only ever considering a small fraction of the candidates it was asked for. A default setting we had never touched capped it. Everything above that cap looked entirely healthy — a full page of results, no error, and an apparent cut-off that seemed to explain it. Lifting the cap costs about a hundredth of a second and gives the ranking around five times as much to work with.
  • The tell was that the results were identical whether we set the quality bar high or removed it entirely. That should be impossible, and it is the only reason we found it. It had survived rebuilding the library, rebuilding the index and replacing the component that does the comparing, because nothing anywhere reports it.
  • It also meant a change made earlier the same day had quietly done nothing. We widened how many candidates the ranking stage should see; the cap sat underneath and ignored it.
  • We caught one more thing before it shipped, which would have made all of the above pointless. A single line further downstream re-sorted the results back into their original order, undoing the ranking entirely — on the only version of the list that actually reaches the writing. Every log, count and indicator would have gone on reporting that the new stage was working perfectly. It was, in every place except the one that counts.
  • We had also measured how much text fits in one go using a single book, and assumed it held for the whole library. It does not. Qur’anic Arabic, with its vowel markings, takes more than twice the room of the commentaries we measured on — so a limit set from one was wrong for the other. Re-measured properly across every book, which also fixes the last passage that had failed to process.
  • Nothing on the site has changed yet, and no published writing has been altered. The blind comparison that tells us whether any of this improved what gets quoted is next, and it is judged by a human. We will report it either way, including if we made things worse.
  • Nothing to do at your end.

Version 2.84.0

August 6, 2026

We replaced the part that decides which passages are relevant — and found our own status page had been describing the wrong arrangement for days

  • The component that turns writing into something a computer can compare has been replaced. The previous one was built principally for European languages. Persian was never among the languages it was properly trained on, and Arabic — which most of our library is written in — it handled least well of all. We had been relying on it anyway. The replacement is markedly stronger at both.
  • We tested it on our own material rather than on published rankings. Those rankings are built from text that looks nothing like classical religious prose, so a high placing on one tells us very little. We used real passages from our own library — and wrote down the standard the replacement had to meet before running anything, so the result could not be read to suit whichever answer was more appealing on the day.
  • The test was whether it could find the English of a passage given only its Arabic. It manages that about half the time from a field of three hundred candidates. Then we deliberately paired them wrongly, and it fell away to almost nothing. That second half is what makes the first half mean anything — a test that cannot fail is not a test, and we have been caught by exactly that before.
  • We also added a second stage that reads the question and the passage together rather than comparing them at arm’s length. Asked about patience in hardship, it separated the passages that were genuinely about patience from those that were not by a factor of more than a hundred. The first stage, for comparison, has been known to rate outright gibberish nearly as highly as a real answer — which is why the ordering of results, rather than the finding of them, was the thing that needed fixing.
  • Our own status page had been reporting this work as running somewhere it was not. It worked out where to look from a setting that is deliberately never filled in, so it went on describing the previous arrangement, and the part actually doing the work appeared nowhere at all. Nothing failed; it simply told us something untrue every time we looked.
  • The reason that slipped through is worth more than the fix. That check was written to avoid an indicator sitting permanently red for something not yet built — a sound precaution at the time, which quietly stopped being true. It produced a permanently missing indicator instead, which is the same blind spot wearing a quieter coat. It now asks the one part of the system that actually knows the answer, rather than working it out a second time and getting a different result.
  • The instructions for rebuilding all of this from nothing are now written down, together with each failure we hit getting here and what it actually meant. Several of them looked convincingly like faults somewhere else entirely, and that is precisely the sort of thing that costs a day when nobody wrote it down.
  • Rebuilding the searchable library then found a fault in our own tooling — and it was only visible because the new component complains. A handful of passages were too long for it to read. It said so plainly, which the previous one never did. But our code treated one rejected passage as though the whole group of two hundred and fifty-six had failed, so a single oversized item quietly took hundreds of perfectly good ones with it.
  • That fault was always there; it simply could not happen before. The old component silently shortened anything too long rather than refusing it, so the request always appeared to succeed and the mistake never surfaced. Trading a silent failure for a loud one is worth doing precisely because it turns up things like this — but it does mean every place we handle a refusal now needs reading again with fresh eyes.
  • Nothing has changed on the site yet, and no published writing has been altered. The library has been rebuilt, and the next step is the blind comparison that tells us whether any of this actually improved what gets quoted. We will report it either way, including if it did not.
  • Nothing to do at your end.