@haus-tech/haus-workflow 5.0.1 → 5.2.0

package/library/global/skills/request/scripts/compare-scores.mjs

@@ -3,17 +3,31 @@
  * MEDIUM+). Poängen har större driftyta än klassens enum och multipliceras
  * direkt till pris — request-score:s eget acceptanstest är att två oberoende
  * körningar ger samma poäng. Jämförelsefälten är outcome, score och
- * inringningens golv- och takankare. Prosa (why, drivers, rationale) jämförs
- * ALDRIG. Confidence (enum, inte prosa) visas alltid i utskriften, men fäller
+ * inringningens golv- och takankare, samt type (toleransrad), antalet
+ * conditions (hård diff) och alternatives per label (#509). Prosa (why,
+ * drivers, rationale) jämförs ALDRIG. Confidence (enum, inte prosa) visas
+ * alltid i utskriften, men fäller
  * bara ett par utanför toleransen, se nedan.
  *
  * Toleransregel: en poängskillnad ≤ 0,5 med samma outcome är prisbrus, inte
  * oenighet, oavsett confidence. En ankarskillnad tolereras dessutom bara när
  * banden överlappar eller angränsar; icke-angränsande band är hård diff även
- * vid samma poäng. LIKA_TOLERANS hör till LIKA-familjen (exit 0) med
+ * vid samma poäng. Angränsning avgörs av skalans ordning i lib.mjs ANKARE,
+ * inte av ankarnumret (A17 ligger mellan A12 och A13). LIKA_TOLERANS hör till
+ * LIKA-familjen (exit 0) med
  * en deterministisk vinnare (högsta poängen, skyddar marginalen). Den
  * skriver aldrig om en fil och räknar aldrig fram ett medelvärde.
  *
+ * Stegdiff (beslut D 2026-09-02, ADR-0107 amends 0078): två körningar som
+ * läser SAMMA inre ankare i bracket.steps åt motsatt håll (storre ↔ mindre)
+ * är hård diff, aldrig toleransrad, även när poängen ligger inom 0,5. Golv-
+ * och takankare i någon av körningarna undantas: när banden angränsar
+ * (A11/A12 mot A12/A13) flippar det delade gränsankaret av konstruktion, och
+ * det fallet äger redan angränsningstoleransen ovan. Utan undantaget hade
+ * varje angränsande par blivit OLIKA och toleransen upphävts i praktiken.
+ * Ankare som bara finns i ena körningen, saknat eller trasigt steps (äldre
+ * arkiv) ger ingen rad.
+ *
  * Skriver LIKA, LIKA_TOLERANS (exit 0) eller OLIKA + diffrader (exit 1) på
  * stdout; varningar går på stderr. Vid OLIKA väljer dispatchern ALDRIG en
  * körning och räknar ALDRIG medelvärde — posten eskaleras till granskaren med
@@ -25,10 +39,10 @@
  *
  * Användning: node compare-scores.mjs <körning1.json> <körning2.json>
  */
-import { loadRunPair, refDriftWarning, reportDiffs } from './lib.mjs'
+import { ankarPosition, loadRunPair, norm, refDriftWarning, reportDiffs } from './lib.mjs'
 
 // Jämförelsefälten speglar poängskalans kontrakt — varna (stderr) vid katalogdrift.
