@haus-tech/haus-workflow 4.9.0 → 5.0.1

package/library/global/skills/request/scripts/report.mjs

@@ -0,0 +1,571 @@
+/**
+ * Läser experimentytan och renderar en självständig HTML-rapport.
+ *
+ * Rapporten är ett LÄSVERKTYG. Den rangordnar aldrig modeller, rekommenderar
+ * aldrig en nivå och räknar aldrig fram ett facit: bedömningen av vad som är
+ * ett korrekt utfall är människans, gjord på erfarenhet av systemet. Scriptet
+ * visar spridningen och håller tyst om vem som hade rätt.
+ *
+ * Matrisen är med flit ojämn. En post kan ha opus och sonnet, en annan opus,
+ * sonnet och fable, eftersom en dyrare modell läggs till bara där de billigare
+ * inte räckte. Därför förutsätter rapporten aldrig samma kolumnuppsättning och
+ * räknar aldrig aggregat tvärs poster: ett medelvärde över olika
+ * modelluppsättningar jämför olika saker.
+ *
+ * Användning: node report.mjs <experimentyta> [--ut <fil>]
+ * Exit 0 = rapport skriven, 2 = användnings- eller lässfel.
+ *
+ * Varje radbyggare returnerar färdig HTML och äger sin egen escaping;
+ * `sektion` interpolerar cellerna oescapade. En ny sektion som glömmer detta
+ * öppnar för injektion, så regeln måste stå här, inte bara i författarnas huvud.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { sectionLines } from './lib.mjs'
+
+const SPECFALT = ['Problem', 'Lösning', 'När det är klart', 'Ingår inte']
+
+/** Körningskataloger heter k<N>. Sorteringen är numerisk: k10 kommer efter k2,
+ *  vilket strängordning inte ger. */
+const KORNING_RE = /^k(\d+)$/
+
+const läsJson = (p) => {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+const kataloger = (p) =>
+  fs
+    .readdirSync(p, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+
+/** Gällande pris-JSON för en axel: högsta vN UTAN suffix. En `-run2`- eller
+ *  `-avvisad`-fil är aldrig det gällande dokumentet, samma regel som
+ *  `detaljer` följer.
+ *
+ *  Axelnamnen är arkivets filnamn (`classification`, `score`), aldrig skillens
+ *  svenska axelord: filerna på disk heter `classification-pricing-vN.json` och
+ *  `score-pricing-vN.json`, pinnade av PRICING_RE i archive.mjs. */
+const gallandePrisfil = (dir, axel) => {
+  const re = new RegExp(`^${axel}-pricing-v(\\d+)\\.json$`)
+  const träffar = fs
+    .readdirSync(dir)
+    .map((f) => [f, re.exec(f)])
+    .filter(([, m]) => m)
+    .sort((a, b) => Number(a[1][1]) - Number(b[1][1]))
+  return träffar.length ? läsJson(path.join(dir, träffar.at(-1)[0])) : null
+}
+
+const läsSpec = (dir) => {
+  let rå
+  try {
+    rå = fs.readFileSync(path.join(dir, 'spec.md'), 'utf8')
+  } catch {
+    return null
+  }
+  return Object.fromEntries(
+    SPECFALT.map((f) => {
+      const rader = sectionLines(rå, f)
+      return [f, rader === null ? null : rader.join('\n').trim()]
+    }),
+  )
+}
+
+/** Arkiverat dokument, eller null. Ett saknat dokument är inte samma sak som en
+ *  ofullständig körning: analysen finns inte förrän bedömningsbenet körts, och
+ *  en spec-only-körning är fortfarande en hel körning av det den var. */
+const läsDok = (dir, namn) => {
+  try {
+    return fs.readFileSync(path.join(dir, namn), 'utf8')
+  } catch {
+    return null
+  }
+}
+
+const läsKorning = (dir, namn) => {
+  const state = läsJson(path.join(dir, 'state.json'))
+  const spec = läsSpec(dir)
+  return {
+    namn,
+    sokvag: dir,
+    // Ofullständig betyder att rapporten inte kan visa körningen som en hel
+    // körning. Den visas ändå, märkt: tyst utelämnande är den enda utgången
+    // som skulle ljuga för läsaren.
+    ofullstandig: state === null || spec === null,
+    state,
+    spec,
+    impact: läsDok(dir, 'impact.md'),
+    granskarblock: läsDok(dir, 'granskarblock.md'),
+    klass: gallandePrisfil(dir, 'classification'),
+    poang: gallandePrisfil(dir, 'score'),
+    matning: läsJson(path.join(dir, 'korning.json')),
+    // Startarens egen mätning. Egen fil med flit: `korning.json` är
+    // headless-svaret rått, och en haus-ägd nyckel i den gör den till ett
+    // blandat format som inte längre går att diffa mot CLI:ns utdata.
+    klocka: läsJson(path.join(dir, 'matning.json')),
+    delar: kataloger(dir)
+      .filter((d) => /^del-\d+$/.test(d))
+      .sort()
+      .map((d) => läsKorning(path.join(dir, d), d)),
+  }
+}
+
+export function läsExperimentyta(rot) {
+  if (!fs.existsSync(rot)) throw new Error(`experimentytan ${rot} finns inte`)
+  const alla = kataloger(rot)
+    .sort()
+    .map((slug) => {
+      const postDir = path.join(rot, slug)
+      const experiment = läsJson(path.join(postDir, 'experiment.json'))
+      const modeller = kataloger(postDir)
+        .sort()
+        .map((modell) => ({
+          namn: modell,
+          korningar: kataloger(path.join(postDir, modell))
+            .map((k) => [k, KORNING_RE.exec(k)])
+            .filter(([, m]) => m)
+            .sort((a, b) => Number(a[1][1]) - Number(b[1][1]))
+            .map(([k]) => läsKorning(path.join(postDir, modell, k), k)),
+        }))
+        .filter((m) => m.korningar.length > 0)
+      return { slug, experiment, modeller }
+    })
+  // En post utan k<N>-körningar är inte samma sak som en post som inte finns:
+  // ett äldre arkivlager lägger sina delar direkt under modellkatalogen, utan
+  // k<N>-nivå, och den posten ska synas som skippad, aldrig som frånvarande.
+  // `alla` är redan sorterad på slug (kataloger(rot).sort() ovan), så
+  // filtreringen behåller ordningen utan en extra sort.
+  const poster = alla.filter((p) => p.modeller.length > 0)
+  const utan_korningar = alla.filter((p) => p.modeller.length === 0).map((p) => p.slug)
+  return { rot, poster, utan_korningar }
+}
+
+const esc = (s) =>
+  String(s ?? '').replace(
+    /[&<>"']/g,
+    (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c],
+  )
+
+const tal = (n) => (n == null ? '–' : new Intl.NumberFormat('sv-SE').format(n))
+const usd = (n) => (n == null ? '–' : `$${n.toFixed(2)}`)
+const minuter = (ms) => (ms == null ? '–' : `${(ms / 60000).toFixed(1)} min`)
+
+/** Ett gid är siffror och inget annat. En slug-post (spec utan Asana-ticket)
+ *  har inget gid och ska inte få ett påhittat: ett felaktigt gid i rapporten
+ *  leder läsaren till fel ticket, vilket är värre än inget gid alls. */
+const GID_RE = /^\d+$/
+
+/** Postens identitet. Titeln och permalänken är experimentets, aldrig
+ *  rapportens: Asanas permalänkar bär ett workspace-gid som inte finns någonstans
+ *  på experimentytan, så en konstruerad URL vore en gissning som tyst slutar
+ *  fungera. Datumet läses under båda namnen, äldre filer bär `date`. */
+const identitet = (post) => {
+  const e = post.experiment ?? {}
+  const rid = String(e.request_id ?? '')
+  return {
+    titel: e.title || post.slug,
+    gid: GID_RE.test(rid) ? rid : GID_RE.test(post.slug) ? post.slug : null,
+    lank:
+      typeof e.permalink_url === 'string' && e.permalink_url.startsWith('https://')
+        ? e.permalink_url
+        : null,
+    datum: e.datum ?? e.date ?? null,
+  }
+}
+
+/** Identitetsraden under rubriken. Gid:t utelämnas när det redan ÄR rubriken
+ *  (titellös post), men länken och datumet står kvar, annars tappas de för
+ *  precis de poster som är svårast att känna igen. */
+const identRad = (id) => {
+  const bitar = []
+  if (id.gid && id.gid !== id.titel)
+    bitar.push(id.lank ? `<a href="${esc(id.lank)}">${esc(id.gid)}</a>` : esc(id.gid))
+  else if (id.lank) bitar.push(`<a href="${esc(id.lank)}">Asana</a>`)
+  if (id.datum) bitar.push(esc(id.datum))
+  return bitar.length ? `<p class="ident">${bitar.join(' · ')}</p>` : ''
+}
+
+/** Kostnadsraderna. En körning utan korning.json är OMÄTT, inte noll: nollor
+ *  skulle läsas som "gratis" och är den enda siffra rapporten kan ljuga med.
+ *
+ *  Radlistan har ALLTID samma längd och samma fältnamn, mätt eller omätt. Varje
+ *  sektion tar sina fältnamn från den första körningens lista, så en omätt
+ *  körning med färre rader skulle förskjuta hela tabellen och ställa USD mot
+ *  väggtid.
+ *
+ *  Varje fält deklarerar sin egen källa: kostnaden och tokens kommer ur
+ *  `korning.json` (headless-svaret), klocktiden ur `matning.json` (startarens
+ *  mätning). */
+const KOSTNADSFALT = [
+  ['USD', 'matning', (m) => usd(m.total_cost_usd)],
+  ['Tokens in', 'matning', (m) => tal(m.usage?.input_tokens)],
+  ['Tokens ut', 'matning', (m) => tal(m.usage?.output_tokens)],
+  ['Cache läst', 'matning', (m) => tal(m.usage?.cache_read_input_tokens)],
+  ['Cache skriven', 'matning', (m) => tal(m.usage?.cache_creation_input_tokens)],
+  // Klocktiden kommer ur startarens mätning, aldrig ur headless-svarets
+  // `duration_ms`: det fältet räknar inte in väntan på bakgrundssubagenter och
+  // sa 5,5 minuter om en sonnetkörning som tog omkring 34. Ett `wall_ms` som
+  // saknas eller inte är ett tal är omätt, aldrig noll: en nolla skulle läsas
+  // som en ögonblicklig körning.
+  ['Väggtid', 'klocka', (m) => (Number.isFinite(m.wall_ms) ? minuter(m.wall_ms) : null)],
+  ['Dispatcher', 'matning', (m) => tal(m.subagent_stats?.spawned)],
+]
+
+const kostnadsrader = (k) =>
+  KOSTNADSFALT.map(([namn, källa, hämta]) => {
+    // En del är ingen egen process: mätningen kommer ur headless-svaret för
+    // hela körningen. "omätt" skulle påstå att mätningen misslyckades, vilket
+    // är en annan sak än att den inte finns på den här nivån.
+    if (k.rot) return [namn, `<em>ingår i ${esc(k.rot)}</em>`]
+    // Två oberoende källor: en saknad fil säger omätt för SINA rader och
+    // ljuger inte om de andra. Radlistan har ändå alltid samma längd och
+    // samma fältnamn, mätt eller omätt.
+    const dok = k[källa]
+    const värde = dok ? hämta(dok) : null
+    return [namn, värde === null ? '<em>omätt</em>' : esc(värde)]
+  })
+
+const provenienrader = (k) => {
+  const p = k.state?.proveniens ?? {}
+  return [
+    ['Modell', esc(p.modell ?? '–')],
+    ['Datum', esc(p.datum ?? '–')],
+    ['Konto', esc(p.konto ?? '–')],
+    ['SKILL.md', esc((p.skill_sha256 ?? '–').slice(0, 12))],
+    ['Underlag', esc((p.underlag_sha256 ?? '–').slice(0, 12))],
+  ]
+}
+
+/** Inringningen är ett objekt, inte en sträng: `esc()` rakt på den ger
+ *  `[object Object]`. Golvlöst är kontraktsenligt, `floor` är null när taket är
+ *  A1 och posten alltså är mindre än A1, och då är "under A1" det ärliga
+ *  läsvärdet. Saknas inringningen helt får den samma streck som övriga saknade
+ *  värden. */
+const inringning = (b) => {
+  const tak = b?.ceiling?.anchor
+  if (!tak) return '–'
+  const golv = b?.floor?.anchor
+  return golv ? `${golv} till ${tak}` : `under ${tak}`
+}
+
+/** Renderar ett godtyckligt kuvertvärde. Kontraktet pinnar bara ytterhöljet
+ *  (contract-check kräver floor/ceiling/between/steps och två till tre drivers);
+ *  vad som ligger INUTI ett steg eller en driver är inte pinnat och skiljer sig
+ *  mellan arkiv: en floor bär `score` och `why` i en körning och `poang` i en
+ *  annan, en driver `faktor` i en och `ankare` i en annan. En renderare som
+ *  plockar namngivna innernycklar tappar därför tyst innehåll i hälften av
+ *  arkiven. Den här skriver ut de nycklar som faktiskt finns. */
+const varde = (v) => {
+  if (v == null || v === '') return '–'
+  if (Array.isArray(v))
+    return v.length ? `<ul>${v.map((x) => `<li>${varde(x)}</li>`).join('')}</ul>` : '–'
+  if (typeof v === 'object') {
+    const rader = Object.entries(v).filter(([, x]) => x != null && x !== '')
+    return rader.length ? rader.map(([k, x]) => `<b>${esc(k)}:</b> ${varde(x)}`).join('<br>') : '–'
+  }
+  return esc(v)
+}
+
+/** Kuverten är slutna och nycklarna deras, inte rapportens: klassningen bär sitt
+ *  utfall i `classification.utfall`, poängen sitt tal i `score` och sin
+ *  inringning i `bracket`. Formerna är pinnade i contract-check.mjs. */
+const utfallsrader = (k, harKlass = true) => [
+  ...(harKlass ? [['Klass', esc(k.klass?.classification?.utfall ?? '–')]] : []),
+  ['Poäng', esc(k.poang?.score ?? '–')],
+  ['Inringning', esc(inringning(k.poang?.bracket))],
+  ['Utfall poäng', esc(k.poang?.outcome ?? '–')],
+  ['Delning', k.delar.length ? esc(`${k.delar.length} delar`) : 'delade sig inte'],
+  ['Dubbelkörning', esc(k.state?.runs?.at(-1)?.double_run ?? '–')],
+  ['Status', k.ofullstandig ? '<strong>ofullständig</strong>' : esc(k.state?.status ?? '–')],
+]
+
+const specrader = (k) => SPECFALT.map((f) => [f, `<pre>${esc(k.spec?.[f] ?? '–')}</pre>`])
+
+/** Hopfälld som default: impact.md är flera sidor, och tre öppna analyser sida
+ *  vid sida trycker ner utfallstabellen ur bild. Saknat dokument ger streck,
+ *  aldrig en tom hopfällare som lovar innehåll som inte finns. */
+const hopfalld = (text) =>
+  text == null ? '–' : `<details><summary>visa</summary><pre>${esc(text)}</pre></details>`
+
+const analysrader = (k) => [['impact.md', hopfalld(k.impact)]]
+const granskarrader = (k) => [['granskarblock.md', hopfalld(k.granskarblock)]]
+
+/** Klassningens fältvisa rader. Frågeraderna är dynamiska: id-listan kommer ur
+ *  kuvertet, inte ur en hårdkodad lista, eftersom protokollets frågor och
+ *  stopputfallens delmängder skiljer sig mellan körningar. Belägget står under
+ *  svaret därför att det är den enda delen som avslöjar om två lika svar vilar
+ *  på samma läsning av underlaget. */
+const klassrader = (k) => {
+  const c = k.klass?.classification
+  const kund = k.klass?.customer
+  // En handredigerad eller trunkerad envelope kan ha en null-post i fragor;
+  // contract-check.mjs stoppar det för välformade arkiv, men rapporten
+  // degraderar per cell, aldrig per sida, så en icke-objekt-rad filtreras bort
+  // i stället för att kasta och riva ner hela sidan.
+  const fragor = Array.isArray(c?.fragor) ? c.fragor.filter((f) => f && typeof f === 'object') : []
+  return [
+    ['Utfall', varde(c?.utfall)],
+    ['Basklass', varde(c?.basklass)],
+    ...fragor.map((f) => [
+      esc(f.id ?? '?'),
+      `${varde(f.svar)}${f.konfidens == null ? '' : ` (konfidens ${varde(f.konfidens)})`}` +
+        `<br><em>${esc(f.belagg ?? '–')}</em>`,
+    ]),
+    ['Bumpar träffade', varde(c?.bumpar_traffade)],
+    ['Genomförbarhetsvillkor', varde(c?.genomforbarhetsvillkor)],
+    ['Beroenden', varde(c?.beroenden)],
+    ['Saknas', varde(c?.saknas)],
+    ['Eskaleringsskäl', varde(c?.eskaleringsskal)],
+    ['Slutklassmotivering', varde(c?.slutklass_motivering)],
+    ['Kundmotivering', varde(kund?.rationale)],
+  ]
+}
+
+/** Poängens fältvisa rader. `inringning` behålls som sammanfattningsrad och
+ *  golv/tak/steg visas dessutom hela: sammanfattningen svarar på VAR posten
+ *  landade, de tre raderna på VARFÖR, och det är varför-delen som skiljer två
+ *  modeller som råkade landa på samma tal. */
+const poangrader = (k) => {
+  const p = k.poang
+  return [
+    ['Utfall', varde(p?.outcome)],
+    ['Poäng', varde(p?.score)],
+    ['Typ', varde(p?.type)],
+    ['Inringning', esc(inringning(p?.bracket))],
+    ['Golv', varde(p?.bracket?.floor)],
+    ['Tak', varde(p?.bracket?.ceiling)],
+    ['Mellan', varde(p?.bracket?.between)],
+    ['Steg', varde(p?.bracket?.steps)],
+    ['Drivers', varde(p?.drivers)],
+    ['Konfidens', varde(p?.confidence)],
+    ['Antaganden', varde(p?.assumptions_stated)],
+    ['Villkor', varde(p?.conditions)],
+    ['Beroenden', varde(p?.dependencies)],
+    ['Noter', varde(p?.notes)],
+    ['Alternativ', varde(p?.alternatives)],
+    ['Kundmotivering', varde(p?.customer_rationale)],
+  ]
+}
+
+/** En sektion är en rubrik plus rader, där varje rad har ett fältnamn och en
+ *  cell per körning. Fältvis, inte dokumentvis: det som ska jämföras är samma
+ *  fält, inte samma sidnummer. */
+const sektion = (rubrik, rader, korningar) => `
+  <h3>${esc(rubrik)}</h3>
+  <div class="scroll">
+  <table>
+    <thead><tr><th>Fält</th>${korningar
+      .map((k) => `<th>${esc(k.rubrik)}</th>`)
+      .join('')}</tr></thead>
+    <tbody>
+      ${rader
+        .map(
+          (fältnamn, i) =>
+            `<tr><th>${esc(fältnamn)}</th>${korningar
+              .map((k) => `<td>${k.celler[i]}</td>`)
+              .join('')}</tr>`,
+        )
+        .join('\n')}
+    </tbody>
+  </table>
+  </div>`
+
+/** Bygger en sektion ur en radfunktion per kolumn. Fältnamnen är UNIONEN över
+ *  kolumnerna i första-förekomst-ordning, aldrig kolumn noll:s lista: två
+ *  modeller som besvarat olika frågor är normalfallet vid stopputfall, och ett
+ *  fält som bara en kolumn har måste synas, annars döljer rapporten just den
+ *  skillnad läsaren letar efter. En kolumn utan fältet får streck. */
+const byggSektion = (rubrik, kolumner, radfn) => {
+  const perKolumn = kolumner.map((k) => new Map(radfn(k)))
+  const namn = []
+  for (const m of perKolumn) for (const n of m.keys()) if (!namn.includes(n)) namn.push(n)
+  return sektion(
+    rubrik,
+    namn,
+    kolumner.map((k, i) => ({ ...k, celler: namn.map((n) => perKolumn[i].get(n) ?? '–') })),
+  )
+}
+
+/** Kolumnerna: varje körning följd av sina delar. Delarna är egna kolumner
+ *  eftersom det är DÄR utfallen bor i en delad post; räknaren "N delar" döljer
+ *  hela resultatet. `rot` är null för en riktig körning och namnet på
+ *  körningen för en del, vilket är det kostnadsraderna behöver för att säga
+ *  "ingår i k1" i stället för att påstå att mätningen misslyckades.
+ *
+ *  Rekursivt trots att kontraktet stannar på en nivå (en del utan tak blir
+ *  OVER_SKALAN och delas aldrig vidare): en oväntad nivå ska synas som en
+ *  kolumn, aldrig tappas tyst. */
+const plattaKolumner = (k, modell, prefix, rot) => {
+  const rubrik = `${prefix} / ${k.namn}`
+  return [
+    { ...k, modell, rubrik, rot },
+    ...k.delar.flatMap((d) => plattaKolumner(d, modell, rubrik, rot ?? k.namn)),
+  ]
+}
+
+const postSektion = (post) => {
+  // Kolumnerna är alla körningar av alla modeller för posten, plus varje
+  // körnings delar som egna kolumner direkt efter den. Ojämn matris är
+  // normalfallet, inte ett undantag som ska jämnas ut.
+  const korningar = post.modeller.flatMap((m) =>
+    m.korningar.flatMap((k) => plattaKolumner(k, m.namn, m.namn, null)),
+  )
+  const id = identitet(post)
+  // ADR-0098: klassaxeln är borttagen — Klassning-sektionen (och Klass-raden
+  // i Utfall) renderas bara när posten faktiskt bär klassningsfiler, dvs. för
+  // äldre arkiv. Kalibreringshistoriken kastas inte, men en post utan axeln
+  // ska inte visa en tom sektion för den.
+  const harKlass = korningar.some((k) => k.klass != null)
+  const block = [
+    ['Utfall', (k) => utfallsrader(k, harKlass)],
+    ...(harKlass ? [['Klassning', klassrader]] : []),
+    ['Poäng', poangrader],
+    ['Spec', specrader],
+    ['Analys', analysrader],
+    ['Granskarblock', granskarrader],
+    ['Kostnad', kostnadsrader],
+    ['Proveniens', provenienrader],
+  ]
+  return `
+  <section class="post" id="post-${esc(post.slug)}" hidden>
+    <h2>${esc(id.titel)}</h2>
+    ${identRad(id)}
+    ${block.map(([rubrik, fn]) => byggSektion(rubrik, korningar, fn)).join('\n')}
+  </section>`
+}
+
+/** Anledningen upprepas i båda hoppa-över-fallen nedan: en post utan
+ *  k<N>-katalog är inte tom, den är skriven i ett äldre arkivlager som ligger
+ *  utanför vad rapporten läser. Att kalla den tom skulle påstå att datan är
+ *  borta, när den bara ligger på en nivå rapporten inte tolkar. */
+const K_FORMAT_FORKLARING =
+  'Rapporten läser körningar ur kataloger som heter k1, k2 och så vidare. Ett äldre arkiv, ' +
+  'skrivet innan den namngivningen togs i bruk, har sina delar direkt under modellkatalogen, ' +
+  'och de syns därför inte i den här rapporten.'
+
+const postord = (n) => (n === 1 ? 'postkatalog' : 'postkataloger')
+
+/** Katalognamnen kommer från filsystemet, inte från något som redan är
+ *  HTML-säkert, så de escapas precis som varje annat arkivnamn i filen. */
+const hoppadeLista = (namn) =>
+  `<details><summary>visa</summary><pre>${namn.map(esc).join('\n')}</pre></details>`
+
+/** De tre sanna fallen. "Tom" är bara sant när det inte fanns några
+ *  postkataloger alls: finns kataloger som skippades är ytan inte tom, den
+ *  har lästa poster på fel nivå, och det är en annan sak att säga. */
+const innehall = (modell) => {
+  const { poster, utan_korningar: skippade } = modell
+  if (poster.length === 0 && skippade.length === 0) {
+    return '<p class="tom">Experimentytan är tom.</p>'
+  }
+  if (poster.length === 0) {
+    return `<p class="tom">${skippade.length} ${postord(skippade.length)} hittades, men ingen har körningar under k&lt;N&gt;. ${K_FORMAT_FORKLARING}</p>
+${hoppadeLista(skippade)}`
+  }
+  const meny = poster
+    .map((p) => {
+      const namn = identitet(p).titel
+      const suffix = namn === p.slug ? '' : `, ${p.slug}`
+      return `<option value="post-${esc(p.slug)}">${esc(namn)}${esc(suffix)} (${p.modeller
+        .map((m) => `${esc(m.namn)}×${m.korningar.length}`)
+        .join(', ')})</option>`
+    })
+    .join('\n')
+  // Notisen står ovanför menyn, inte längst ner: en läsare som jämför
+  // modeller ska se att ytan är ofullständig INNAN hen börjar jämföra, inte
+  // upptäcka det av misstag efter att redan ha bildat sig en uppfattning.
+  const notis = skippade.length
+    ? `<p class="notis">${skippade.length} ${postord(skippade.length)} hoppades över: ingen körning under k&lt;N&gt; hittades. ${K_FORMAT_FORKLARING}</p>
+${hoppadeLista(skippade)}`
+    : ''
+  return `${notis}
+<p><label>Post: <select id="val">${meny}</select></label></p>
+${poster.map(postSektion).join('\n')}
+<script>
+  const val = document.getElementById('val')
+  const visa = () => {
+    for (const s of document.querySelectorAll('section.post')) s.hidden = s.id !== val.value
+  }
+  val.addEventListener('change', visa)
+  visa()
+</script>`
+}
+
+export function renderaHtml(modell) {
+  return `<!doctype html>
+<meta charset="utf-8">
+<title>Modellrapport</title>
+<style>
+  body { font: 15px/1.5 system-ui, sans-serif; margin: 2rem; max-width: 100%; }
+  select { font-size: 1rem; padding: .4rem; }
+  /* table-layout: fixed gör kolumnbredderna oberoende av innehållet: fältkolumnen
+     får sina 9rem, och datakolumnerna sin angivna bredd. Med auto-layout skulle
+     i stället den kolumn som råkar ha längst spec bli bredast, och fältkolumnen
+     hoppa i sidled mellan sektionerna.
+     min-width i stället för width på tabellen är det som låter .scroll göra sitt
+     jobb: får kolumnerna plats sträcks tabellen till full bredd och de delar
+     utrymmet, får de inte plats växer tabellen förbi behållaren och den scrollar
+     i sidled. Med width: 100% kunde tabellen aldrig bli bredare än behållaren,
+     så scrollen slog aldrig in och kolumnerna krympte i stället obegränsat: en
+     post delad i tre delar över fyra modeller ger sexton datakolumner, och de
+     blev då för smala för att läsa. */
+  table { border-collapse: collapse; margin: 1rem 0; width: max-content; min-width: 100%; table-layout: fixed; }
+  th, td { border: 1px solid #ccc; padding: .4rem .6rem; text-align: left; vertical-align: top; }
+  thead th { background: #f3f3f3; }
+  tbody th, thead th:first-child { width: 9rem; font-weight: 600; }
+  /* Golvbredden per datakolumn. Räcker utrymmet fördelas överskottet över dem,
+     annars är det här den bredd de behåller medan tabellen scrollar. */
+  tbody td, thead th:not(:first-child) { width: 14rem; }
+  /* Fast layout ger cellen ingen chans att växa, så allt som inte ryms måste
+     kunna brytas. Utan detta spiller en lång URL i en spec ut över grannkolumnen. */
+  td, th { overflow-wrap: anywhere; }
+  pre { white-space: pre-wrap; margin: 0; font: inherit; }
+  .tom { color: #666; }
+  .notis { color: #666; }
+  .ident { color: #666; margin: -.5rem 0 1rem; }
+  .scroll { overflow-x: auto; }
+</style>
+<h1>Modellrapport</h1>
+<p>Underlag för manuell bedömning av lägsta acceptabla modellnivå. Rapporten tar
+inte ställning, den visar spridningen mellan körningarna.</p>
+${innehall(modell)}
+`
+}
+
+// ---- CLI -------------------------------------------------------------------
+// `file://${argv[1]}` bryter mot import.meta.url när argv är /var/... och
+// Node resolvar till /private/var/... (macOS-temp, och ~/.claude bakom länk).
+const isCli = (() => {
+  if (!process.argv[1]) return false
+  try {
+    return fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(process.argv[1])
+  } catch {
+    return false
+  }
+})()
+const [rot, ...rest] = process.argv.slice(2)
+if (isCli) {
+  if (!rot) {
+    console.error('användning: node report.mjs <experimentyta> [--ut <fil>]')
+    process.exit(2)
+  }
+  const iUt = rest.indexOf('--ut')
+  const utFil = iUt === -1 ? null : rest[iUt + 1]
+  if (iUt !== -1 && (!utFil || utFil.startsWith('--'))) {
+    console.error('--ut kräver ett värde')
+    process.exit(2)
+  }
+  try {
+    const html = renderaHtml(läsExperimentyta(rot))
+    if (utFil) fs.writeFileSync(utFil, html)
+    else process.stdout.write(html)
+  } catch (e) {
+    console.error(e.message)
+    process.exit(2)
+  }
+}