Case 1/1852: the generator that reported success

🕵️ Show the full case file → 📋 Session protocol →

Case file · Code Homicide Dept.

I changed a sentence in the source, regenerated the projection as the protocol demands, and the home page came up empty: headings with no text, buttons with no text, cards with no text. Boxes with geometry and no words. The generator had finished with exit code 0 and printed "spine generated" to the console. It did not lie about what it did: it wrote the file, and the file carried the new sentence, correctly, on line 2. What nobody checked — neither it nor I — was line 31, where it repeated a key it had already written on line 30. Fluent does not forgive that: it does not pick one, it does not ignore the other. It drops the resource. And the resource, in this framework, is all forty-two files of the language concatenated into one.

The double ledger — what it cost, and what it left

The figures on the left are the body. The one on the right is the lesson. And it is worth facing the proportion that presides over this case file: one key, one thousand eight hundred and fifty-two lost. This is not an error proportional to its cause. It is a fuse wired backwards: the smallest component in the system holds the authority to switch the whole thing off, and until today nothing stopped it exercising that authority.

The point of abandonment — what the table doesn't show

The point of abandonment was not at the end, it was at the beginning, and I walked straight past it. When the first regeneration finished, I did what looked rigorous: I opened the .ftl and checked the new sentence was there, correct. It was. spine-hero = Pisa firme, con paso ligero., line 2, exactly as asked. I called the step done and moved on. I verified the file, not the page — and this series’ own howto has it written, in capitals, from another case that cost plenty: “count the RENDERED CARD, not a number in the HTML; a check that measures a proxy for the capability is a check that can be green while the page is wrong”. It was in front of me. I did not read it, because I did not ask: I took an example file, inferred the shape, and got to work. The check that would have saved me cost one curl.

The suspects — the false leads

The weapon — gen-spine-pages.nu — a key that names the door, a loop that walks the hooks, 86 lines between them

# gen-spine-pages.nu — line 93. The door's landing page:

  let hook = ($spine.evidence_hooks | where {|h| $h.door == $d.key })
  let h = ($hook | first)          # ← one door, one hook. Disambiguated.

# ... 86 lines further down. The .ftl emission:

  let hook_keys = (
    $spine.evidence_hooks
    | each {|h| $"spine-hook-($h.door) = ($hl)" }   # ← iterates by HOOK
    | str join "\n"                                  #   names by DOOR
  )

# spine.ncl declares TWO hooks with door = "developer".
# The same list. The same file. Two incompatible readings.
#
# `spine-hero = Pisa firme, con paso ligero.`   ← line 2, correct
# `spine-hook-developer = ...`                   ← line 30
# `spine-hook-developer = ...`                   ← line 31, and the language is dead

And the weapon had been loaded for months with nobody touching it. The .ftl on disk was generated when only ONE hook existed; the second landed later and the file was never regenerated. The bomb was armed, waiting for the generator’s next run — which turned out to be mine, for changing a sentence. I did not create this bug. I woke it. And that is the nastiest property of a generated artifact nobody regenerates: it is not stable, it is expiring quietly, and whoever walks past next wears it.

The turn — Group by what the key names — and give the generator the exit gate it never had

# 1. The key names the DOOR, so group by door. First-wins: exactly the rule
#    the landing page was applying 86 lines above.

  | group-by door
  | items {|door, hs| let h = ($hs | first); $"spine-hook-($door) = ..." }

# 2. And the lock, which is the only thing that stops this happening AGAIN:
#    the generator validates what it is about to write, BEFORE writing it.

  let dup = ($ftl | lines | ... | where n > 1 | get key)
  if ($dup | is-not-empty) {
    error make { msg: $"home_spine.ftl [($lang)] would carry duplicate Fluent keys —
      the resource would be dropped whole, blanking the page: ($dup)" }
  }
  $ftl | save -f $target     # ← garbage no longer reaches this line

# The contract no longer ends where the text begins.

The lock was falsified before being trusted: a duplicate was injected and it caught it. It is a small proof and it is the only one that matters, because the lesson of this case file is precisely that an unchecked mechanism is an intention. It would have been perfectly coherent to write the lock, watch it pass green over a healthy file, and ship it — which is exactly what the broken detector in case 0/318 does.

The verdict

The series asks: with ontoref, would it not have gone like this? And this case answers with a discomfort unlike the earlier ones, because here the protocol did not fail by absence: it failed at a frontier. Everything this project declares is typed, contracted and rejected the instant it is defined. nickel export will not pass a malformed record; the schema of the very case file you are reading rejects a case with a missing field; contracts fail at definition, not at runtime — and that is written, literally, on the architecture diagram on the home page. All true. And all of it stops exactly where a script takes that impeccable data and writes it out as text. Past that point there is no contract, no type, no gate: there is a string, a save -f, and an exit 0. Projection is the site’s central practice — drift is fixed by re-running the generator, never by editing the served copy — and that practice rests entirely on trusting that the generator produces something valid. Nobody was checking. What makes this a case and not an anecdote is that the failure was neither silent nor gradual: it detonated. One repeated key, in a file of twenty-nine, inside a language of one thousand eight hundred and fifty-two, and the home page lost every word. It did not degrade. It did not lose the hero. It did not show the key in brackets, the way the eighteen broken titles we found that same afternoon did. It went dark. And the process that switched it off finished cleanly, reported success, and returned zero — because nothing had ever told it what failing meant.

Case law — what enforces the lesson today

• ✓
  The page is the publication: the witness asks what a reader would askadr:072/the-page-is-the-publication
• ✓
  A gate measures the capability, not a proxy — the file was the page's proxyadr:072/a-check-measures-the-capability-not-a-proxy

⊘Declared debt: The frontier stays open where data becomes text: whatever is written past it is published on someone's word. A contract over the EMITTED artifact — a schema for the generated resource — would settle it, not one over its source alone.

One thing remains to be said, and it is what places this case file alongside the others from that afternoon. In the same session there appeared: a diagram whose own footer claimed to be a live projection while its figures were typed by hand; eighteen routes serving a broken key’s name as their <title>, under a publishing contract that declared “witnessed 0 brackets”; and the largest Spanish surface on the site, one hundred and fifty-five files, outside every policy. All three are the same defect as this case, in its slow version: an artifact that asserts something about itself and nobody asks it for proof. The difference is that those drifted quietly for months and this one detonated in a second. And that is why this is the one that gets published: because silent drift can be argued with, and a blank home page argues with nobody.