@haus-tech/haus-workflow 4.8.0 → 5.0.0

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

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * Deterministisk kontroll av scorerns LÄSTA-svansrad (ADR-0099). Läs-scopet
+ * är en promptregel, inte en fysisk spärr — raden gör den granskbar, och det
+ * här scriptet gör granskningen mekanisk i stället för en instruktion som är
+ * lätt att missa (granskningens fynd på PR #470).
+ *
+ * Tillåten mängd: EXAKT underlagens två sökvägar (spec.md, impact.md — båda
+ * OBLIGATORISKA: scorern måste ha läst sitt underlag), plus valfria filer
+ * under skillens egen katalog (`skills/request-score/` under Claude-
+ * konfigkatalogen, referensfilen). Allt annat — körningskatalogens övriga
+ * filer, repot, vad som helst — är ett kontraktsbrott: behandla exit 1 som
+ * BROTT i bedöm steg 5 (omdispatch EN gång, sedan stopp).
+ *
+ * Användning: node check-lasta.mjs "<LÄSTA-radens innehåll>" <spec.md> <impact.md>
+ *   Innehållet är det som står EFTER "LÄSTA: ": kommaseparerade absoluta
+ *   sökvägar, eller literalen "inga".
+ * Exit 0 = ok, 1 = kontraktsbrott (BROTT-rader på stdout), 2 = användningsfel.
+ */
+import path from 'node:path'
+
+import { claudeDir } from './lib.mjs'
+
+const [lasta, specPath, impactPath] = process.argv.slice(2)
+if (lasta == null || !specPath || !impactPath) {
+  console.error('användning: node check-lasta.mjs "<LÄSTA-innehåll>" <spec.md> <impact.md>')
+  process.exit(2)
+}
+
+const problems = []
+const spec = path.resolve(specPath)
+const impact = path.resolve(impactPath)
+// Skillkatalogen med avslutande separator, så prefixtestet aldrig släpper
+// igenom en granne som `request-score-annat/`.
+const skillDir = path.resolve(claudeDir(), 'skills', 'request-score') + path.sep
+
+const lista =
+  lasta.trim() === 'inga'
+    ? []
+    : lasta
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+
+const lastaResolved = lista.map((p) => path.resolve(p))
+
+for (const kravd of [spec, impact])
+  if (!lastaResolved.includes(kravd))
+    problems.push(`obligatoriskt underlag olästt: ${kravd} saknas på LÄSTA-raden`)
+
+for (const p of lastaResolved)
+  if (p !== spec && p !== impact && !p.startsWith(skillDir))
+    problems.push(
+      `otillåten sökväg på LÄSTA-raden: ${p} — tillåtet är exakt underlagens två ` +
+        'filer plus skillens egen katalog',
+    )
+
+if (problems.length === 0) {
+  console.log('OK: LÄSTA-raden håller sig inom läs-scopet')
+  process.exit(0)
+}
+console.log(`BROTT (${problems.length}):`)
+for (const p of problems) console.log(`- ${p}`)
+process.exit(1)

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

@@ -2,16 +2,26 @@
  * Deterministisk dubbelkörningsdiff för poängsättningar (driftvakten på
  * 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örs: outcome, score, confidence (enum, inte
- * prosa) och inringningens golv- och takankare. Prosa (why, drivers,
- * rationale) jämförs ALDRIG.
+ * 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
+ * bara ett par utanför toleransen, se nedan.
  *
- * Skriver LIKA (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 båda inringningarna.
+ * 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
+ * en deterministisk vinnare (högsta poängen, skyddar marginalen). Den
+ * skriver aldrig om en fil och räknar aldrig fram ett medelvärde.
+ *
+ * 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
+ * båda inringningarna.
  *
  * Exit 2 = jämförelsen kan inte göras alls (dispatcherns fel, aldrig LIKA) —
- * rälsen bor i lib.mjs och delas med compare-classifications.
+ * rälsen bor i lib.mjs (delades tidigare med compare-classifications,
+ * borttagen med klassaxeln i ADR-0098).
  *
  * Användning: node compare-scores.mjs <körning1.json> <körning2.json>
  */
@@ -33,18 +43,66 @@ if (a.outcome === undefined || b.outcome === undefined) {
 const show = (v) => JSON.stringify(v ?? null)
 const diffs = []
 if (a.outcome !== b.outcome) diffs.push(`outcome: ${show(a.outcome)} ↔ ${show(b.outcome)}`)
-// confidence är ett enum (hog/medel/lag), inte prosa — samma poäng med olika
-// säkerhet är information granskaren ska se, precis som klassningens konfidenssida.
-if (a.confidence !== b.confidence)
-  diffs.push(`confidence: ${show(a.confidence)} ↔ ${show(b.confidence)}`)
+// Toleransregel (beslut 2026-08-28, ADR-0078): en poängskillnad inom 0,5 med
+// samma outcome är prisbrus, inte oenighet, oavsett confidence. Båda
+// pilotfallens eskaleringar gällde Δ = 0,25 och kostade ett helt nytt varv
+// styck. Högsta poängen gäller (skyddar marginalen); ett medelvärde räknas
+// 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.
+ */
+const ankarNr = (v) => {
+  if (v === null || v === undefined) return 0
+  const m = /^A(\d+)$/.exec(String(v))
+  return m ? Number(m[1]) : null
+}
+/**
+ * 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å
+ * samma poäng men ringar in A5/A6 respektive A11/A12 är inte prisbrus, det är
+ * precis den drift dubbelkörningen finns för att visa, även när summan råkar bli
+ * densamma.
+ */
+const nastanSammaBand = (fa, ta, fb, tb) => {
+  const [l1, h1, l2, h2] = [ankarNr(fa), ankarNr(ta), ankarNr(fb), ankarNr(tb)]
+  if ([l1, h1, l2, h2].some((n) => n === null)) return false
+  return l1 <= h2 + 1 && l2 <= h1 + 1
+}
+
+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
+// toleransen: identisk poäng med medel↔hog routade en skarp post till ESKALERA
+// på enbart ordet (ADR-0092). Utanför toleransen är den hård diff som förut.
+const konfDiff =
+  a.confidence !== b.confidence ? `confidence: ${show(a.confidence)} ↔ ${show(b.confidence)}` : null
 if (a.outcome === 'POANG' && b.outcome === 'POANG') {
-  if (a.score !== b.score) diffs.push(`score: ${show(a.score)} ↔ ${show(b.score)}`)
+  const delta = Math.abs(a.score - b.score)
+  const inomTolerans = Number.isFinite(delta) && delta <= TOLERANS
+  if (konfDiff) (inomTolerans ? tolerans : diffs).push(konfDiff)
+  if (a.score !== b.score)
+    (inomTolerans ? tolerans : diffs).push(`score: ${show(a.score)} ↔ ${show(b.score)}`)
   const fa = a.bracket?.floor?.anchor ?? null
   const fb = b.bracket?.floor?.anchor ?? null
   const ta = a.bracket?.ceiling?.anchor ?? null
   const tb = b.bracket?.ceiling?.anchor ?? null
-  if (fa !== fb) diffs.push(`bracket.floor.anchor: ${show(fa)} ↔ ${show(fb)}`)
-  if (ta !== tb) diffs.push(`bracket.ceiling.anchor: ${show(ta)} ↔ ${show(tb)}`)
+  const ankarDiffs = []
+  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)
+} else if (konfDiff) {
+  diffs.push(konfDiff)
 }
 
-reportDiffs(diffs)
+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})`)
+  for (const t of tolerans) console.log(`- ${t}`)
+  process.exit(0)
+}
+// Hårda diffar visas tillsammans med toleransraderna: granskaren ska se helheten.
+reportDiffs([...diffs, ...tolerans])

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

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 /**
- * Mekanisk efterhandskontroll av en classify- eller score-JSON mot sitt
- * underlag. Fångar det starka modeller ändå slarvar med i lång kontext:
+ * Mekanisk efterhandskontroll av en score-JSON mot sitt underlag.
+ * Classify-grenen finns kvar ENBART för äldre arkiv (före ADR-0098, då
+ * klassaxeln togs bort): inga nya classify-svar produceras, men arkiverade
+ * 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
@@ -13,15 +16,41 @@
  */
 import { readFileSync } from 'node:fs'
 
-import { refDriftWarning } from './lib.mjs'
+import { refDriftWarning, norm, quoteOk, CLASS_UTFALL, SCORE_OUTCOMES } from './lib.mjs'
 
 const argv = process.argv.slice(2)
 let expectId = null
 const idFlag = argv.indexOf('--expect-id')
 if (idFlag !== -1) {
-  expectId = argv[idFlag + 1]
+  // Ett `--expect-id` utan ett efterföljande värde (sista argumentet, eller
+  // direkt följt av en ny flagga) fick tidigare `expectId = undefined`, och
+  // `undefined != null` är `false` i JS, så kontrollen mot `request_id` längre
+  // ner hoppades då tyst över helt, exakt som om flaggan aldrig angetts.
+  // `--expect-id` är den ENDA spärren mot att arkivera en körning mot fel
+  // post (avgörande i `utvärdera`, se SKILL.md), så ett värdelöst anrop får
+  // aldrig tolkas som "ingen kontroll begärd". Det är nästan säkert ett
+  // dispatcherfel som ska stanna hårt (exit 2), inte ett tyst OK.
+  const v = argv[idFlag + 1]
+  if (v === undefined || v.startsWith('--')) {
+    console.error('--expect-id kräver ett värde')
+    process.exit(2)
+  }
+  expectId = v
   argv.splice(idFlag, 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
+// `impactPath` (eller ströks av destructuringen om positionen inte räckte
+// till) och kontrollen mot `request_id` kördes aldrig, samma
+// fail-öppet-brist som det värdelösa fallet ovan, bara via ett annat
+// missförstått flaggnamn. Varje kvarvarande `--`-token är alltså ett
+// 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>)`)
+  process.exit(2)
+}
 const [jsonPath, specPath, impactPath] = argv
 if (!jsonPath || !specPath) {
   console.error(
@@ -37,9 +66,10 @@ const warnings = []
 // i referensfilerna. Pinsen är markör-strippade (stabila över haus-releaser,
 // som stämplar om filer med paketversionen) och sökvägarna hedrar
 // CLAUDE_CONFIG_DIR — se lib.mjs.
+// klassningsinstruktion.md togs bort med klassaxeln (ADR-0098): classify-
+// grenen kontrollerar bara arkiverade filer och behöver ingen levande
+// referensfil att drifta mot.
 const EXPECTED_REFS = {
-  'request-classify/references/klassningsinstruktion.md':
-    '811f0bff62c749255e86da7ea8db0ea868ebc9df14262f9889101c110d9d14ff',
   'request-score/references/poangskala.md':
     'cb5a6c221b5d39c445ca31a427fd3f96c648388ac5441c22ea2ea5f72e1f8e31',
 }
@@ -47,9 +77,6 @@ for (const [rel, expected] of Object.entries(EXPECTED_REFS)) {
   const w = refDriftWarning(rel, expected)
   if (w) warnings.push(w)
 }
-// Markdown-betoning (**fet**, *kursiv*, `kod`) strippas före jämförelse — ett
-// citat som återges utan källans markeringar är fortfarande ordagrant.
-const norm = (s) => s.replace(/[*`]/g, '').replace(/\s+/g, ' ').trim()
 let doc
 try {
   doc = JSON.parse(readFileSync(jsonPath, 'utf8'))
@@ -69,17 +96,9 @@ try {
   process.exit(2)
 }
 
-/** Ett "ordagrant" citat får hoppa med [...] och kortas med inledande/avslutande …
- *  — varje kvarvarande segment måste vara exakt substräng av underlaget.
- *  Ett citat som blir tomt efter filtreringen är INTE ordagrant (annars vore
- *  "[...]" ett giltigt belägg för vad som helst). */
-const quoteOk = (q) => {
-  const segments = q
-    .split(/\s*\[(?:\.\.\.|…)\]\s*/)
-    .map((seg) => norm(seg.replace(/^(\.\.\.|…)|(\.\.\.|…)$/g, '')))
-    .filter((seg) => seg.length > 0)
-  return segments.length > 0 && segments.every((seg) => source.includes(seg))
-}
+// quoteOk kommer från lib.mjs; bind källan lokalt så befintliga anropsställen
+// (`ok(f.belagg)` osv.) förblir oförändrade.
+const ok = (q) => quoteOk(q, source)
 
 /** Alla strängvärden ur ett godtyckligt värde (drivers kan vara objekt). */
 const collectStrings = (v) => {
@@ -117,12 +136,48 @@ const CUSTOMER_BLACKLIST = [
 // 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
+// Vardagsidiom där "poängen" är vanlig svenska, inte skalans mekanik.
+// Maskas bort FÖRE svartlistan så att "hela poängen med posten" går fri
+// medan "poängen är 5" och "ger 5 poäng" fortfarande fälls.
+//
+// Undantaget är snävat till den STARKA idiom-markören, inte till talformen.
+// Det observerade fallet som motiverade hela undantaget är "två fönster är
+// hela poängen med posten", och "hela poängen med/i" är en konstruktion som
+// bara förekommer idiomatiskt (syftet med något). Mekaniken uttrycks
+// aldrig så: den säger "poängen är 5" eller "poängen med posten är 5",
+// aldrig "hela poängen med posten är 5". Att kräva ordet "hela" gör
+// undantaget smalast möjligt och stänger båda hålen i mekaniskt bruk på en
+// gång, oavsett om talet skrivs som siffra ("är 5") eller ord ("handlar om
+// fem enheter"). Ett tidigare försök jagade i stället en siffra i resten
+// av meningen som ENDA spärr, utan att kräva "hela", och missade just
+// ordformen (fälldes i en granskning). Siffer-lookaheaden ligger kvar som
+// extra spärr på med/i-varianten, ren belt-and-braces mot specialfall som
+// "hela poängen med de 5 posterna är 5" där "hela" ändå finns men en
+// siffra i samma mening ändå bör tippa mot BROTT.
+//
+// Konsekvens, medveten falsk positiv: "poängen med det här är att slippa
+// dubbelarbete" (idiom UTAN "hela") fälls nu som BROTT. Det kostar en
+// omdispatch där agenten kan skriva "syftet med" i stället. Det är den
+// säkra riktningen, eftersom BROTT ger en ofarlig omdispatch medan motsatt
+// fel (falsk negativ) släpper protokollmekanik hela vägen ut i kundtext.
+// Rör INTE kravet på "hela" utan att förstå detta, det ser ut som det kan
+// "lättas upp" men gör det inte utan att öppna hålet igen.
+//
+// "poängen är att" behöver ingen lookahead: "är att" följs alltid av en
+// sats, aldrig av en poängangivelse.
+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 checkCustomerText = (text, field) => {
   if (typeof text !== 'string') return
+  const masked = maskIdioms(text)
   for (const re of CUSTOMER_BLACKLIST) {
-    const m = text.match(re)
+    const m = masked.match(re)
     if (m) 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`)
 }
@@ -193,19 +248,10 @@ const checkEnvelopeKeys = (kind) => {
 }
 
 if (doc.classification !== undefined) {
-  // ---- classify ------------------------------------------------------------
-  const UTFALL = [
-    'TINY',
-    'SMALL',
-    'MEDIUM',
-    'LARGE',
-    'OFFERT',
-    'KONCEPT',
-    'DIAGNOS',
-    'TILLBAKA_TILL_SPEC',
-    'INPUT_SAKNAS',
-    'ESKALERA',
-  ]
+  // ---- classify (endast äldre arkiv, före ADR-0098) -------------------------
+  // Enumen bor i lib.mjs (CLASS_UTFALL) — delad med archive.mjs, som validerar
+  // samma fält på en ARKIVERAD körning innan set-status priced litar på den.
+  const UTFALL = CLASS_UTFALL
   // Trasig form är brottet, aldrig en krasch — utan '- '-rader har omdispatchen
   // inget att citera och stacktracen ser ut som ett scriptfel.
   const c = doc.classification && typeof doc.classification === 'object' ? doc.classification : null
@@ -233,6 +279,9 @@ if (doc.classification !== undefined) {
       'classification.fragor: saknas eller är tom — varje körning ska redovisa sina frågerader',
     )
   }
+  // Fråge-id är protokollets, aldrig modellens. Ett påhittat id ("S1-stod")
+  // passerade tidigare som "övrig rad" och kunde inte jämföras i dubbelkörningen.
+  const PROTOKOLL_IDS = ['S1', 'S2', 'S3', 'BASKLASS', 'B1', 'B2', 'B3']
   const fragorRows = Array.isArray(c.fragor) ? c.fragor : []
   for (const f0 of fragorRows) {
     if (f0 == null || typeof f0 !== 'object') {
@@ -240,6 +289,10 @@ if (doc.classification !== undefined) {
       continue
     }
     const f = f0
+    if (!PROTOKOLL_IDS.includes(f.id))
+      problems.push(
+        `fråga ${f.id}: okänt fråge-id (protokollet har exakt: ${PROTOKOLL_IDS.join(', ')})`,
+      )
     // S1–S3/B1–B3 svarar JA/NEJ; basklassraden svarar med en klass
     // (instruktionens JSON, "ordagrant och orört" — tvinga aldrig om den).
     if (/^[SB][1-3]$/i.test(f.id ?? '')) {
@@ -250,11 +303,18 @@ if (doc.classification !== undefined) {
     }
     if (typeof f.konfidens !== 'number' || f.konfidens < 0 || f.konfidens > 1)
       problems.push(`fråga ${f.id}: konfidens ${f.konfidens} utanför 0–1`)
-    // Belägg är obligatoriskt per instruktionen — saknat belägg är brottet,
-    // inte låg kvalitet.
-    if (!f.belagg || norm(f.belagg).length === 0)
-      problems.push(`fråga ${f.id}: belägg saknas (obligatoriskt, ordagrant citat)`)
-    else if (!quoteOk(f.belagg))
+    // Belägg är obligatoriskt. Saknas belagg men ankaret finns har dispatchern
+    // hoppat över resolve-steget: det är dispatcherns fel (exit 2), aldrig
+    // agentens brott, en omdispatch vore meningslös.
+    if (!f.belagg || norm(f.belagg).length === 0) {
+      if (f.belagg_ankare) {
+        console.error(`fråga ${f.id}: belagg_ankare olöst — kör resolve-anchors.mjs först`)
+        process.exit(2)
+      }
+      problems.push(
+        `fråga ${f.id}: belägg saknas (obligatoriskt: belagg_ankare i svaret, belagg efter resolve)`,
+      )
+    } else if (!ok(f.belagg))
       problems.push(
         `fråga ${f.id}: belägg är inte ordagrant citat ur underlaget: "${f.belagg.slice(0, 70)}..."`,
       )
@@ -266,15 +326,8 @@ if (doc.classification !== undefined) {
     checkCustomerText(dep, `customer.dependencies[${i}]`)
 } else if (doc.outcome !== undefined) {
   // ---- score ---------------------------------------------------------------
-  const OUTCOMES = [
-    'POANG',
-    'KONCEPT',
-    'DIAGNOS',
-    'TILLBAKA_TILL_SPEC',
-    'DELA_UPP',
-    'OVER_SKALAN',
-    'INPUT_SAKNAS',
-  ]
+  // Enumen bor i lib.mjs (SCORE_OUTCOMES) — samma delning som UTFALL ovan.
+  const OUTCOMES = SCORE_OUTCOMES
   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}"`)
@@ -290,13 +343,21 @@ if (doc.classification !== undefined) {
   } else if (doc.score != null) {
     problems.push(`score: ska vara null när outcome är ${doc.outcome}`)
   }
+  // 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())
+    if (d && typeof d === 'object' && d.ankare && !d.citat) {
+      console.error(`drivers[${i}]: ankare olöst — kör resolve-anchors.mjs först`)
+      process.exit(2)
+    }
+
   // Citat i drivers (även i objektform) ska vara ordagranna ur underlaget.
   // Både raka och typografiska citattecken räknas. Ett icke-array-värde är
   // redan fällt av POANG-kontrollen ovan — här skyddar vi bara iterationen.
   for (const [i, d] of (Array.isArray(doc.drivers) ? doc.drivers : []).entries())
     for (const str of collectStrings(d))
       for (const m of str.matchAll(/["“”„«»]([^"“”„«»]{15,})["“”„«»]/g))
-        if (!quoteOk(m[1]))
+        if (!ok(m[1]))
           problems.push(
             `drivers[${i}]: citat är inte ordagrant ur underlaget: "${m[1].slice(0, 70)}..."`,
           )

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

@@ -111,3 +111,84 @@ export function reportDiffs(diffs) {
   for (const d of diffs) console.log(`- ${d}`)
   process.exit(1)
 }
+
+/** Markdown-betoning strippas före jämförelse: ett citat som återges utan
+ *  källans fetstil- eller `kod`-markeringar är fortfarande ordagrant. */
+export const norm = (s) => s.replace(/[*`]/g, '').replace(/\s+/g, ' ').trim()
+
+/** Kanoniserar ett fakturerat modell-id: kontextsuffix som `[1m]` är samma
+ *  modell på en annan kontextnivå, aldrig en egen modell (ADR-0099). */
+export const canonicalModel = (id) => id.replace(/\[[^\]]*\]$/, '')
+
+/** Ett "ordagrant" citat får hoppa med [...] och kortas med inledande/avslutande …
+ *  Varje kvarvarande segment måste vara exakt substräng av det normaliserade
+ *  underlaget. Tomt efter filtrering = INTE ordagrant. */
+export const quoteOk = (q, normalizedSource) => {
+  const segments = q
+    .split(/\s*\[(?:\.\.\.|…)\]\s*/)
+    .map((seg) => norm(seg.replace(/^(\.\.\.|…)|(\.\.\.|…)$/g, '')))
+    .filter((seg) => seg.length > 0)
+  return segments.length > 0 && segments.every((seg) => normalizedSource.includes(seg))
+}
+
+/**
+ * Klassaxelns fullständiga utfallsenum (klassningsinstruktion.md, Steg 4) och
+ * poängaxelns fullständiga outcome-enum (request-score/SKILL.md). Delade
+ * mellan contract-check.mjs (validerar en FÄRSK körning mot protokollet) och
+ * archive.mjs (validerar en ARKIVERAD körning innan set-status priced litar
+ * på dess utfall) — en enda lista, aldrig två som kan glida isär.
+ *
+ * Detta är en ALLOW-lista (känt värde), inte bara en icke-tom-sträng-kontroll.
+ * En DENY-lista över stopputfall (se CLASS_STOP/SCORE_STOP i archive.mjs)
+ * släpper igenom en felstavning ("OFERT"), en tom sträng, eller fel skiftläge
+ * ("eskalera") eftersom inget av dem finns i deny-listan — grinden failar
+ * ÖPPET på precis den typ av trasig data en modell råkar producera. En
+ * allow-lista failar STÄNGT i stället: allt som inte är ett av de kända
+ * värdena är ett integritetsfel, aldrig ett grönt kort.
+ */
+// CLASS_UTFALL finns kvar ENBART för äldre arkiv (före ADR-0098, då
+// klassaxeln togs bort): archive.mjs och contract-check.mjs validerar
+// fortfarande arkiverade classification-filer mot den.
+export const CLASS_UTFALL = [
+  'TINY',
+  'SMALL',
+  'MEDIUM',
+  'LARGE',
+  'OFFERT',
+  'KONCEPT',
+  'DIAGNOS',
+  'TILLBAKA_TILL_SPEC',
+  'INPUT_SAKNAS',
+  'ESKALERA',
+]
+
+export const SCORE_OUTCOMES = [
+  'POANG',
+  'KONCEPT',
+  'DIAGNOS',
+  'TILLBAKA_TILL_SPEC',
+  'DELA_UPP',
+  'OVER_SKALAN',
+  'INPUT_SAKNAS',
+  // ADR-0098: flyttad hit från klassningens utfall när klassningen togs bort —
+  // utgången "en människa ska titta på det här" får aldrig saknas.
+  'ESKALERA',
+]
+
+/** Rubrikrad: fetstilsrad eller markdown-rubrik som utgör hela raden. Delad
+ *  mellan precheck (formkontroll) och report (fältvis jämförelse) så rapporten
+ *  läser specen med exakt samma regler som grinden. */
+export const isHeadingLine = (line) =>
+  /^\*\*[^*]+\*\*\s*$/.test(line.trim()) || /^#{1,6}\s+\S/.test(line.trim())
+
+export const headingRe = (h) => new RegExp(`^(\\*\\*${h}\\*\\*|#{1,6}\\s*${h})\\s*$`, 'm')
+
+/** Raderna i sektionen under rubriken `heading`, fram till nästa rubrikrad. */
+export const sectionLines = (block, heading) => {
+  const lines = block.split('\n')
+  const start = lines.findIndex((l) => headingRe(heading).test(l.trim()))
+  if (start === -1) return null
+  const rest = lines.slice(start + 1)
+  const end = rest.findIndex((l) => isHeadingLine(l))
+  return rest.slice(0, end === -1 ? rest.length : end)
+}

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

@@ -7,7 +7,7 @@
  * status (ok/fel-lista), aldrig ett protokollutfall.
  *
  * BRISTER (exit 1) är hårda formfel. VARNING är heuristik som kräver mänsklig
- * blick (klassord i analys, saknad Ingår inte) — de skrivs ut men stoppar inget.
+ * blick (poängord i analys, saknad Ingår inte) — de skrivs ut men stoppar inget.
  *
  * Användning: node precheck.mjs <arkivkatalog> [--impact]
  *   --impact  kräv och kontrollera även impact.md (bedöm-steget)
@@ -16,7 +16,7 @@
 import { readFileSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { markerStrippedSha256, refDriftWarning } from './lib.mjs'
+import { markerStrippedSha256, refDriftWarning, headingRe, sectionLines } from './lib.mjs'
 
 const dir = process.argv[2]
 const requireImpact = process.argv.includes('--impact')
@@ -31,7 +31,7 @@ const warnings = []
 // Kontraktsdriftvakt: rubrik- och vokabulärreglerna nedan speglar specformatet.
 // Pinnen är markör-strippad (stabil över haus-releaser, som stämplar om filer
 // med paketversionen) och sökvägen hedrar CLAUDE_CONFIG_DIR — se lib.mjs.
-const SPECFORMAT_SHA = '53bbb92ad6337557901e827c97a0995ff92150f88e0ede2810a28f36b51aa17c'
+const SPECFORMAT_SHA = 'e6134fd8a3c1cc9e3056c849d8834310e39d269846f2b6bec2871a83d488fc01'
 {
   const w = refDriftWarning('request-write-spec/references/specformat.md', SPECFORMAT_SHA)
   if (w) warnings.push(w)
@@ -43,19 +43,6 @@ const TIDSORD_RE = /[\p{L}]*tim(?:me|mar|marna|men)[\p{L}]*|[\p{L}]*estim(?:at|e
 // JS \b bryter vid å/ä/ö — svenska ord kräver Unicode-medvetna gränser
 // ("kräver" får aldrig matcha förbudet "kr").
 const W = (pat) => new RegExp(`(?<![\\p{L}\\d_])(?:${pat})(?![\\p{L}\\d_])`, 'iu')
-// Rubrikrad: fetstilsrad eller markdown-rubrik som utgör hela raden.
-const isHeadingLine = (line) =>
-  /^\*\*[^*]+\*\*\s*$/.test(line.trim()) || /^#{1,6}\s+\S/.test(line.trim())
-const headingRe = (h) => new RegExp(`^(\\*\\*${h}\\*\\*|#{1,6}\\s*${h})\\s*$`, 'm')
-/** Raderna i sektionen under rubriken `heading`, fram till nästa rubrikrad. */
-const sectionLines = (block, heading) => {
-  const lines = block.split('\n')
-  const start = lines.findIndex((l) => headingRe(heading).test(l.trim()))
-  if (start === -1) return null
-  const rest = lines.slice(start + 1)
-  const end = rest.findIndex((l) => isHeadingLine(l))
-  return rest.slice(0, end === -1 ? rest.length : end)
-}
 
 const read = (name, required) => {
   const p = join(dir, name)
@@ -156,19 +143,16 @@ if (requireImpact) {
       problems.push('impact.md: "## Till granskaren" saknas')
     for (const row of ['Ej verifierat', 'Avvikelse mot specen', 'Obesvarade utfallsval'])
       if (!impact.includes(`**${row}:**`)) problems.push(`impact.md: raden "**${row}:**" saknas`)
-    // Analysen får inte läcka klass eller tid. Klassord är dock en heuristik —
-    // "felklassen", "den klassen (av ändringar)" och ett ordagrant citerat
-    // kod-enum (MEDIUM/LARGE i ett repo) är legitima — så träffar blir
-    // varningar för mänsklig blick, aldrig hårda stopp. Tidsord förblir hårda.
-    const m = impact.match(W('klass(?:er|en|ning\\p{L}*)?'))
+    // Analysen får inte läcka poängsättning eller tid (ADR-0098: kontrollen
+    // gällde tidigare klassord; klassaxeln är borttagen och regeln riktas nu
+    // mot poängen, som är det analysens läsare inte får primas mot).
+    // Poängord är dock en heuristik — "poängen med ändringen" och ett
+    // ordagrant citerat kod-enum är legitima — så träffar blir varningar för
+    // mänsklig blick, aldrig hårda stopp. Tidsord förblir hårda.
+    const m = impact.match(W('poäng(?:en|er|sätt\\p{L}*|sättning\\p{L}*)?'))
     if (m)
       warnings.push(
-        `impact.md: klassord "${m[0]}" — kontrollera att analysen inte läcker klassning`,
-      )
-    const cls = impact.match(/(?<![\p{L}\d_])(TINY|SMALL|MEDIUM|LARGE|OFFERT)(?![\p{L}\d_])/u)
-    if (cls)
-      warnings.push(
-        `impact.md: klassnamnet "${cls[0]}" — läcka, eller citat av ett kod-enum? Kontrollera`,
+        `impact.md: poängord "${m[0]}" — kontrollera att analysen inte läcker poängsättning`,
       )
     const t = impact.match(TIDSORD_RE)
     if (t) problems.push(`impact.md: förbjudet tidsord "${t[0]}"`)
@@ -182,6 +166,25 @@ if (state != null) {
     const s = JSON.parse(state)
     for (const key of ['request_id', 'slug', 'title', 'status', 'runs'])
       if (!(key in s)) problems.push(`state.json: fältet "${key}" saknas`)
+    // ADR-0099 (#461): två byteidentiska runs-rader för samma fil är
+    // signaturen ett OSTÄMPLAT omtag lämnar — samma dispatch bokförd två
+    // gånger, den förkastade utan avvisad-fil och utan felrader. Heuristik
+    // (en legitim dubblett är tänkbar), därför varning, aldrig brist.
+    if (Array.isArray(s.runs)) {
+      const sedda = new Set()
+      const flaggade = new Set()
+      for (const rad of s.runs) {
+        const nyckel = JSON.stringify(rad)
+        if (sedda.has(nyckel) && !flaggade.has(nyckel)) {
+          flaggade.add(nyckel)
+          warnings.push(
+            `state.json: identiska runs-rader för ${rad?.file ?? '?'} — ett omtag ska ` +
+              'arkiveras som -avvisad med kontrollens felrader, aldrig bokföras som en dubblettrad',
+          )
+        }
+        sedda.add(nyckel)
+      }
+    }
     // Underlagsproveniens: analysen måste höra till DEN spec som ligger i
     // katalogen nu. En respec efter underkännande lämnar annars en gammal
     // analys som prissätts mot ny spec — helt osynligt utan den här kontrollen.