Case 8/0: the cure that never went home

🩺 Show the full clinical history → 📋 Session protocol →

Clinical history · Software Pathology Service

Eight lines closed the case that opened this series. They exist: written, proven, and serving this very page right now. And they have reached nowhere — not the commit of their own instance, where someone kept adding kinds BY HAND, one at a time, up to seven, with the cure already written in the file next door; nor the two templates every new site is born from, which are exactly as they were. The patient was cured and the prescription was not. And when the prescription was finally seen to, the architect — with «empirical proof» — recommended deleting the shortcut. It would have broken six of eight routes. Answering 200.

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

The figures on the left have an easy reading and a hard one. The easy one is the 4, the 7, the 69. The hard one is the zero — «constraints run today by a recipe or CI: 0» — because that zero does not measure a defect: it measures how many of this project’s rules have ever had the chance to say no.

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

The point of abandonment was not a temptation: it was a recommendation, signed, with proof. This case’s architect — the one who wrote the plan, drafted the rules, published the case file about measuring the box next door — said: «the shortcut adds no capability, delete it», and called it empirical proof. They had read the template’s code and curled the instance: two different trees, a demonstration built astride both. Had it been executed, six of eight routes would have lost their grid answering 200 — the failure no smoke test sees. The architect did not stop it. Neither their experience, nor their care, nor having spent the whole day publishing precisely this lesson. What stopped it was one sentence in the task: «curl these eight routes, in both languages, before and after, pasted, not narrated». That is all it took, and it is all there was. The gate caught the architect — and that, not the fix, is the only reason this case file is written in the past tense.

Differential diagnosis — what was ruled out

Etiology — the cause — shell/htmx.rs — the hand-written list, and how it grew while the cure watched

// templates/website-htmx-ssr/crates/server/src/shell/htmx.rs:423
// (identical in website-leptos/.../shell/htmx.rs:275)

let kind = match base {
    "blog" => Some("blog"),
    "projects" | "proyectos" => Some("projects"),
    "recipes" | "recetas" => Some("recipes"),
    "activities" | "actividades" => Some("activities"),
    _ => None,
};

// And in the instance's HEAD — with the cure already written, uncommitted,
// in its own working tree — the same pattern, grown BY HAND:

let kind = match base {
    "blog" => Some("blog"),
    "projects" | "proyectos" => Some("projects"),
    "domains" | "dominios" => Some("domains"),      // ← by hand
    "recipes" | "recetas" => Some("recipes"),
    "activities" | "actividades" => Some("activities"),
    "catalog" => Some("catalog"),                    // ← by hand
    "adr" => Some("adr"),                            // ← by hand
    _ => None,
};

And it was not two places, but three: htmx_pages.rs:105 has its own list, in its own shape. Nobody looked for it because nobody had a rule that looks — which is exactly what this case is about.

Treatment — A backport that was not designed, and the rule that finally bites

# The fix was not designed: IT ALREADY EXISTED, deployed, serving.
# Verbatim backport from the instance → both templates.