-const REF_SHA = 'cb5a6c221b5d39c445ca31a427fd3f96c648388ac5441c22ea2ea5f72e1f8e31'
+const REF_SHA = '810a71f2767173bdc1747e932f466f3fc25cb412b84f61fab0ca0894ff80438a'
 {
   const w = refDriftWarning('request-score/references/poangskala.md', REF_SHA)
   if (w) console.error(`VARNING: ${w}`)
@@ -50,16 +64,19 @@ if (a.outcome !== b.outcome) diffs.push(`outcome: ${show(a.outcome)} ↔ ${show(
 // fortfarande aldrig.
 const TOLERANS = 0.5
 
-/**
- * Ankarnummer på skalan A1..A17. Golv null (under-A1-fallet) läses som 0, alltså
- * steget under A1. Ett ankare som inte går att tolka ger null och behandlas som
- * icke-angränsande, så en oläslig inringning aldrig kan tystas som brus.
- */
+/** Ankarnummer, ENBART för deterministisk utskriftsordning av stegrader. Aldrig ett skalläge, se position(). */
 const ankarNr = (v) => {
   if (v === null || v === undefined) return 0
   const m = /^A(\d+)$/.exec(String(v))
   return m ? Number(m[1]) : null
 }
+/**
+ * Position i skalans ordning ur lib.mjs ANKARE. Golv null (under-A1-fallet)
+ * läses som steget under A1. Ett okänt ankare ger null och behandlas som
+ * icke-angränsande, så en oläslig inringning aldrig kan tystas som brus.
+ * Ankarnumret är INTE en position: A17 ligger mellan A12 och A13 (#506).
+ */
+const position = (v) => (v === null || v === undefined ? -1 : ankarPosition(v))
 /**
  * Inringningarna får toleransbehandling bara när de faktiskt pekar på samma del
  * av skalan: överlappande eller angränsande band. Två körningar som landar på
@@ -68,11 +85,29 @@ const ankarNr = (v) => {
  * densamma.
  */
 const nastanSammaBand = (fa, ta, fb, tb) => {
-  const [l1, h1, l2, h2] = [ankarNr(fa), ankarNr(ta), ankarNr(fb), ankarNr(tb)]
+  const [l1, h1, l2, h2] = [position(fa), position(ta), position(fb), position(tb)]
   if ([l1, h1, l2, h2].some((n) => n === null)) return false
   return l1 <= h2 + 1 && l2 <= h1 + 1
 }
 
+/**
+ * Ankare → relation ur bracket.steps. Saknat, icke-array eller element utan
+ * sträng-anchor/relation läses som tomt: äldre arkiv har andra stegformer och
+ * ska fortfarande gå att jämföra på poäng och band. Dubblett av samma ankare
+ * inom en körning: sista vinner.
+ */
+const stegRelationer = (bracket) => {
+  const out = new Map()
+  const steps = bracket?.steps
+  if (!Array.isArray(steps)) return out
+  for (const s of steps) {
+    if (!s || typeof s !== 'object') continue
+    if (typeof s.anchor !== 'string' || typeof s.relation !== 'string') continue
+    out.set(s.anchor, s.relation)
+  }
+  return out
+}
+
 const tolerans = []
 // Konfidensordet (hog/medel/lag) är en självrapporterad etikett. Den visas
 // alltid i utskriften, men fäller aldrig ensam ett par vars poäng ligger inom
@@ -94,13 +129,84 @@ if (a.outcome === 'POANG' && b.outcome === 'POANG') {
   if (fa !== fb) ankarDiffs.push(`bracket.floor.anchor: ${show(fa)} ↔ ${show(fb)}`)
   if (ta !== tb) ankarDiffs.push(`bracket.ceiling.anchor: ${show(ta)} ↔ ${show(tb)}`)
   ;(inomTolerans && nastanSammaBand(fa, ta, fb, tb) ? tolerans : diffs).push(...ankarDiffs)
+  // Stegdiff (beslut D, ADR-0107): samma inre ankare läst åt motsatt håll är
+  // oenighet om skalan, inte prisbrus, så raden går alltid till diffs. Golv och
+  // tak i någon av körningarna hoppas över: vid angränsande band flippar det
+  // delade gränsankaret av konstruktion (posten är större än A12 som golv,
+  // mindre än A12 som tak), och det fallet syns redan som floor/ceiling-rad
+  // under angränsningstoleransen (ADR-0078). Stigande ankarordning gör
+  // utskriften deterministisk oavsett i vilken ordning agenten skrev stegen.
+  const granser = new Set([fa, fb, ta, tb])
+  const stegA = stegRelationer(a.bracket)
+  const stegB = stegRelationer(b.bracket)
+  const flippar = [...stegA.keys()]
+    .filter((k) => stegB.has(k) && !granser.has(k) && stegA.get(k) !== stegB.get(k))
+    .sort((x, y) => (ankarNr(x) ?? Infinity) - (ankarNr(y) ?? Infinity) || x.localeCompare(y))
+  for (const k of flippar)
+    diffs.push(`bracket.steps[${k}].relation: ${show(stegA.get(k))} ↔ ${show(stegB.get(k))}`)
+  // Kundnära fält utanför huvudpoängen (#509). type är en självrapporterad
+  // etikett som loggas för mätning: toleransrad, fäller aldrig ensam.
+  // conditions är kundens kontraktsvillkor: ett villkor som finns i ena
+  // körningen men inte i den andra är oenighet, inte brus. alternatives
+  // matchas per normaliserad label och diffas under samma toleransregel som
+  // huvudpoängen; ett alternativ som bara finns i ena körningen visas som
+  // toleransrad så granskaren ser det utan att ett par som är ense om priset
+  // faller.
+  if ((a.type ?? null) !== (b.type ?? null))
+    tolerans.push(`type: ${show(a.type)} ↔ ${show(b.type)}`)
+  const antal = (v) => (Array.isArray(v) ? v.length : 0)
+  if (antal(a.conditions) !== antal(b.conditions))
+    diffs.push(`conditions.length: ${antal(a.conditions)} ↔ ${antal(b.conditions)}`)
+  const altNyckel = (x) => norm(x.label).toLowerCase()
+  const alternativ = (doc) =>
+    new Map(
+      (Array.isArray(doc.alternatives) ? doc.alternatives : [])
+        .filter((x) => x && typeof x === 'object' && typeof x.label === 'string')
+        .map((x) => [altNyckel(x), x]),
+    )
+  const altA = alternativ(a)
+  const altB = alternativ(b)
+  for (const [key, x] of altA) {
+    const y = altB.get(key)
+    const label = norm(x.label)
+    if (!y) {
+      tolerans.push(`alternatives[${JSON.stringify(label)}]: bara i körning 1`)
+      continue
+    }
+    if (x.score === y.score) continue
+    const d = Math.abs(x.score - y.score)
+    const rad = `alternatives[${JSON.stringify(label)}].score: ${show(x.score)} ↔ ${show(y.score)}`
+    ;(Number.isFinite(d) && d <= TOLERANS ? tolerans : diffs).push(rad)
+  }
+  for (const [key, y] of altB)
+    if (!altA.has(key))
+      tolerans.push(`alternatives[${JSON.stringify(norm(y.label))}]: bara i körning 2`)
+} else if (a.outcome === 'OVER_SKALAN' && b.outcome === 'OVER_SKALAN') {
+  // ADR-0116: inget tak är prisbärande. Utfallet är lika, golvet avgör.
+  const fa = a.bracket?.floor?.anchor ?? null
+  const fb = b.bracket?.floor?.anchor ?? null
+  if (fa !== fb) diffs.push(`bracket.floor.anchor: ${show(fa)} ↔ ${show(fb)}`)
+  if (konfDiff) tolerans.push(konfDiff)
 } else if (konfDiff) {
   diffs.push(konfDiff)
 }
 
+// Täckningspost (ADR-0119): fältets närvaro är oenighet om vad som ska
+// prissättas, innehållet jämförs inte.
+const harCp = (d) => d.coverage_post !== undefined && d.coverage_post !== null
+if (harCp(a) !== harCp(b))
+  diffs.push(`coverage_post: ${harCp(a) ? 'finns' : 'saknas'} ↔ ${harCp(b) ? 'finns' : 'saknas'}`)
+
 if (diffs.length === 0 && tolerans.length > 0) {
-  const winner = b.score > a.score ? 2 : 1
-  console.log(`LIKA_TOLERANS: högsta gäller ${Math.max(a.score, b.score)} (körning ${winner})`)
+  // OVER_SKALAN bär score: null (ADR-0116), "högsta poängen" är obegripligt
+  // för ett par utan tal. Golvet redan lika (annars hade grenen ovan diffat),
+  // så bara konfidensen skiljer; körning 1 vinner deterministiskt.
+  if (a.outcome === 'OVER_SKALAN' && b.outcome === 'OVER_SKALAN') {
+    console.log('LIKA_TOLERANS: samma golv, konfidens skiljer (körning 1)')
+  } else {
+    const winner = b.score > a.score ? 2 : 1
+    console.log(`LIKA_TOLERANS: högsta gäller ${Math.max(a.score, b.score)} (körning ${winner})`)
+  }
   for (const t of tolerans) console.log(`- ${t}`)
   process.exit(0)
 }

package/library/global/skills/request/scripts/contract-check.mjs

@@ -6,17 +6,59 @@
  * ska fortsätta gå att kontrollera. Fångar det starka modeller ändå slarvar
  * med i lång kontext:
  * parafraserade "ordagranna" citat, läckta protokolltermer i kundtext, brutna
- * enum- och upplösningsregler. Bedömer aldrig innehållets rimlighet — bara
- * kontraktet. Vid BROTT: dispatcha agenten om EN gång med felraderna, sedan
+ * enum- och upplösningsregler. Ett svartlistat ord som står i specen (kundens
+ * eget dokument; analysen är Haus-intern och friar inget) är kundvokabulär
+ * och fälls inte (#504). Bedömer aldrig innehållets rimlighet
+ * — bara kontraktet. Vid BROTT: dispatcha agenten om EN gång med felraderna, sedan
  * stopp. VARNING är heuristik (t.ex. ankar-id som krockar med pappersformat) —
  * visas, stoppar inte.
  *
+ * Stegschemat: `bracket.steps` (och `alternatives[i].bracket.steps`) är en
+ * lista av objekt med exakt nycklarna `anchor` (A<n>), `relation`
+ * (storre/mindre/lika) och `grund` (icke-tom). Egna nycklar är brott, som i
+ * kuvertet. Äldre arkiv med strängsteg läses fortfarande av report.mjs;
+ * bara färska körningar går genom den här kontrollen.
+ *
+ * Inringningens konsistens (ADR-0115): golv före tak, between två angränsande
+ * ankare inuti [golv, tak] (får sammanfalla med dem), poängen mellan
+ * between-paret, och varje stegs relation mot poängen. Poäng PÅ ett ankare
+ * trots storre/mindre är VARNING bara när between-paret inte rymmer någon
+ * poäng emellan; annars BROTT. Ordningen kommer från lib.mjs ANKARE, aldrig
+ * ur ankarnumret.
+ *
+ * Motsägelsegrinden (ADR-0106): när impact.md ges och analysens rad
+ * `**Avvikelse mot specen:**` bär etiketten `motsägelse` är TILLBAKA_TILL_SPEC
+ * det enda giltiga utfallet. Varje annat outcome är brott. Saknad etikett
+ * fäller inget här, precheck äger etikettkravet.
+ *
+ * Språkgrinden (#521): med `--sprak <svenska|engelska>` prövas varje
+ * kundtextfält mot språket. Två OLIKA funktionsord ur fel språk (hela ord,
+ * skiftlägesokänsligt, listorna i lib.mjs FUNKTIONSORD) är BROTT; diakritiska
+ * tecken är ingen signal. Utan flaggan görs ingen språkkontroll.
+ *
  * Användning: node contract-check.mjs <run.json> <spec.md> [impact.md]
+ *                   [--expect-id <id>] [--state <state.json>] [--sprak <svenska|engelska>]
  * Exit 0 = ok, 1 = kontraktsbrott (listade), 2 = användningsfel.
  */
 import { readFileSync } from 'node:fs'
 
-import { refDriftWarning, norm, quoteOk, CLASS_UTFALL, SCORE_OUTCOMES } from './lib.mjs'
+import {
+  refDriftWarning,
+  norm,
+  quoteOk,
+  avvikelseEtikett,
+  CLASS_UTFALL,
+  SCORE_OUTCOMES,
+  CUSTOMER_BLACKLIST,
+  MODES,
+  STEP_RELATIONS,
+  KONFIDENS,
+  ankarPosition,
+  ankarPoang,
+  toppAnkare,
+  TYPER,
+  felSprakOrd,
+} from './lib.mjs'
 
 const argv = process.argv.slice(2)
 let expectId = null
@@ -38,6 +80,39 @@ if (idFlag !== -1) {
   expectId = v
   argv.splice(idFlag, 2)
 }
+// --state pekar ut den buntdels/split-statefil (#503) som avgör om posten är
+// en split-del (split.part) och därmed får sätta OVER_SKALAN. Utan värde är
+// det, som --expect-id ovan, nästan säkert ett dispatcherfel: stanna hårt.
+let statePath = null
+const stateFlag = argv.indexOf('--state')
+if (stateFlag !== -1) {
+  const v = argv[stateFlag + 1]
+  if (v === undefined || v.startsWith('--')) {
+    console.error('--state kräver ett värde')
+    process.exit(2)
+  }
+  statePath = v
+  argv.splice(stateFlag, 2)
+}
+// --sprak (#521) ger kundtextens språk: varje kundtextfält prövas mot det med
+// funktionsordsheuristiken i lib.mjs (felSprakOrd). Utan flaggan görs ingen
+// språkkontroll. Ett saknat eller okänt värde är, som ovan, ett dispatcherfel
+// som stannar hårt: grinden gissar aldrig språk (ADR-0114).
+let sprak = null
+const sprakFlag = argv.indexOf('--sprak')
+if (sprakFlag !== -1) {
+  const v = argv[sprakFlag + 1]
+  if (v === undefined || v.startsWith('--')) {
+    console.error('--sprak kräver ett värde (svenska eller engelska)')
+    process.exit(2)
+  }
+  if (v !== 'svenska' && v !== 'engelska') {
+    console.error(`--sprak: okänt språk "${v}" (giltiga: svenska, engelska)`)
+    process.exit(2)
+  }
+  sprak = v
+  argv.splice(sprakFlag, 2)
+}
 // En felstavad flaggform (t.ex. `--expectid`, bindestrecket i "expect-id"
 // tappat) matchar aldrig `--expect-id` ovan och blir kvar i `argv` som ett
 // obehandlat argument. Utan den här kontrollen landade den tyst som
@@ -48,17 +123,33 @@ if (idFlag !== -1) {
 // användningsfel, aldrig en gissning om vad anroparen menade.
 const okandFlagga = argv.find((a) => a.startsWith('--'))
 if (okandFlagga !== undefined) {
-  console.error(`okänd flagga: ${okandFlagga} (giltig: --expect-id <id>)`)
+  console.error(
+    `okänd flagga: ${okandFlagga} (giltiga: --expect-id <id>, --state <state.json>, --sprak <svenska|engelska>)`,
+  )
   process.exit(2)
 }
 const [jsonPath, specPath, impactPath] = argv
 if (!jsonPath || !specPath) {
   console.error(
-    'användning: node contract-check.mjs <run.json> <spec.md> [impact.md] [--expect-id <id>]',
+    'användning: node contract-check.mjs <run.json> <spec.md> [impact.md] [--expect-id <id>] [--state <state.json>] [--sprak <svenska|engelska>]',
   )
   process.exit(2)
 }
 
+// Split-status (#503): null när --state inte gavs (OVER_SKALAN blir då en
+// VARNING, inte ett BROTT), annars true/false ur split.part i statefilen. En
+// oläsbar statefil är ett dispatcherfel, inte agentens brott.
+let splitDel = null
+if (statePath !== null) {
+  try {
+    const st = JSON.parse(readFileSync(statePath, 'utf8'))
+    splitDel = st?.split?.part != null
+  } catch (e) {
+    console.error(`kunde inte läsa ${statePath}: ${e.message}`)
+    process.exit(2)
+  }
+}
+
 const problems = []
 const warnings = []
 
@@ -71,7 +162,7 @@ const warnings = []
 // referensfil att drifta mot.
 const EXPECTED_REFS = {
   'request-score/references/poangskala.md':
-    'cb5a6c221b5d39c445ca31a427fd3f96c648388ac5441c22ea2ea5f72e1f8e31',
+    '810a71f2767173bdc1747e932f466f3fc25cb412b84f61fab0ca0894ff80438a',
 }
 for (const [rel, expected] of Object.entries(EXPECTED_REFS)) {
   const w = refDriftWarning(rel, expected)
@@ -87,10 +178,16 @@ try {
 // Oläsbart underlag är dispatcherns fel (exit 2), aldrig ett kontraktsbrott —
 // exit 1 skulle trigga en meningslös och dyr omdispatch av agenten.
 let source
+// Analysens råtext hålls isär från det normaliserade underlaget: etiketten på
+// avvikelseraden läses ur den (motsägelsegrinden nedan), och norm() skulle
+// kunna vika radbrytningar som rad-regexen i avvikelseEtikett förlitar sig på.
+let impactText = null
+let kundUnderlag
 try {
-  source = norm(
-    readFileSync(specPath, 'utf8') + '\n' + (impactPath ? readFileSync(impactPath, 'utf8') : ''),
-  )
+  const specText = readFileSync(specPath, 'utf8')
+  if (impactPath) impactText = readFileSync(impactPath, 'utf8')
+  source = norm(specText + '\n' + (impactText ?? ''))
+  kundUnderlag = norm(specText)
 } catch (e) {
   console.error(`kunde inte läsa underlaget: ${e.message}`)
   process.exit(2)
@@ -108,31 +205,8 @@ const collectStrings = (v) => {
   return []
 }
 
-// Protokollmekanik som aldrig får nå kundtext. Klass/klassas är kundspråk
-// (kunden ser Class-fältet) och KONCEPT/DIAGNOS är legitima kundutfall — de
-// står medvetet INTE här. Poäng och skalans mekanik är interna. Gränserna är
-// Unicode-medvetna (JS \b bryter vid å/ä/ö), och "protokoll" är snävat så att
-// vardagssvenska som "protokollförs" går fri medan klassningsprotokollet fångas.
-const B = (pat) => new RegExp(`(?<![\\p{L}\\d_])(?:${pat})`, 'iu')
-const CUSTOMER_BLACKLIST = [
-  B('poäng\\p{L}*'),
-  B('basklass\\p{L}*'),
-  B('bump\\p{L}*'),
-  B('ankar\\p{L}*'),
-  B('referensuppdrag\\p{L}*'),
-  B('inringning\\p{L}*'),
-  B('konfidens\\p{L}*'),
-  // Substantivformer av skalan är mekanik; verbet "skalar" (skalbarhet) är
-  // legitim kundsvenska och går fritt.
-  B('skal(?:a|an|ans|or|orna)(?!\\p{L})'),
-  B('protokoll(?:et|en|s)?(?!\\p{L})'),
-  /klassningsprotokoll/iu,
-  B('blast\\s*radius'),
-  B('touchpoint\\p{L}*'),
-  // u-flaggan är obligatorisk: utan den är \p{L} i lookaround teckenklassen
-  // "p{L" och "era B2B-kunder" blir ett falskt BROTT.
-  /(?<![\p{L}\d_])[SB][1-3](?![\p{L}\d_])/u,
-]
+// CUSTOMER_BLACKLIST bor i lib.mjs (delad med kontroll.mjs, som avgör om ett
+// brott är ett rent kundtextbrott innan en fältomskrivning kan täcka det).
 // Ankar-id (A1–A17) kolliderar strukturellt med pappersformat (A3/A4/A5) och
 // går inte att regexa isär — heuristik, alltså varning i stället för brott.
 const ANCHOR_RE = /(?<![\p{L}\d_])A(?:1[0-7]|[1-9])(?![\p{L}\d_])/u
@@ -168,18 +242,36 @@ const ANCHOR_RE = /(?<![\p{L}\d_])A(?:1[0-7]|[1-9])(?![\p{L}\d_])/u
 const IDIOM_ALLOW = [/hela\s+poängen\s+(?:med|i)\b(?![^.!?]*\d)/giu, /poängen\s+är\s+att\b/giu]
 const maskIdioms = (text) =>
   IDIOM_ALLOW.reduce((t, re) => t.replace(re, (m) => '�'.repeat(m.length)), text)
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+/**
+ * Ett svartlistat ord som redan förekommer som HELT ord i kundens underlag
+ * (specen) är kundens vokabulär, inte skalans mekanik, och fälls inte (#504).
+ * Analysen (impact.md) är Haus-intern och friar inget: den skrivs av en
+ * Haus-agent, inte kunden, så ett protokollord där är inget kundläckage.
+ * Kundens sajt hade en blocktyp "anchor" som agenten återgav som
+ * "ankartrigger" — ett läckage kan inte komma från kundens egna dokument.
+ * Helordsgräns: "ankartrigger" i specen friar inte "ankartriggern".
+ */
+const iUnderlaget = (ord) =>
+  new RegExp(`(?<![\\p{L}\\d_])${escapeRe(ord)}(?![\\p{L}\\d_])`, 'iu').test(kundUnderlag)
 const checkCustomerText = (text, field) => {
   if (typeof text !== 'string') return
   const masked = maskIdioms(text)
   for (const re of CUSTOMER_BLACKLIST) {
     const m = masked.match(re)
-    if (m) problems.push(`${field}: protokollterm "${m[0]}" i kundtext`)
+    if (m && !iUnderlaget(m[0])) problems.push(`${field}: protokollterm "${m[0]}" i kundtext`)
   }
   // Ankarvarningen körs mot ORIGINALET, aldrig mot den maskade strängen.
   // Maskningen bevarar längden men inte innehållet, och varningscitatet ska
   // visa vad som faktiskt stod i texten.
   const a = text.match(ANCHOR_RE)
   if (a) warnings.push(`${field}: "${a[0]}" — ankar-id eller pappersformat? Kontrollera`)
+  // Språkgrinden (#521), också mot originalet: två OLIKA funktionsord ur fel
+  // språk fäller, ett enda är ett lån. Raden har med flit en annan form än
+  // protokollterm-brottet: kundtextfixen i kontroll.mjs byter ord, den
+  // översätter inte, så brottet ska till omdispatch.
+  if (sprak !== null && felSprakOrd(text, sprak).length >= 2)
+    problems.push(`${field}: kundtext på fel språk (väntat ${sprak})`)
 }
 
 /** Poängupplösning: 0.25-steg under 3, heltal från 3, alltid > 0.
@@ -193,7 +285,14 @@ const checkScoreValue = (score, field) => {
   else if (score < 3 ? Math.round(score * 4) !== score * 4 : !Number.isInteger(score))
     problems.push(`${field}: ${score} bryter upplösningen (0.25-steg under 3, heltal från 3)`)
 }
-const checkBracket = (b, field) => {
+/** Nästa giltiga poäng över `lo` på skalans upplösning (0,25 under 3, heltal från 3). */
+const nastaSteg = (lo) => (lo < 3 ? lo + 0.25 : lo + 1)
+/** Avrundningskollaps: between-paret rymmer ingen giltig poäng strikt emellan sig
+ *  (A13/A14 = 12/13, A9/A10 = 4/4). Då landar avrundningen av nödvändighet PÅ
+ *  ett av ankarna även när posten bedömts större/mindre än det (#502). */
+const kollapsar = (lo, hi) => !(nastaSteg(lo) < hi)
+
+const checkBracket = (b, field, score) => {
   // Under-A1-fallet är kontraktsenligt golvlöst: "Får du inget golv: posten är
   // mindre än A1 och får A1:s poäng" — då är floor null och taket A1.
   const floorless = b?.floor == null && b?.ceiling?.anchor === 'A1'
@@ -214,10 +313,118 @@ const checkBracket = (b, field) => {
     )
   if (b.steps.length === 0)
     problems.push(`${field}.steps: tom — inringningen ska redovisa ankarjämförelserna`)
+
+  // Konsistens (ADR-0115, #502/#496): delarna ska hänga ihop, inte bara finnas.
+  // Bara när poängen är ett tal — annars har checkScoreValue redan fällt.
+  const harPoang = typeof score === 'number'
+  let kollaps = false
+  if (floorless) {
+    // Kontraktet självt kollapsar hit: posten är MINDRE än A1 men får A1:s
+    // poäng, så "mindre än A1" med A1:s poäng är varning. "storre mot A1" är
+    // däremot en rak motsägelse av kontraktet (#514 p2), och between prövas
+    // mot ankartabellen precis som i den golvade grenen.
+    const a1 = ankarPoang('A1')
+    if (harPoang && score !== a1)
+      problems.push(
+        `${field}: golvlös inringning (under A1) kräver A1:s poäng ${a1}, fick ${score}`,
+      )
+    for (const id of b.between.filter((x) => ankarPosition(x) === null))
+      problems.push(`${field}: okänt ankare "${id}" (skalan är A1–A17)`)
+    for (const [i, step] of b.steps.entries())
+      if (step && step.anchor === 'A1' && step.relation === 'storre')
+        problems.push(
+          `${field}.steps[${i}]: storre mot A1 i golvlös inringning, posten är per kontrakt mindre än A1`,
+        )
+    kollaps = true
+  } else if (b.between.length === 2) {
+    const okanda = [b.floor.anchor, b.ceiling.anchor, ...b.between].filter(
+      (id) => ankarPosition(id) === null,
+    )
+    if (okanda.length > 0) {
+      for (const id of okanda) problems.push(`${field}: okänt ankare "${id}" (skalan är A1–A17)`)
+    } else {
+      const [pf, pc] = [ankarPosition(b.floor.anchor), ankarPosition(b.ceiling.anchor)]
+      const [b0, b1] = b.between
+      const [p0, p1] = [ankarPosition(b0), ankarPosition(b1)]
+      if (pf >= pc)
+        problems.push(
+          `${field}: golv ${b.floor.anchor} ligger inte före tak ${b.ceiling.anchor} i skalans ordning`,
+        )
+      if (p1 !== p0 + 1)
+        problems.push(
+          `${field}.between: ${b0}/${b1} är inte angränsande i skalans ordning (A17 ligger mellan A12 och A13)`,
+        )
+      else {
+        if (p0 < pf || p1 > pc)
+          problems.push(
+            `${field}.between: ${b0}/${b1} ligger utanför golv ${b.floor.anchor}–tak ${b.ceiling.anchor}`,
+          )
+        // Bara ett bekräftat angränsande par har ett lo/hi (#514 p3): ett
+        // reverserat par gav lo > hi, en vilseledande rad och en falsk kollaps.
+        const [lo, hi] = [ankarPoang(b0), ankarPoang(b1)]
+        if (harPoang && (score < lo || score > hi))
+          problems.push(
+            `${field === 'bracket' ? 'score' : field.replace(/\.bracket$/, '.score')}: ${score} ligger utanför between ${b0} (${lo})–${b1} (${hi})`,
+          )
+        kollaps = kollapsar(lo, hi)
+      }
+    }
+  }
+  for (const [i, step] of b.steps.entries())
+    checkStep(step, `${field}.steps[${i}]`, harPoang ? score : null, kollaps)
+}
+
+/** Ett steg i inringningen: exakt nycklarna anchor/relation/grund, inga egna.
+ *  Okänd nyckel fälls för sig så omdispatchen ser vad som ska bort, och de
+ *  tre obligatoriska kontrolleras oberoende av varandra. Med `score` prövas
+ *  dessutom att relationen stämmer med poängen (ADR-0115). */
+const checkStep = (step, field, score, kollaps) => {
+  if (step === null || typeof step !== 'object' || Array.isArray(step)) {
+    problems.push(`${field}: inte ett objekt (schemat är {anchor, relation, grund})`)
+    return
+  }
+  for (const key of Object.keys(step))
+    if (!STEP_KEYS.includes(key))
+      problems.push(
+        `${field}: okänd nyckel "${key}" (schemat är exakt ${STEP_KEYS.join('/')}, egna nycklar är förbjudna)`,
+      )
+  if (step.anchor === undefined) problems.push(`${field}.anchor: saknas`)
+  else if (typeof step.anchor !== 'string' || !ANCHOR_ID_RE.test(step.anchor))
+    problems.push(`${field}.anchor: "${step.anchor}" är inte ett ankar-id (A<n>)`)
+  else if (ankarPoang(step.anchor) === null)
+    problems.push(`${field}.anchor: okänt ankare "${step.anchor}" (skalan är A1–A17)`)
+  if (step.relation === undefined) problems.push(`${field}.relation: saknas`)
+  else if (!STEP_RELATIONS.includes(step.relation))
+    problems.push(
+      `${field}.relation: ogiltigt värde "${step.relation}" (giltiga: ${STEP_RELATIONS.join(', ')})`,
+    )
+  if (typeof step.grund !== 'string' || step.grund.trim().length === 0)
+    problems.push(`${field}.grund: saknas eller tom sträng`)
+
+  // Relation mot poäng. "Landar den på samma nivå som ett referensuppdrag, ge
+  // den det ankarets poäng rakt av" (SKILL.md steg 4) — då är relationen lika.
+  const ap = ankarPoang(step.anchor)
+  if (score === null || ap === null || !STEP_RELATIONS.includes(step.relation)) return
+  const id = step.anchor
+  if (step.relation === 'lika') {
+    if (score !== ap) problems.push(`${field}: lika med ${id} (${ap}) men poängen är ${score}`)
+  } else if (step.relation === 'storre' && score < ap) {
+    problems.push(`${field}: storre mot ${id} (${ap}) men poängen ${score} är lägre`)
+  } else if (step.relation === 'mindre' && score > ap) {
+    problems.push(`${field}: mindre än ${id} (${ap}) men poängen ${score} är högre`)
+  } else if (score === ap) {
+    const rad = `${field}: ${step.relation === 'storre' ? 'storre mot' : 'mindre än'} ${id} men poängen ${score} är ${id}:s poäng`
+    if (kollaps)
+      warnings.push(`${rad} (avrundningskollaps: between-paret rymmer ingen poäng emellan)`)
+    else problems.push(`${rad} — relationen ska vara lika, eller poängen flyttas`)
+  }
 }
 
-const MODES = ['pricing', 'guard']
 const BASKLASS = ['TINY', 'SMALL', 'MEDIUM', 'LARGE', 'OVER']
+// MODES, STEP_RELATIONS och KONFIDENS bor i lib.mjs (delade med kontroll.mjs,
+// som reparerar samma enumer innan dispatch).
+const STEP_KEYS = ['anchor', 'relation', 'grund']
+const ANCHOR_ID_RE = /^A\d+$/
 
 // Kuverten är slutna: agenterna får aldrig lägga till egna nycklar ("ordagrant
 // och orört"). Okänd toppnyckel är ett brott, inte en utökning.
@@ -237,6 +444,7 @@ const ENVELOPE_KEYS = {
     'alternatives',
     'dependencies',
     'notes',
+    'coverage_post',
     'customer_rationale',
     'guard_diff',
   ],
@@ -331,11 +539,19 @@ if (doc.classification !== undefined) {
   checkEnvelopeKeys('score')
   if (!MODES.includes(doc.mode)) problems.push(`mode: ogiltigt värde "${doc.mode}"`)
   if (!OUTCOMES.includes(doc.outcome)) problems.push(`outcome: ogiltigt värde "${doc.outcome}"`)
-  if (!['hog', 'medel', 'lag'].includes(doc.confidence))
+  if (!KONFIDENS.includes(doc.confidence))
     problems.push(`confidence: ogiltigt värde "${doc.confidence}"`)
+  // Typen (#509): loggas för att mäta systematisk felplacering per typ, så
+  // värdet måste vara ett av översiktstabellens fem. Tom typ tolereras bara på
+  // stopputfall (där finns ingen placering att mäta).
+  const typTom = doc.type === undefined || doc.type === null || doc.type === ''
+  if (doc.outcome === 'POANG' && typTom)
+    problems.push('type: saknas (POANG kräver en av översiktstabellens typer)')
+  else if (!typTom && !TYPER.includes(doc.type))
+    problems.push(`type: ogiltigt värde "${doc.type}" (giltiga: ${TYPER.join(', ')})`)
   if (doc.outcome === 'POANG') {
     checkScoreValue(doc.score, 'score')
-    checkBracket(doc.bracket, 'bracket')
+    checkBracket(doc.bracket, 'bracket', doc.score)
     if (!Array.isArray(doc.drivers) || doc.drivers.length < 2 || doc.drivers.length > 3)
       problems.push(
         `drivers: ${Array.isArray(doc.drivers) ? doc.drivers.length : 'saknas'} (skillen kräver två eller tre faktorer)`,
@@ -343,6 +559,52 @@ if (doc.classification !== undefined) {
   } else if (doc.score != null) {
     problems.push(`score: ska vara null när outcome är ${doc.outcome}`)
   }
+  // #503: inget tak är ett prisbärande utfall. OVER_SKALAN får bara sättas på
+  // en split-del (skillen steg 2), en buntdel är inte en split-del; och båda
+  // inget-tak-utfallen måste ha jämfört posten mot skalans översta ankare
+  // innan de ger upp.
+  if (doc.outcome === 'OVER_SKALAN') {
+    if (splitDel === null)
+      warnings.push('OVER_SKALAN: split-status okänd (kör med --state <state.json> för att grinda)')
+    else if (!splitDel)
+      problems.push(
+        'OVER_SKALAN kräver att posten är en split-del (split.part), en buntdel är inte en split-del: utfallet är DELA_UPP',
+      )
+  }
+  if (doc.outcome === 'DELA_UPP' || doc.outcome === 'OVER_SKALAN') {
+    const topp = toppAnkare()
+    const steps = Array.isArray(doc.bracket?.steps) ? doc.bracket.steps : []
+    if (!steps.some((s) => s && s.anchor === topp))
+      problems.push(
+        `inget tak kräver en jämförelse mot ${topp} i bracket.steps, annars är taket inte prövat`,
+      )
+  }
+  // Motsägelsegrinden (ADR-0106): analysen har redan sagt att specen och
+  // koden inte går ihop, då finns inget att poängsätta och inget att
+  // konceptera. Regeln har inga undantag (samma text som i skillen). Utan
+  // etikett (äldre analys) fälls inget, det kravet äger precheck.
+  if (impactText !== null && avvikelseEtikett(impactText) === 'motsägelse') {
+    if (doc.outcome !== 'TILLBAKA_TILL_SPEC')
+      problems.push(
+        `analysen bär motsägelse mot specen: ${doc.outcome} är inte giltigt, TILLBAKA_TILL_SPEC krävs`,
+      )
+  }
+  // Täckningspost (ADR-0119, #508): antagandet "satt som om tester fanns" är
+  // ett strukturerat fält, inte en fritextnot, så det kan bli en egen post.
+  if (doc.coverage_post !== undefined) {
+    const cp = doc.coverage_post
+    if (cp === null || typeof cp !== 'object' || Array.isArray(cp))
+      problems.push('coverage_post: inte ett objekt (schemat är {yta, omfattning})')
+    else {
+      for (const key of Object.keys(cp))
+        if (!['yta', 'omfattning'].includes(key))
+          problems.push(`coverage_post: okänd nyckel "${key}"`)
+      for (const key of ['yta', 'omfattning'])
+        if (typeof cp[key] !== 'string' || cp[key].trim() === '')
+          problems.push(`coverage_post.${key}: saknas eller tom sträng`)
+      if (typeof cp.yta === 'string') checkCustomerText(cp.yta, 'coverage_post.yta')
+    }
+  }
   // Ett ankare utan sitt lösta citat betyder att dispatchern hoppat över
   // resolve-anchors.mjs: dispatcherns fel (exit 2), aldrig agentens brott.
   for (const [i, d] of (Array.isArray(doc.drivers) ? doc.drivers : []).entries())
@@ -374,7 +636,7 @@ if (doc.classification !== undefined) {
     checkCustomerText(alt?.adds, `alternatives[${i}].adds`)
     if (alt?.score != null) {
       checkScoreValue(alt.score, `alternatives[${i}].score`)
-      checkBracket(alt?.bracket, `alternatives[${i}].bracket`)
+      checkBracket(alt?.bracket, `alternatives[${i}].bracket`, alt.score)
     }
   }
 } else {