@haus-tech/haus-workflow 5.0.0 → 5.1.0

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

@@ -0,0 +1,622 @@
+#!/usr/bin/env node
+/**
+ * Scorerns kontrollkedja i EN process (plan requestmotor-korning, Task 1):
+ * svansrader, JSON-extraktion, deterministiska reparationer, check-lasta,
+ * resolve-anchors och contract-check, med valfri fältomskrivning av kundtext.
+ * Ersätter fyra separata anrop (och fyra orkestratorturer) per scorerkörning.
+ *
+ * Reparationerna ändrar aldrig poäng, utfall eller belägg: de rättar det
+ * dispatchern redan vet (request_id), form på enumvärden och siffersträngar,
+ * och LÄSTA-radens sökvägsform. Varje reparation skrivs som REPARERAT-rad och
+ * bokförs av anroparen i runs-radens note. Allt annat är modellfel och går
+ * till omdispatch enligt ADR-0092.
+ *
+ * Fältomskrivning (--fixa-kundtext): ett protokollterm-brott i ett rent
+ * kundtextfält kostar idag en hel scorerkörning, som dessutom kan ge en ny
+ * poäng, alltså brus i dubbelkörningen. Här skrivs bara fältet om av en
+ * billig modell (claude -p --model sonnet --max-turns 1) och kedjan körs om,
+ * högst MAX_FIXRUNDOR gånger. Råsvaren sparas via --fix-fil. Fixen är en
+ * valfri besparing: faller anropet (inget claude på PATH, exit skilt från 0,
+ * ogiltig JSON, is_error, tomt result) loggas en rad på stderr och kedjans
+ * ursprungliga BROTT står kvar, så posten går till omdispatch som vanligt.
+ * En brusten fix får aldrig fälla den obligatoriska kontrollkedjan.
+ *
+ * Användning:
+ *   node kontroll.mjs <svar.txt> <spec.md> <impact.md> --expect-id <id> --ut <ren.json>
+ *                     [--fixa-kundtext] [--claude <kommando>] [--fix-modell sonnet] [--fix-fil <rå.json>]
+ * stdout: MODELL:, LÄSTA:, [AVVIKELSE:], REPARERAT: (0..n), kedjans rader, sist
+ * "OK: kontrollkedjan håller" (exit 0) eller "BROTT (n):" + rader (exit 1).
+ * Exit 2 = användningsfel eller ett delscript med exit 2.
+ */
+import { readFileSync, writeFileSync, realpathSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import { homedir } from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import {
+  parseSvansrader,
+  extraheraJson,
+  SCORE_OUTCOMES,
+  MODES,
+  STEP_RELATIONS,
+  KONFIDENS,
+  TYPER,
+} from './lib.mjs'
+
+const HAR = path.dirname(fileURLToPath(import.meta.url))
+export const MAX_FIXRUNDOR = 1
+const VIK = { hög: 'hog', låg: 'lag', större: 'storre' }
+const KUNDTEXT_RE =
+  /^- (customer_rationale|conditions\[\d+\]|assumptions_stated\[\d+\]|alternatives\[\d+\]\.(?:label|adds)): protokollterm "([^"]+)" i kundtext$/u
+
+const VARDEFLAGGOR = ['expect-id', 'ut', 'claude', 'fix-modell', 'fix-fil', 'state']
+const BOOLFLAGGOR = ['fixa-kundtext']
+
+export const ANVANDNING = [
+  'användning: kontroll.mjs <svar.txt> <spec.md> <impact.md> --expect-id <id> --ut <ren.json>',
+  '                          [--fixa-kundtext] [--claude <kommando>] [--fix-modell sonnet] [--fix-fil <rå.json>] [--state <state.json>]',
+].join('\n')
+
+// ---------------------------------------------------------------------------
+// Rena hjälpare (testas in-process)
+// ---------------------------------------------------------------------------
+
+/** Argumenttolkning, fail-closed som svep.mjs tolkaArgv: alla saknade
+ *  flaggor namnges på en gång, en okänd flagga eller ett värdelöst
+ *  flaggvärde stoppar direkt i stället för att gissa. */
+export function tolkaArgv(argv) {
+  const positionella = []
+  const enkla = {}
+  const bool = { 'fixa-kundtext': false }
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (!a.startsWith('--')) {
+      positionella.push(a)
+      continue
+    }
+    const namn = a.slice(2)
+    if (BOOLFLAGGOR.includes(namn)) {
+      bool[namn] = true
+      continue
+    }
+    if (!VARDEFLAGGOR.includes(namn)) return { fel: `okänd flagga: --${namn}` }
+    const v = argv[i + 1]
+    if (v === undefined || v.startsWith('--')) return { fel: `--${namn} kräver ett värde` }
+    i++
+    enkla[namn] = v
+  }
+  if (positionella.length !== 3)
+    return {
+      fel: `förväntade tre positionella sökvägar (svar.txt spec.md impact.md), fick ${positionella.length}`,
+    }
+  const saknas = ['expect-id', 'ut'].filter((n) => enkla[n] === undefined)
+  if (saknas.length > 0) return { fel: `saknar ${saknas.map((n) => `--${n}`).join(', ')}` }
+  return {
+    svarPath: positionella[0],
+    specPath: positionella[1],
+    impactPath: positionella[2],
+    expectId: enkla['expect-id'],
+    utPath: enkla.ut,
+    fixaKundtext: bool['fixa-kundtext'],
+    claudeCmd: enkla.claude ?? 'claude',
+    fixModell: enkla['fix-modell'] ?? 'sonnet',
+    fixFil: enkla['fix-fil'] ?? null,
+    statePath: enkla.state ?? null,
+  }
+}
+
+const enumForm = (v, tillatna, { versal = false } = {}) => {
+  if (typeof v !== 'string') return null
+  let k = v.trim()
+  k = versal ? k.toUpperCase() : k.toLowerCase()
+  if (!versal && VIK[k]) k = VIK[k]
+  return tillatna.includes(k) && k !== v ? k : null
+}
+const talForm = (v) =>
+  typeof v === 'string' && /^\d+([.,]\d+)?$/.test(v.trim())
+    ? Number(v.trim().replace(',', '.'))
+    : null
+
+const typForm = (v) => {
+  if (typeof v !== 'string') return null
+  const k = v.trim().toLowerCase()
+  const traff = TYPER.find((t) => t.toLowerCase() === k)
+  return traff !== undefined && traff !== v ? traff : null
+}
+
+// Ankarnycklarnas alias: modellen skriver ibland den svenska stavningen
+// (samma ord som i prosan) i stället för resolve-anchors.mjs:s ASCII-schema
+// (samma stil som kalla/hog/storre). Bara nyckeln byts, aldrig värdet.
+const ANKAR_NYCKEL_ALIAS = [
+  ['delsträng', 'delstrang'],
+  ['källa', 'kalla'],
+]
+// De två fält resolve-anchors.mjs:s walk() letar efter på valfri nivå i
+// dokumentet (MAPPINGS i resolve-anchors.mjs): ankare (poängens drivers) och
+// belagg_ankare (klassaxelns frågerader, kvar för äldre arkiv).
+const ANKAR_FALT = ['ankare', 'belagg_ankare']
+
+/** Normaliserar ankarobjektens nycklar var resolve-anchors.mjs än letar
+ *  efter dem (samma fält, samma djup som dess walk()). Bara när ASCII-
+ *  nyckeln saknas; värdet kopieras ordagrant, aldrig rört. */
+const normaliseraAnkarnycklar = (node, sokvag, rader) => {
+  if (Array.isArray(node))
+    return node.map((v, i) => normaliseraAnkarnycklar(v, `${sokvag}[${i}]`, rader))
+  if (node === null || typeof node !== 'object') return node
+  const ut = {}
+  for (const [nyckel, varde] of Object.entries(node)) {
+    const barnvag = sokvag ? `${sokvag}.${nyckel}` : nyckel
+    if (
+      ANKAR_FALT.includes(nyckel) &&
+      varde &&
+      typeof varde === 'object' &&
+      !Array.isArray(varde)
+    ) {
+      let a = { ...varde }
+      for (const [gammal, ny] of ANKAR_NYCKEL_ALIAS) {
+        if (a[gammal] !== undefined && a[ny] === undefined) {
+          rader.push(`${barnvag}: nyckeln "${gammal}" normaliserad till "${ny}"`)
+          const { [gammal]: flyttat, ...rest } = a
+          a = { ...rest, [ny]: flyttat }
+        }
+      }
+      ut[nyckel] = a
+    } else {
+      ut[nyckel] = normaliseraAnkarnycklar(varde, barnvag, rader)
+    }
+  }
+  return ut
+}
+
+const stegRelationer = (bracket, prefix, rader) => {
+  if (!Array.isArray(bracket?.steps)) return bracket
+  const steps = bracket.steps.map((s, i) => {
+    const r = enumForm(s?.relation, STEP_RELATIONS)
+    if (r === null) return s
+    rader.push(`${prefix}steps[${i}].relation "${s.relation}" normaliserad till "${r}"`)
+    return { ...s, relation: r }
+  })
+  return { ...bracket, steps }
+}
+
+/** Ny doc med reparationerna applicerade plus en rad per reparation. */
+export function reparera(doc, { expectId }) {
+  const rader = []
+  let d = { ...doc }
+  if (expectId != null && d.request_id !== expectId) {
+    rader.push(`request_id "${d.request_id}" ersatt med "${expectId}" (dispatchern vet id:t)`)
+    d = { ...d, request_id: expectId }
+  }
+  const o = enumForm(d.outcome, SCORE_OUTCOMES, { versal: true })
+  if (o !== null) {
+    rader.push(`outcome "${d.outcome}" normaliserad till "${o}"`)
+    d = { ...d, outcome: o }
+  }
+  const m = enumForm(d.mode, MODES)
+  if (m !== null) {
+    rader.push(`mode "${d.mode}" normaliserad till "${m}"`)
+    d = { ...d, mode: m }
+  }
+  const c = enumForm(d.confidence, KONFIDENS)
+  if (c !== null) {
+    rader.push(`confidence "${d.confidence}" normaliserad till "${c}"`)
+    d = { ...d, confidence: c }
+  }
+  // type (#514 p1): översiktstabellens fem värden, exakt modulo skiftläge och
+  // blanksteg. Fritext hängd på värdet är inte reparerbar och faller i
+  // contract-check, avsiktligt.
+  const t = typForm(d.type)
+  if (t !== null) {
+    rader.push(`type "${d.type}" normaliserad till "${t}"`)
+    d = { ...d, type: t }
+  }
+  const s = talForm(d.score)
+  if (s !== null) {
+    rader.push(`score "${d.score}" tolkad som talet ${s}`)
+    d = { ...d, score: s }
+  }
+  if (d.bracket) d = { ...d, bracket: stegRelationer(d.bracket, 'bracket.', rader) }
+  if (Array.isArray(d.alternatives))
+    d = {
+      ...d,
+      alternatives: d.alternatives.map((alt, j) => {
+        let a = alt
+        const as = talForm(a?.score)
+        if (as !== null) {
+          rader.push(`alternatives[${j}].score "${a.score}" tolkad som talet ${as}`)
+          a = { ...a, score: as }
+        }
+        if (a?.bracket)
+          a = { ...a, bracket: stegRelationer(a.bracket, `alternatives[${j}].bracket.`, rader) }
+        return a
+      }),
+    }
+  const ankarRader = []
+  const dAnkare = normaliseraAnkarnycklar(d, '', ankarRader)
+  if (ankarRader.length > 0) {
+    d = dAnkare
+    rader.push(...ankarRader)
+  }
+  return { doc: d, reparerat: rader }
+}
+
+/** LÄSTA-radens sökvägsform: ~ expanderas, avslutande skiljetecken strippas,
+ *  relativa sökvägar löses mot underlagets katalog. Scopet prövas av
+ *  check-lasta, aldrig här. */
+export function normaliseraLasta(lasta, basDir) {
+  if (lasta == null || lasta.trim() === '' || lasta.trim() === 'inga') return 'inga'
+  return lasta
+    .split(',')
+    .map((s) => s.trim().replace(/[.,;]+$/u, ''))
+    .filter(Boolean)
+    .map((p) => (p.startsWith('~/') ? path.join(homedir(), p.slice(2)) : p))
+    .map((p) => (path.isAbsolute(p) ? p : path.resolve(basDir, p)))
+    .join(', ')
+}
+
+/** Brotten som är rena kundtextbrott: alla eller inga. Ett enda brott av
+ *  annan sort betyder att en fältomskrivning inte räcker. */
+export function kundtextBrott(brottRader) {
+  const ut = []
+  for (const rad of brottRader) {
+    const m = KUNDTEXT_RE.exec(rad.trim())
+    if (!m) return []
+    ut.push({ falt: m[1], term: m[2] })
+  }
+  return ut
+}
+
+/** Ny doc med fältet (customer_rationale, conditions[n], assumptions_stated[n],
+ *  alternatives[n].label|adds) ersatt. */
+export function ersattFalt(doc, falt, text) {
+  const m = /^(\w+)(?:\[(\d+)\])?(?:\.(\w+))?$/u.exec(falt)
+  if (!m) throw new Error(`okänt fält: ${falt}`)
+  const [, namn, idx, under] = m
+  if (idx === undefined) return { ...doc, [namn]: text }
+  const lista = [...(doc[namn] ?? [])]
+  const i = Number(idx)
+  lista[i] = under === undefined ? text : { ...lista[i], [under]: text }
+  return { ...doc, [namn]: lista }
+}
+
+/** Läser fältets nuvarande text, motsvarigheten till ersattFalt fast läsande.
+ *  Samma fältgrammatik: customer_rationale, conditions[n],
+ *  assumptions_stated[n], alternatives[n].label|adds. */
+function hamtaFalt(doc, falt) {
+  const m = /^(\w+)(?:\[(\d+)\])?(?:\.(\w+))?$/u.exec(falt)
+  if (!m) throw new Error(`okänt fält: ${falt}`)
+  const [, namn, idx, under] = m
+  if (idx === undefined) return doc[namn]
+  const post = (doc[namn] ?? [])[Number(idx)]
+  return under === undefined ? post : post?.[under]
+}
+
+export function omskrivningsPrompt(text, term) {
+  return [
+    'Skriv om följande kundtext så att ordet "' +
+      term +
+      '" (och böjningar av det) inte förekommer.',
+    'Behåll innebörden och längden. Använd inga ord som beskriver hur ett pris räknats fram',
+    '(poäng, ankare, skala, referensuppdrag, inringning, konfidens, klass, protokoll).',
+    'Svara med enbart den omskrivna texten, utan citattecken och utan kommentar.',
+    '',
+    text,
+  ].join('\n')
+}
+
+/** Läser och parsar en JSON-fil. { data } eller { fel }, aldrig ett kastat
+ *  undantag, så anroparen kan bokföra felet som ett dispatcherfel (exit 2). */
+function lasJson(path) {
+  try {
+    return { data: JSON.parse(readFileSync(path, 'utf8')) }
+  } catch (e) {
+    return { fel: `kunde inte läsa ${path}: ${e.message}` }
+  }
+}
+
+/** Skriver en JSON-fil (två mellanslags indrag, avslutande radbrytning).
+ *  null vid lyckad skrivning, annars ett felmeddelande. */
+function skrivJson(path, data) {
+  try {
+    writeFileSync(path, JSON.stringify(data, null, 2) + '\n')
+    return null
+  } catch (e) {
+    return `kunde inte skriva ${path}: ${e.message}`
+  }
+}
+
+/**
+ * Tolkar ett `claude -p --output-format json`-svar från kundtextfixen.
+ * { text } bara när CLI:n svarade utan fel OCH `result` är en icke-tom sträng.
+ * Utan den kontrollen skrevs `undefined` eller tomma strängen rakt in i
+ * kundtextfältet: en tyst radering av kundens motivering, som dessutom
+ * passerar kedjan (ingen protokollterm i en tom sträng).
+ */
+export function tolkaOmskrivning(parsed) {
+  if (parsed?.is_error === true)
+    return { fel: `CLI:n rapporterade is_error (${String(parsed.result ?? '').slice(0, 200)})` }
+  const text = parsed?.result
+  if (typeof text !== 'string') return { fel: 'svaret saknar en result-sträng' }
+  if (text.trim() === '') return { fel: 'svarets result är tomt' }
+  return { text }
+}
+
+/** Skriver om ETT kundtextfält via en billig `claude -p`. { fel }, eller
+ *  { d, svar, rad }: ny doc med fältet ersatt, råsvaret (för --fix-fil) och
+ *  REPARERAT-raden. */
+function omskrivFalt({ d, falt, term, claudeCmd, fixModell }) {
+  const svar = spawnSync(
+    claudeCmd,
+    ['-p', '--model', fixModell, '--output-format', 'json', '--max-turns', '1'],
+    { input: omskrivningsPrompt(hamtaFalt(d, falt), term), encoding: 'utf8' },
+  )
+  // spawnSync lämnar stdout och stderr som null när kommandot inte finns på
+  // PATH, så `(svar.stderr || svar.stdout).trim()` hade kastat här.
+  if (svar.error)
+    return { fel: `${claudeCmd}: omskrivning av ${falt} startade inte (${svar.error.message})` }
+  if (svar.status !== 0) {
+    const text = (svar.stderr || svar.stdout || '').trim() || `exit ${svar.status}`
+    return { fel: `${claudeCmd}: omskrivning av ${falt} misslyckades (${text})` }
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(svar.stdout)
+  } catch (e) {
+    return { fel: `${claudeCmd}: ogiltigt JSON-svar vid omskrivning av ${falt}: ${e.message}` }
+  }
+  const tolkad = tolkaOmskrivning(parsed)
+  if (tolkad.fel) return { fel: `${claudeCmd}: omskrivning av ${falt}: ${tolkad.fel}` }
+  return {
+    d: ersattFalt(d, falt, tolkad.text),
+    svar: parsed,
+    rad: `${falt} omskrivet av ${fixModell} (protokollterm "${term}")`,
+  }
+}
+
+/** Ett varvs alla fältomskrivningar. { fel } vid det första misslyckade
+ *  anropet, och dokumentet lämnas då orört: en halvskriven runda får aldrig
+ *  nå disk. */
+function skrivOmFalten(doc, brott, { claudeCmd, fixModell }) {
+  let d = doc
+  const rader = []
+  const svar = []
+  for (const { falt, term } of brott) {
+    const fix = omskrivFalt({ d, falt, term, claudeCmd, fixModell })
+    if (fix.fel) return { fel: fix.fel }
+    d = fix.d
+    svar.push(fix.svar)
+    rader.push(fix.rad)
+  }
+  return { d, rader, svar }
+}
+
+/**
+ * Upp till MAX_FIXRUNDOR varv av: läs --ut-filens aktuella skick, skriv om
+ * varje kundtextfält som bär ett brott via omskrivFalt, skriv --ut igen, kör
+ * kedjan om. Anropas bara när ALLA kvarvarande brott är kundtextbrott
+ * (anroparens ansvar).
+ *
+ * En misslyckad omskrivning är INTE ett dispatcherfel: fixen är en valfri
+ * besparing ovanpå den obligatoriska kedjan, och fälldes den som exit 2 kunde
+ * ett saknat `claude` på PATH slå ut hela kontrollkedjan. Då loggas en rad på
+ * stderr och kedjans ursprungliga BROTT returneras, så anroparen går den
+ * vanliga omdispatchvägen. Kvar som { fel } (exit 2) är bara läs- och
+ * skrivfel mot --ut-filen och ett delscript med exit 2.
+ */
+function fixaKundtextrundor({ startResultat, utPath, claudeCmd, fixModell, kedja }) {
+  let resultat = startResultat
+  const reparatRader = []
+  const raSvar = []
+  let rundor = 0
+  while (
+    resultat.brott.length > 0 &&
+    kundtextBrott(resultat.brott).length > 0 &&
+    rundor < MAX_FIXRUNDOR
+  ) {
+    // resolve-anchors kan ha skrivit om --ut-filen (lösta citat) sedan den
+    // senaste skrivningen, så aktuellt skick läses från disk.
+    const last = lasJson(utPath)
+    if (last.fel) return { fel: `${last.fel} (inför fältomskrivning)` }
+    const runda = skrivOmFalten(last.data, kundtextBrott(resultat.brott), { claudeCmd, fixModell })
+    if (runda.fel) {
+      process.stderr.write(
+        `kundtextfix misslyckades: ${runda.fel}, faller tillbaka på omdispatch\n`,
+      )
+      return { resultat, reparatRader, raSvar }
+    }
+    const skrivFel = skrivJson(utPath, runda.d)
+    if (skrivFel) return { fel: skrivFel }
+    reparatRader.push(...runda.rader)
+    raSvar.push(...runda.svar)
+    rundor++
+    resultat = kedja()
+    if (resultat.exit2) return { fel: resultat.exit2 }
+  }
+  return { resultat, reparatRader, raSvar }
+}
+
+// check-lasta.mjs och contract-check.mjs skriver sina brott som "- ...".
+// resolve-anchors.mjs skriver "OLÖST: ..."/"FLERTYDIG: ..." (inget
+// bindestreck), samma sorts brott, bara en annan yta. Normaliserar båda
+// formerna till "- <raden>" så BROTT-blocket alltid har en enhetlig radform.
+const brottFranRader = (rader) =>
+  rader
+    .filter((l) => l.startsWith('- ') || l.startsWith('OLÖST:') || l.startsWith('FLERTYDIG:'))
+    .map((l) => (l.startsWith('- ') ? l : `- ${l}`))
+
+/**
+ * Bygger `kor`/`kedja` (barnprocesserna check-lasta/resolve-anchors/contract-
+ * check), kör kedjan en gång, och vid `--fixa-kundtext` med enbart
+ * kundtextbrott (kundtextBrott returnerar tomt om ens ett brott är av annan
+ * sort, den vanliga BROTT-vägen tar då över i stället) delegerar till
+ * fixaKundtextrundor för resten. Returnerar { fel } vid ett dispatcherfel
+ * (exit 2 hos anroparen), annars { resultat, reparatRader, raSvar } där
+ * resultat är kedjans SISTA utfall.
+ */
+function korKedjaOchFixa({
+  utPath,
+  specPath,
+  impactPath,
+  lastaNorm,
+  expectId,
+  fixaKundtext,
+  claudeCmd,
+  fixModell,
+  statePath,
+}) {
+  const kor = (script, args) =>
+    spawnSync(process.execPath, [path.join(HAR, script), ...args], { encoding: 'utf8' })
+  const kedja = () => {
+    const brott = []
+    const utskrift = []
+    // Vid ett olöst/flertydigt ankare lämnar resolve-anchors --ut-filen med
+    // citat obesatt. contract-check kan då bara ge exit 2 (citat saknas,
+    // "kör resolve-anchors först"), vilket kontroll.mjs annars felaktigt
+    // läser som ett dispatcherfel i stället för det retrybara BROTT det
+    // egentligen är. Kedjan stannar därför här, kör aldrig contract-check
+    // på det skicket.
+    for (const [script, args, stoppaVidBrott] of [
+      ['check-lasta.mjs', [lastaNorm, specPath, impactPath], false],
+      ['resolve-anchors.mjs', [utPath, specPath, impactPath], true],
+      [
+        'contract-check.mjs',
+        [
+          utPath,
+          specPath,
+          impactPath,
+          '--expect-id',
+          expectId,
+          ...(statePath ? ['--state', statePath] : []),
+        ],
+        false,
+      ],
+    ]) {
+      const r = kor(script, args)
+      if (r.status === 2) return { exit2: `${script}: ${(r.stderr || r.stdout).trim()}` }
+      const rader = r.stdout.split('\n').filter(Boolean)
+      utskrift.push(...rader)
+      if (r.status !== 0) {
+        brott.push(...brottFranRader(rader))
+        if (stoppaVidBrott) return { brott, utskrift }
+      }
+    }
+    return { brott, utskrift }
+  }
+
+  let resultat = kedja()
+  if (resultat.exit2) return { fel: resultat.exit2 }
+
+  const reparatRader = []
+  let raSvar = []
+  if (fixaKundtext && resultat.brott.length > 0 && kundtextBrott(resultat.brott).length > 0) {
+    const fix = fixaKundtextrundor({ startResultat: resultat, utPath, claudeCmd, fixModell, kedja })
+    if (fix.fel) return { fel: fix.fel }
+    resultat = fix.resultat
+    reparatRader.push(...fix.reparatRader)
+    raSvar = fix.raSvar
+  }
+  return { resultat, reparatRader, raSvar }
+}
+
+/** Skriver MODELL/LÄSTA/[AVVIKELSE]-raderna och sist verdikten: antingen det
+ *  egna BROTT (1) när svaret aldrig gav JSON (`ingenJson`), eller
+ *  REPARERAT-raderna, kedjans egna rader ordagrant och OK/BROTT. Returnerar
+ *  exit-koden. */
+function skrivUtfall({ modell, lastaNorm, avvikelse, ingenJson, reparatRader, resultat }) {
+  console.log(`MODELL: ${modell ?? '-'}`)
+  console.log(`LÄSTA: ${lastaNorm}`)
+  if (avvikelse) console.log(`AVVIKELSE: ${avvikelse}`)
+  if (ingenJson) {
+    console.log('BROTT (1):')
+    console.log('- svaret innehåller ingen JSON')
+    return 1
+  }
+  for (const r of reparatRader) console.log(`REPARERAT: ${r}`)
+  for (const l of resultat.utskrift) console.log(l)
+  if (resultat.brott.length === 0) {
+    console.log('OK: kontrollkedjan håller')
+    return 0
+  }
+  console.log(`BROTT (${resultat.brott.length}):`)
+  for (const b of resultat.brott) console.log(b)
+  return 1
+}
+
+/** Läser svar.txt, delar svansraderna och extraherar JSON. { fel } vid ett
+ *  läsfel, annars { modell, lastaNorm, avvikelse, raw } där raw är null när
+ *  svaret aldrig gav JSON. */
+function lasSvar(svarPath, specPath) {
+  let svarText
+  try {
+    svarText = readFileSync(svarPath, 'utf8')
+  } catch (e) {
+    return { fel: `kunde inte läsa ${svarPath}: ${e.message}` }
+  }
+  const { body, modell, lasta, avvikelse } = parseSvansrader(svarText)
+  return {
+    modell,
+    lastaNorm: normaliseraLasta(lasta, path.dirname(specPath)),
+    avvikelse,
+    raw: extraheraJson(body),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// main (körs bara direkt, se arDirektKord längst ner)
+// ---------------------------------------------------------------------------
+
+export function main(argv) {
+  const val = tolkaArgv(argv)
+  if (val.fel) {
+    console.error(val.fel)
+    console.error(ANVANDNING)
+    return 2
+  }
+
+  const inlast = lasSvar(val.svarPath, val.specPath)
+  if (inlast.fel) {
+    console.error(inlast.fel)
+    return 2
+  }
+  const { modell, lastaNorm, avvikelse, raw } = inlast
+  if (raw === null) return skrivUtfall({ modell, lastaNorm, avvikelse, ingenJson: true })
+
+  const { doc: reparerad, reparerat } = reparera(raw, { expectId: val.expectId })
+  const skrivFel = skrivJson(val.utPath, reparerad)
+  if (skrivFel) {
+    console.error(skrivFel)
+    return 2
+  }
+
+  const kf = korKedjaOchFixa({ ...val, lastaNorm })
+  if (kf.fel) {
+    console.error(kf.fel)
+    return 2
+  }
+
+  if (val.fixFil && kf.raSvar.length > 0) {
+    const fixFilFel = skrivJson(val.fixFil, kf.raSvar)
+    if (fixFilFel) {
+      console.error(fixFilFel)
+      return 2
+    }
+  }
+
+  return skrivUtfall({
+    modell,
+    lastaNorm,
+    avvikelse,
+    reparatRader: [...reparerat, ...kf.reparatRader],
+    resultat: kf.resultat,
+  })
+}
+
+const arDirektKord = () => {
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))
+  } catch {
+    return false
+  }
+}
+if (arDirektKord()) process.exit(main(process.argv.slice(2)))