fn render_content_or_grid(path: &str, language: &str) -> String {
    use rustelo_core_lib::routing::config::load_routes_config;
    let base = /* first segment of the path */;
    // PAP: resolve the URL's first segment → content kind from the routes
    // registry (site/config/routes.ncl), NOT a hardcoded list. A new content
    // kind works with NCL config alone — no code change here.
    let kind: Option<String> = load_routes_config().routes.iter().find_map(|r| {
        if !r.enabled { return None; }
        let seg = r.path.trim_start_matches('/').split('/').next().unwrap_or("");
        (seg == base).then(|| r.content_type.clone()).flatten()
    });

# And the rule, enforceable at last — SEEN TO FAIL before anything was fixed:

  adr-002 · hardcoded-kind-list-shadows-registry · 'Hard
    → 9 hits against today's tree. After the backport: 3.

And the constraint was SEEN TO FAIL before anything was fixed: nine hits, must_be_empty = true. After the backport, three — the third list’s, which stay because they are not this decision’s. A rule only ever seen to pass is not a rule: it is a hope with syntax.

Prognosis

The mechanism was not missing: there was a surplus of it. config-driven-architecture is marked invariant in rustelo’s ontology. ADR-002 says, in letter, «without any hardcoded match arms». And there is more: the exact answer to the question that nearly broke the site — is that match redundant — had been written since 13 July in the project’s queryable knowledge: «the match arms are an optimisation, not the source of truth». It was all there. Written, accepted, dated, queryable. And the defect lived for months, grew to seven hand-written kinds in the very tree that already had the cure, spread into two templates and a third list nobody knew existed. Because between a rule that is written and a rule that bites there is exactly one thing, and it is not the rule’s quality: it is something that executes it. Twenty-three constraints. Eight ADRs. Zero recipes. Zero CI. Case 0/318’s validator at least existed and died on the first file; here not even that — here the rules are perfectly healthy and perfectly silent. And the finish, which is what makes this case unlike every earlier one: the lesson was also written, in a howto, and prevented nothing either — because a howto is read, not executed. Whoever recommended deleting the shortcut never queried it. They could not: nothing obliged them, and nothing told them it was there.

The regimen — the session, replayed with protocol

What was asked — reconstructed from .coder/2026-07-16-2a-rustelo-reparacion.done.md · transcript of the rustelo session

render_content_or_grid re-lists 4 kinds by hand in both templates
(templates/website-htmx-ssr and website-leptos, shell/htmx.rs), shadowing the registry.
ADR-002 already forbids it but its check points at crates/foundation/, where the defect
is not. […] 2. Ask me BEFORE choosing between deleting the shortcut or deriving it from
config: that is my decision, not yours. […] 4. No-regression witness: curl /blog,
/proyectos, /recetas, /actividades in both languages, before and after. Pasted, not narrated.

What should have been asked

Before claiming that something does not exist, DECLARE THE SCOPE of your search and check
it against every tree in the constellation, not just the repo you are running from. If the
task's evidence does not show up, the default hypothesis is that you are looking at the
wrong tree — not that the task is wrong.

And before proposing to delete anything: consult the declared way (`ontoref qa show`), not
the code. The answer to whether that match is redundant IS ALREADY WRITTEN, and it is not
the one you deduce by reading the file.

The gate before delegating: The witness is defined FIRST, and defined over the real surface: «curl these eight routes, in both languages, before and after, pasted». That sentence — and only that sentence — is what prevented the disaster: the architect had recommended deleting the shortcut with an «empirical proof» built across two different trees, and the witness refuted it before it cost anything. The gate caught the architect.

The ADR trigger: The ADR-002 amendment suffices and is done: the registry-vs-list decision was taken and deployed in the instance; here it was only backported, so criterion 1 fails. The one that DOES ask for an ADR is another and is undecided: whether templates/ is product to be versioned or generated scaffolding. Proposed, not created.

Prophylaxis — what enforces the lesson today

• ✓
  The hand-written list that shadows the registry is forbidden by a typed constraint, seen to fail before anything was fixedadr:002/hardcoded-kind-list-shadows-registry
• ✓
  The shortcut, backported: the registry resolves the kind in both templatescontract:templates/*/crates/server/src/shell/htmx.rs#render_content_or_grid
• ✓
  That match arms are an optimisation and not the source of truth, queryable instead of rediscoverableqa:rustelo-static-page-howto

⊘Declared debt: Nothing runs the new constraint: the recipe that runs all 23 and reports per constraint is unwritten — and without it, this rots again exactly the same way. A just recipe in rustelo's chain would settle it, kept out of check-strict until the 11 real hits are triaged. And four remain ownerless: the third list in htmx_pages.rs (3 hits), the 11 real hits of no-hardcoded-route-paths, templates/ unversioned — the gravest, and no ADR says whether it is policy or oversight — and an instance ↔ template drift-check, which has neither mechanism nor owner.

Discharge and prophylaxis

The discharge is signed with two uncomfortable facts and one good one. The first: the constraint, freshly written, found three places with the hand-written list — and only two were in the task. The rule, the moment it could run, saw before the one who wrote it did. The second: the htmx-ssr profile had never compiled — eight errors from a migration the framework did and the template did not — and nobody knew, because nothing builds it; it surfaced only because a real site was needed for the witness. And the good one: none of this was decided blind. The witness was demanded first, it ran, and it refuted the one who demanded it. A wired contract does not tire or get distracted; but before that, someone has to wire it. Twenty-three constraints are still waiting for their wire, and this page says so instead of keeping quiet.