@haus-tech/haus-workflow 5.0.0 → 5.1.0

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

@@ -0,0 +1,1502 @@
+#!/usr/bin/env node
+/**
+ * Den inre processen i utvärdera-svepet, som script (plan requestmotor-korning,
+ * Task 3, ADR-0113). Fram till nu var den inre processen en sonnet-modell som
+ * läste 1300 rader SKILL.md och dispatchade tre agenter: 22 % av körningens
+ * kostnad för noll bedömningsbeslut, och protokollet bröts i precis de steg
+ * som bara var prosa. Här är samma flöde deterministisk kod: prompterna byggs
+ * ur filer på disk, varje agentsteg är en egen `claude -p --agent`-process med
+ * svaret RÅTT under `k<N>/steg/`, kontrollerna är scriptanrop och arkivet
+ * skrivs bara via `archive.mjs`. Ingen modelltur finns kvar i orkestreringen.
+ *
+ * Rollfördelningen (ADR-0092) håller: omdispatch sker ENBART på scriptbevisat
+ * brott, budgeten är EN omdispatch per agent och varv, och två körningar som
+ * skiljer sig (OLIKA) går till människan som `väntar på dom`, aldrig en
+ * tredje körning som röstar.
+ *
+ * Användning:
+ *   node korning.mjs --katalog <abs k<N>> --exp <abs experimentkatalog> --repo-rot <abs>
+ *                    --request-id <gid eller slug> --modell <modell|default>
+ *                    [--claude <kommando>] [--delar-parallellt 2]
+ *                    [--steg-timeout 1800000]
+ *
+ * Läser `<exp>/experiment.json` (`sprak` OBLIGATORISK, ADR-0114: språket
+ * gissas aldrig), `<exp>/onskemal.md` och `<exp>/kallmanifest.md`. Skriver
+ * `steg/*.json`, spec/impact/prisfiler i körningskatalogen och `korning.json`;
+ * `experiment.json` och `state.json` rörs BARA via `archive.mjs`.
+ *
+ * stdout används inte (svep sparar stderr som `stderr.log`). Exit 0 = körningen
+ * gick igenom (status `klar` sätts av svep), 1 = minst en del blev ofärdig,
+ * 2 = användningsfel, 130 = avbruten med SIGTERM eller SIGINT.
+ *
+ * SIGTERM och SIGINT dödar varje pågående `claude`-process, skriver
+ * `korning.json` ur stegen så långt och lämnar körningen som `ofärdig`. Varje
+ * agentsteg har dessutom ett väggtidstak (`--steg-timeout`, 30 minuter): ett
+ * steg som hänger utan att svara kostar inga turer men blockerar körningen.
+ */
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  rmSync,
+  realpathSync,
+} from 'node:fs'
+import { spawn, spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import {
+  parseSvansrader,
+  delaSpecifierSvar,
+  matcharModell,
+  avgorDeps,
+  schemalagg,
+  markerStrippedSha256,
+  claudeDir,
+  canonicalModel,
+  SPEC_HEADINGS,
+  SCORE_OUTCOMES,
+} from './lib.mjs'
+
+const HAR = path.dirname(fileURLToPath(import.meta.url))
+const ARCHIVE = path.join(HAR, 'archive.mjs')
+
+/** Turtak per agent. Taken är generösa men ändliga: en agent som snurrar
+ *  kostar pengar tills den dör, och en körning utan tak har inget slut. */
+export const MAX_TURER = { specifier: 120, assessor: 200, scorer: 80 }
+
+/** Modellen som skriver om kundtextfält i kontrollkedjan (kontroll.mjs
+ *  --fixa-kundtext). Pinnad där, upprepad här bara som stegets modell_begard. */
+const FIXMODELL = 'sonnet'
+/** Ett hjälpanrop CLI:n själv gör (haiku, ett dussin output-tokens) är inte
+ *  en obegärd modell. Taket skiljer hjälpanropet från en riktig körning. */
+const HJALP_TAK = 200
+const STANDARD_DELAR_PARALLELLT = 2
+/** Väggtidstaket per agentsteg, 30 minuter. Turtaket ovan hindrar en agent som
+ *  snurrar i turer, men inte en process som hänger utan att svara: den kostar
+ *  ingenting i turer och allt i väggtid, och blockerar körningen för alltid.
+ *  Taket är generöst, den längsta uppmätta assessorn låg under tio minuter. */
+export const STANDARD_STEG_TIMEOUT = 1800000
+/** Exitkoden efter ett signalavbrott, kutym för dödad av SIGINT. */
+const SIGNAL_EXIT = 130
+const VARDEFLAGGOR = [
+  'katalog',
+  'exp',
+  'repo-rot',
+  'request-id',
+  'modell',
+  'claude',
+  'delar-parallellt',
+  'steg-timeout',
+]
+
+export const ANVANDNING = [
+  'användning: korning.mjs --katalog <abs k<N>> --exp <abs experimentkatalog> --repo-rot <abs>',
+  '                        --request-id <gid eller slug> --modell <modell|default>',
+  `                        [--claude <kommando>] [--delar-parallellt ${STANDARD_DELAR_PARALLELLT}]`,
+  `                        [--steg-timeout ${STANDARD_STEG_TIMEOUT}]`,
+].join('\n')
+
+// ---------------------------------------------------------------------------
+// Rena hjälpare (testas in-process)
+// ---------------------------------------------------------------------------
+
+/**
+ * Verktygsurvalet per agent, en spegel av `tools:`-raden i
+ * `library/global/agents/request-*.md`. En headless `claude -p`-session nekar
+ * per default varje verktygsanrop som saknar en matchande allow-regel, och
+ * ingen kan svara på frågan: E2E:t (Task 7) förlorade 2,67 USD på att
+ * request-scorer nekades läsa sin egen `poangskala.md` och därför vägrade
+ * poängsätta, precis som dess kontrakt kräver. Listan sätts därför explicit i
+ * stället för att slå av behörighetslagret (`bypassPermissions` hade tillåtit
+ * allt, inklusive skrivningar in i arkivet som bara archive.mjs får göra).
+ * Assessorns "bara läsande git"-regel blir här mekanisk: fyra prefix, inte en
+ * mening i prosa som modellen kan tolka fel.
+ */
+export const AGENT_VERKTYG = {
+  'request-scorer': ['Read', 'Skill'],
+  'request-specifier': ['Read', 'Grep', 'Glob', 'Skill'],
+  'request-specifier-eskalerad': ['Read', 'Grep', 'Glob', 'Skill'],
+  'request-assessor': [
+    'Read',
+    'Grep',
+    'Glob',
+    'Skill',
+    'Bash(git ls-files:*)',
+    'Bash(git check-ignore:*)',
+    'Bash(git log:*)',
+    'Bash(git grep:*)',
+  ],
+}
+
+/** Den pinnade headless-invokationen per agentsteg: agentdefinitionen ur
+ *  ~/.claude/agents/ kör med sitt eget verktygsurval och sin egen effort,
+ *  `--model` läggs på bara som override. `default` betyder "agentens egen
+ *  modell" och får därför ingen flagga alls. `--add-dir` öppnar BARA
+ *  skills-katalogen under Claude-konfigkatalogen: det är den agenten läser
+ *  med Read (skillfiler och referensfiler ligger utanför repo-roten som är
+ *  cwd), medan agentdefinitionen läses av CLI:n själv och aldrig via Read.
+ *  Hela konfigkatalogen hade även öppnat inställningar, plugins och
+ *  projektstate för läsning utan att något steg behöver det, och
+ *  check-lasta släpper ändå bara igenom request-score-skillens egen katalog.
+ *  `--allowedTools` ligger SIST: flaggan är variadisk och skulle annars svälja
+ *  allt som kom efter den. Prompten går på stdin som förut. */
+export const agentArgs = ({ agent, modell, maxTurer }) => [
+  '-p',
+  '--agent',
+  agent,
+  '--output-format',
+  'json',
+  '--max-turns',
+  String(maxTurer),
+  '--add-dir',
+  path.join(claudeDir(), 'skills'),
+  ...(modell === 'default' ? [] : ['--model', modell]),
+  ...(AGENT_VERKTYG[agent] === undefined ? [] : ['--allowedTools', ...AGENT_VERKTYG[agent]]),
+]
+
+/** RUBRIKER-blocket: de sju literalerna ur SPEC_HEADINGS på specens språk
+ *  (ADR-0114). Tabellen bor i lib.mjs; här väljs bara kolumn. */
+const rubrikrader = (sprak) => SPEC_HEADINGS.map((r) => `**${sprak === 'engelska' ? r.en : r.sv}**`)
+
+/** Specifierns prompt, dispatch-kontraktets mall ordagrant. Ett okänt språk
+ *  kastar: scriptet gissar aldrig rubrikspråk (IPC 14001 fällde tio utkast på
+ *  just den gissningen). */
+export function specifierPrompt({
+  onskemal,
+  manifest,
+  repoRot,
+  deps,
+  sprak,
+  eskalerad,
+  eskaleringsorsak = null,
+}) {
+  if (sprak !== 'svenska' && sprak !== 'engelska')
+    throw new Error(`SPRÅK måste vara svenska eller engelska (fick "${sprak}")`)
+  return [
+    'ÖNSKEMÅL:',
+    onskemal.trim(),
+    '',
+    'KÄLLOR:',
+    manifest.trim(),
+    '',
+    `REPO-ROT: ${repoRot}`,
+    `DEPS: ${deps}`,
+    `SPRÅK: ${sprak}`,
+    'RUBRIKER:',
+    ...rubrikrader(sprak),
+    `ESKALERAD: ${eskalerad ? (eskaleringsorsak ? `ja, ${eskaleringsorsak}` : 'ja') : 'nej'}`,
+    '',
+  ].join('\n')
+}
+
+/** Assessorns prompt. KÄLLOR ligger med (hävstång 5): analysen skrevs förr
+ *  mot ett repo den fick leta i själv, medan manifestet låg färdigt bredvid. */
+export function assessorPrompt({ repoRot, deps, spec, granskarblock, manifest }) {
+  return [
+    `REPO-ROT: ${repoRot}`,
+    `DEPS: ${deps}`,
+    'KÄLLOR:',
+    manifest.trim(),
+    '',
+    'SPEC (godkänd):',
+    spec.trim(),
+    '',
+    'GRANSKARBLOCK (internt underlag, följer aldrig med i analysens kundtext):',
+    granskarblock.trim(),
+    '',
+  ].join('\n')
+}
+
+/** Scorerns prompt: underlaget per sökväg, aldrig inklistrat (ADR-0099). */
+export function scorerPrompt({ requestId, delpost, specPath, impactPath }) {
+  return [
+    `REQUEST_ID: ${requestId}`,
+    'MODE: pricing',
+    `DELPOST: ${delpost ? `ja, del ${delpost.part} av ${delpost.of}` : 'nej'}`,
+    '',
+    `SPEC: ${specPath}`,
+    `PÅVERKANSANALYS: ${impactPath}`,
+    '',
+  ].join('\n')
+}
+
+/** Omdispatchen: HELA ursprungsprompten oförändrad plus felraderna ordagrant.
+ *  En ny subagent minns inget, enbart felrader utan underlag är obrukbart. */
+export const omdispatchPrompt = (original, felrader, { endastSpec = null } = {}) =>
+  original +
+  '\n\nRÄTTNINGAR:\n' +
+  felrader.join('\n') +
+  (endastSpec ? '\nReturnera endast spec ' + endastSpec : '')
+
+const raderMed = (stdout, prefix) =>
+  String(stdout)
+    .split('\n')
+    .filter((l) => l.startsWith(prefix))
+    .map((l) => l.slice(prefix.length).trim())
+
+const bulletRader = (stdout) =>
+  String(stdout)
+    .split('\n')
+    .filter((l) => l.startsWith('- '))
+    .map((l) => l.trimEnd())
+
+/** Felraderna efter den SISTA rubriken, aldrig varje "- "-rad i utskriften och
+ *  aldrig efter den första rubriken. kontroll.mjs skriver först delscriptens
+ *  hela stdout, som redan innehåller BÅDE deras egna `BROTT (n):`-rubriker och
+ *  felraderna, och sedan sitt eget block med samma rader. Ett anrop mot
+ *  check-lasta/contract-check ger alltså två rubriker; bara den sista är
+ *  kontrollens egen sammanställning. Rökprovet 2026-09-02 gav varje brott
+ *  dubbelt i runs-radens note och i omdispatchen, först för att raderna
+ *  räknades utan rubrik alls, sedan för att slicen började vid ekot. */
+const raderEfter = (stdout, rubrikRe) => {
+  const rader = String(stdout).split('\n')
+  const i = rader.findLastIndex((l) => rubrikRe.test(l))
+  return i === -1 ? [] : bulletRader(rader.slice(i + 1).join('\n'))
+}
+
+/** precheck.mjs stdout: KANDIDAT, AVVIKELSE, VARNING, sedan OK eller
+ *  BRISTER (n) + "- "-rader. */
+export function tolkaPrecheck(stdout, status) {
+  const kandidater = raderMed(stdout, 'KANDIDAT: ')
+  const avvikelser = raderMed(stdout, 'AVVIKELSE: ')
+  return {
+    ok: status === 0,
+    kandidat: kandidater[0] ?? null,
+    avvikelse: avvikelser[0] ?? null,
+    brister: raderEfter(stdout, /^BRISTER \(\d+\):/),
+    varningar: raderMed(stdout, 'VARNING: '),
+    prisavgorande: raderMed(stdout, 'PRISAVGORANDE: ')[0] ?? null,
+  }
+}
+
+/** kontroll.mjs stdout: MODELL, LÄSTA, ev. AVVIKELSE, REPARERAT (0..n),
+ *  kedjans rader, sist OK eller BROTT (n) + "- "-rader. Exit 2 är
+ *  dispatcherfel (ett delscript föll), aldrig ett modellfel. */
+export function tolkaKontroll(stdout, status) {
+  // kontroll.mjs skriver `MODELL: -` när svansraden saknas. Strecket är dess
+  // platshållare för "saknas", aldrig ett värde: stämplas det vidare hamnar
+  // `--model -` i runs-raden i stället för "okänd".
+  const forsta = (prefix) => {
+    const v = raderMed(stdout, prefix)[0]
+    return v === undefined || v === '-' ? null : v
+  }
+  return {
+    ok: status === 0,
+    exit2: status === 2,
+    modell: forsta('MODELL: '),
+    lasta: forsta('LÄSTA: '),
+    avvikelse: forsta('AVVIKELSE: '),
+    reparerat: raderMed(stdout, 'REPARERAT: '),
+    brott: status === 0 ? [] : raderEfter(stdout, /^BROTT \(\d+\):/),
+  }
+}
+
+/** compare-scores.mjs första rad: LIKA | LIKA_TOLERANS: högsta gäller <p>
+ *  (körning <1|2>) | OLIKA (n):. Exit 2 = jämförelsen kunde inte göras. */
+export function tolkaCompare(stdout, status) {
+  const rader = bulletRader(stdout)
+  if (status === 2) return { verdikt: 'FEL', vinnare: 1, rader }
+  const forsta = String(stdout).split('\n')[0] ?? ''
+  if (forsta.startsWith('LIKA_TOLERANS')) {
+    const m = /\(körning (\d)\)/u.exec(forsta)
+    return { verdikt: 'LIKA_TOLERANS', vinnare: m ? Number(m[1]) : 1, rader }
+  }
+  if (forsta.startsWith('OLIKA')) return { verdikt: 'OLIKA', vinnare: 1, rader }
+  if (forsta.startsWith('LIKA')) return { verdikt: 'LIKA', vinnare: 1, rader }
+  return { verdikt: 'FEL', vinnare: 1, rader }
+}
+
+/** Modellverifiering per STEG mot faktureringen (ADR-0099). Steget kördes med
+ *  en modell-override, alltså måste minst en fakturerad nyckel vara den
+ *  begärda modellen; övriga nycklar får bara vara CLI:ns eget haiku-hjälpanrop
+ *  (ett dussin output-tokens). Ett STORT haiku-anrop är inget hjälpanrop utan
+ *  en riktig körning på fel modell. `default` kör agentens egen modell och
+ *  prövas aldrig. */
+export function verifieraSteg(modelUsage, modellBegard, { hjalpTak = HJALP_TAK } = {}) {
+  if (modellBegard === 'default') return { ok: true }
+  const poster = Object.entries(modelUsage ?? {}).map(([nyckel, v]) => [canonicalModel(nyckel), v])
+  const begarda = poster.filter(([k]) => matcharModell(k, modellBegard))
+  if (begarda.length === 0)
+    return {
+      ok: false,
+      orsak: `MODELL-avvikelse: ingen fakturerad nyckel är ${modellBegard} (${poster.map(([k]) => k).join(', ') || 'inga nycklar'})`,
+    }
+  const obegarda = poster
+    .filter(([k]) => !matcharModell(k, modellBegard))
+    .filter(([k, v]) => !(matcharModell(k, 'haiku') && (v?.outputTokens ?? 0) <= hjalpTak))
+    .map(([k]) => k)
+  if (obegarda.length > 0) return { ok: false, orsak: `MODELL-avvikelse: ${obegarda.join(', ')}` }
+  return { ok: true }
+}
+
+const USAGE_FALT = [
+  'input_tokens',
+  'output_tokens',
+  'cache_read_input_tokens',
+  'cache_creation_input_tokens',
+]
+const MODELUSAGE_FALT = [
+  'inputTokens',
+  'outputTokens',
+  'cacheReadInputTokens',
+  'cacheCreationInputTokens',
+  'costUSD',
+]
+
+const summera = (falt, mal, kalla) =>
+  Object.fromEntries(falt.map((f) => [f, (mal?.[f] ?? 0) + (kalla?.[f] ?? 0)]))
+
+/** Körningens summa över stegen, i de fältnamn report.mjs och
+ *  `archive.mjs proveniens` läser. En körning som föll har en verklig
+ *  kostnad, så summan skrivs även då; ett steg utan svar räknas som noll men
+ *  listas, annars försvinner det ur räkningen av dispatchade steg. */
+export function slaIhopKorning(steg) {
+  let total = 0
+  let usage = summera(USAGE_FALT, null, null)
+  let modelUsage = {}
+  let turer = 0
+  let apiMs = 0
+  const avvikelser = []
+  for (const s of steg) {
+    const svar = s.svar
+    if (!svar) continue
+    total += svar.total_cost_usd ?? 0
+    usage = summera(USAGE_FALT, usage, svar.usage)
+    for (const [nyckel, v] of Object.entries(svar.modelUsage ?? {}))
+      modelUsage = { ...modelUsage, [nyckel]: summera(MODELUSAGE_FALT, modelUsage[nyckel], v) }
+    turer += svar.num_turns ?? 0
+    apiMs += svar.duration_api_ms ?? 0
+    const v = verifieraSteg(svar.modelUsage, s.modell_begard)
+    if (!v.ok) avvikelser.push(`${s.fil}: ${v.orsak}`)
+  }
+  return {
+    korningsmotor: 'korning.mjs',
+    total_cost_usd: total,
+    usage,
+    modelUsage,
+    num_turns: turer,
+    duration_api_ms: apiMs,
+    subagent_stats: { spawned: steg.length },
+    modellverifiering: { ok: avvikelser.length === 0, avvikelser },
+    steg: steg.map((s) => ({
+      fil: s.fil,
+      agent: s.agent,
+      modell_begard: s.modell_begard,
+      total_cost_usd: s.svar?.total_cost_usd ?? 0,
+      usage: summera(USAGE_FALT, null, s.svar?.usage),
+      num_turns: s.svar?.num_turns ?? 0,
+      wall_ms: s.wall_ms ?? null,
+      is_error: s.svar ? s.svar.is_error === true : true,
+    })),
+  }
+}
+
+/** Körningens status ur delarnas: den allvarligaste vinner. `ofärdig` är
+ *  avbruten data, `väntar på dom` kräver en människa, `stopp` är ett resultat.
+ *  `null` betyder att svep får sätta `klar`. */
+export function sammanvagdStatus(delStatusar) {
+  for (const s of ['ofärdig', 'väntar på dom', 'stopp']) if (delStatusar.includes(s)) return s
+  return null
+}
+
+const DOUBLE_RUN = { LIKA: 'bekräftad', LIKA_TOLERANS: 'tolerans', OLIKA: 'olika' }
+
+/** Filnamnen för ett arkiveringsvarv: huvudfilen bär den gällande poängen,
+ *  den andra körningen läggs som `-run2`. Vid tolerans är vinnaren den högsta
+ *  poängen, inte körning 1. */
+export const filnamnForVarv = ({ n, verdikt, vinnare }) => ({
+  huvud: `score-pricing-v${n}.json`,
+  run2: `score-pricing-v${n}-run2.json`,
+  huvudAr: vinnare,
+  doubleRun: DOUBLE_RUN[verdikt] ?? 'olika',
+})
+
+/** Ett stopputfall är allt utom POANG: posten får inget pris och går inte
+ *  vidare (ADR-0098). */
+export const arStopputfall = (outcome) => SCORE_OUTCOMES.includes(outcome) && outcome !== 'POANG'
+
+/** Stoppet efter formkontrollen i speca (ADR-0105, ADR-0118): en kandidat
+ *  routas till sitt utfall; ett prisavgörande öppet val går tillbaka till
+ *  specen en gång och därefter till ESKALERA, aldrig en tredje specrunda. */
+export const routaSpecStopp = ({ kandidat, prisavgorande, respecVarv }) => {
+  if (kandidat) return { utfall: kandidat, kalla: 'spec.md', orsak: null }
+  if (prisavgorande === null || prisavgorande === undefined) return null
+  if ((respecVarv ?? 0) >= 1)
+    return {
+      utfall: 'ESKALERA',
+      kalla: 'granskarblock.md',
+      orsak: `prisavgörande val kvarstår efter respec: ${prisavgorande}`,
+    }
+  return { utfall: 'TILLBAKA_TILL_SPEC', kalla: 'granskarblock.md', orsak: prisavgorande }
+}
+
+/** Brottraderna för EN scorerkörning. En kedja utan brottrader är ändå fallen
+ *  i två fall, och båda måste bära en rad, annars räknas körningen som giltig
+ *  och arkiveras som gällande pris. Utan ren JSON finns ingen `doc.outcome`
+ *  att prissätta. Och en kedja som slutade skilt från 0 (`ok === false`) utan
+ *  ett tolkbart BROTT-block har kraschat i sig själv: en grind som failar
+ *  öppet när den själv går sönder är ingen grind. */
+export function scorerBrott(brott, { doc, ok }) {
+  if (brott.length > 0) return brott
+  if (doc === null) return ['- kontrollkedjan lämnade ingen ren JSON']
+  if (ok === false) return ['- kontrollkedjan föll utan tolkbart BROTT-block']
+  return []
+}
+
+/** Dubbelkörningen räknas för varje prisbärande utfall: POANG >= 1 (ADR-0098)
+ *  och OVER_SKALAN, som skickar posten till manuell offert på en enda körning
+ *  om den inte prövas två gånger (ADR-0116, #503). DELA_UPP körs om per del. */
+export const behoverDubbelkorning = (doc) =>
+  doc?.outcome === 'OVER_SKALAN' ||
+  (doc?.outcome === 'POANG' && typeof doc?.score === 'number' && doc.score >= 1)
+
+// ---------------------------------------------------------------------------
+// Mekaniken (verifieras i rökprovet och i E2E, aldrig mot ett fejkat claude)
+// ---------------------------------------------------------------------------
+
+/** All loggning går på stderr; stdout används inte alls, svep sparar stderr
+ *  som `stderr.log` bredvid körningen. */
+const logg = (rad) =>
+  process.stderr.write(`[korning] ${new Date().toISOString().slice(11, 19)} ${rad}\n`)
+
+const arkiv = (args, ctx) =>
+  spawnSync(process.execPath, [ARCHIVE, ...args], { encoding: 'utf8', cwd: ctx.repoRot })
+const script = (namn, args, ctx) =>
+  spawnSync(process.execPath, [path.join(HAR, namn), ...args], {
+    encoding: 'utf8',
+    cwd: ctx.repoRot,
+  })
+const felText = (r) => (r.stderr || r.stdout || '').trim() || `exit ${r.status}`
+const idag = () => new Date().toISOString().slice(0, 10)
+const lasFil = (p) => {
+  try {
+    return readFileSync(p, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+/** Argumenttolkning, fail-closed som svep.mjs och kontroll.mjs: 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. */
+function tolkaArgv(argv) {
+  const enkla = {}
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (!a.startsWith('--')) return { fel: `oväntat argument: ${a}` }
+    const namn = a.slice(2)
+    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
+  }
+  const obligatoriska = ['katalog', 'exp', 'repo-rot', 'request-id', 'modell']
+  const saknas = obligatoriska.filter((n) => enkla[n] === undefined)
+  if (saknas.length > 0) return { fel: `saknar ${saknas.map((n) => `--${n}`).join(', ')}` }
+  const relativa = ['katalog', 'exp', 'repo-rot'].filter((n) => !path.isAbsolute(enkla[n]))
+  if (relativa.length > 0)
+    return { fel: `${relativa.map((n) => `--${n}`).join(', ')} måste vara absoluta sökvägar` }
+  const takText = enkla['delar-parallellt'] ?? String(STANDARD_DELAR_PARALLELLT)
+  if (!/^\d+$/.test(takText) || Number(takText) < 1)
+    return { fel: `--delar-parallellt måste vara ett heltal >= 1 (fick "${takText}")` }
+  const timeoutText = enkla['steg-timeout'] ?? String(STANDARD_STEG_TIMEOUT)
+  if (!/^\d+$/.test(timeoutText) || Number(timeoutText) < 1)
+    return { fel: `--steg-timeout måste vara ett heltal >= 1 (fick "${timeoutText}")` }
+  return {
+    katalog: enkla.katalog,
+    exp: enkla.exp,
+    repoRot: enkla['repo-rot'],
+    requestId: enkla['request-id'],
+    modell: enkla.modell,
+    claude: enkla.claude ?? 'claude',
+    delarParallellt: Number(takText),
+    stegTimeout: Number(timeoutText),
+  }
+}
+
+/** Underlaget på disk. Språket är OBLIGATORISKT (ADR-0114): utan det finns
+ *  ingen rubrikuppsättning att be om, och en gissning fäller hela specvarvet. */
+function lasUnderlag(val) {
+  let experiment
+  try {
+    experiment = JSON.parse(readFileSync(path.join(val.exp, 'experiment.json'), 'utf8'))
+  } catch (e) {
+    return { fel: `kunde inte läsa ${path.join(val.exp, 'experiment.json')}: ${e.message}` }
+  }
+  const sprak = experiment?.sprak
+  if (sprak !== 'svenska' && sprak !== 'engelska')
+    return {
+      fel: 'sprak saknas i experiment.json, sätt med archive.mjs experiment --satt sprak=svenska|engelska',
+    }
+  const onskemal = lasFil(path.join(val.exp, 'onskemal.md'))
+  const manifest = lasFil(path.join(val.exp, 'kallmanifest.md'))
+  const saknas = [
+    ...(onskemal === null ? ['onskemal.md'] : []),
+    ...(manifest === null ? ['kallmanifest.md'] : []),
+  ]
+  if (saknas.length > 0) return { fel: `${val.exp} saknar ${saknas.join(', ')}` }
+  if (!existsSync(path.join(val.katalog, 'state.json')))
+    return {
+      fel: `${val.katalog} saknar state.json. Körningskatalogen skapas av archive.mjs ny-korning`,
+    }
+  return {
+    onskemal,
+    manifest,
+    sprak,
+    eskalerad: experiment.eskalerad === true,
+    eskaleringsorsak:
+      typeof experiment.eskaleringsorsak === 'string' ? experiment.eskaleringsorsak : null,
+    deps: avgorDeps(val.repoRot),
+  }
+}
+
+/** Orsaken till att ett agentsteg räknas som fallet, eller null. Ordningen är
+ *  från grövst till finast: en process som inte startade säger inget om
+ *  modellen, en tom text säger inget om innehållet. `tidsgransMs` sätts när
+ *  steget dödades av väggtidstaket och kommer före exitkoden: koden är då
+ *  bara spåret efter vår egen SIGTERM och döljer den verkliga orsaken. */
+export const stegOrsak = ({ spawnfel, tidsgransMs = null, exitCode, svar, text, verifiering }) => {
+  if (spawnfel) return `processen startade inte: ${spawnfel}`
+  if (tidsgransMs !== null) return `tidsgräns ${tidsgransMs} ms`
+  if (exitCode !== 0) return `exit ${exitCode === null ? 'okänd' : exitCode}`
+  if (svar === null) return 'svaret gick inte att tolka som JSON'
+  if (svar.is_error === true)
+    return `CLI:n rapporterade is_error (${String(svar.result ?? '').slice(0, 200)})`
+  if (text.trim() === '') return 'tomt svar'
+  if (!verifiering.ok) return verifiering.orsak
+  return null
+}
+
+/** Stegets råa stdout tolkad: filen skrivs (även vid fel; tom stdout skriver
+ *  ingen fil), JSON parsas, modellen verifieras och orsaken avgörs. */
+function tolkaSteg({ stdout, stegFil, modell, spawnfel, tidsgransMs, exitCode }) {
+  if (stdout.length > 0) writeFileSync(stegFil, stdout)
+  let svar = null
+  try {
+    svar = JSON.parse(stdout)
+  } catch {
+    svar = null
+  }
+  const text = typeof svar?.result === 'string' ? svar.result : ''
+  const verifiering = verifieraSteg(svar?.modelUsage, modell)
+  return {
+    svar,
+    text,
+    verifiering,
+    orsak: stegOrsak({ spawnfel, tidsgransMs, exitCode, svar, text, verifiering }),
+  }
+}
+
+/** Ett agentsteg: en egen `claude -p --agent`-process med prompten på stdin,
+ *  svaret RÅTT i `steg/<fil>` och klockan runt den. Barnet läggs i `ctx.barn`
+ *  så signalhanteraren kan döda det: en dödad korning.mjs får aldrig lämna
+ *  betalda `claude`-processer efter sig. Väggtidstaket (`--steg-timeout`)
+ *  dödar ett steg som hänger utan att svara. Anroparen avgör vad ett fallet
+ *  steg betyder. */
+function korAgent({ agent, modell, prompt, fil, maxTurer, ctx }) {
+  return new Promise((los) => {
+    const start = Date.now()
+    const stegFil = path.join(ctx.katalog, fil)
+    let stdout = ''
+    let stderr = ''
+    let klar = false
+    let tidsgransMs = null
+    let timer = null
+    const avsluta = ({ exitCode, spawnfel = null }) => {
+      if (klar) return
+      klar = true
+      if (timer !== null) clearTimeout(timer)
+      const wall_ms = Date.now() - start
+      const t = tolkaSteg({ stdout, stegFil, modell, spawnfel, tidsgransMs, exitCode })
+      ctx.samla({ fil, agent, modell_begard: modell, svar: t.svar, wall_ms })
+      if (t.orsak !== null && stderr.trim() !== '')
+        logg(`${fil} stderr: ${stderr.trim().slice(0, 200)}`)
+      logg(
+        `STEG ${fil} ${agent} ${modell} ${wall_ms}ms ${t.orsak === null ? 'ok' : `fallet: ${t.orsak}`}`,
+      )
+      los({ ...t, exitCode, wall_ms, ok: t.orsak === null })
+    }
+    let barn
+    try {
+      barn = spawn(ctx.claude, agentArgs({ agent, modell, maxTurer }), {
+        cwd: ctx.repoRot,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+    } catch (e) {
+      avsluta({ exitCode: null, spawnfel: e.message })
+      return
+    }
+    ctx.barn.add(barn)
+    timer = setTimeout(() => {
+      tidsgransMs = ctx.stegTimeout
+      logg(`STEG ${fil} dödas: tidsgräns ${ctx.stegTimeout} ms`)
+      barn.kill('SIGTERM')
+    }, ctx.stegTimeout)
+    barn.stdout.on('data', (d) => {
+      stdout += d
+    })
+    barn.stderr.on('data', (d) => {
+      stderr += d
+    })
+    barn.on('error', (e) => {
+      ctx.barn.delete(barn)
+      avsluta({ exitCode: null, spawnfel: e.message })
+    })
+    barn.on('close', (code) => {
+      ctx.barn.delete(barn)
+      avsluta({ exitCode: code })
+    })
+    barn.stdin.on('error', () => {})
+    barn.stdin.end(prompt)
+  })
+}
+
+/** Den fakturerade nyckeln för ETT steg, ur stegets eget modelUsage (ADR-0113; #510 a). addRun skickar den som --fakturerad. */
+export function fakturerad(svar, modell) {
+  const nycklar = Object.keys(svar?.modelUsage ?? {}).map(canonicalModel)
+  if (modell === 'default')
+    return nycklar.find((k) => !matcharModell(k, 'haiku')) ?? nycklar[0] ?? null
+  return nycklar.find((k) => matcharModell(k, modell)) ?? null
+}
+
+/** `--ref <namn>=<hash>` över en referensfil i Claude-konfigkatalogen. En fil
+ *  som inte går att läsa ger INGEN flagga: en påhittad hash ser lika giltig ut
+ *  som en riktig. */
+function refFlagga(relSokvag, namn) {
+  try {
+    return ['--ref', `${namn}=${markerStrippedSha256(path.join(claudeDir(), relSokvag))}`]
+  } catch (e) {
+    logg(`VARNING kunde inte hasha ${relSokvag}: ${e.message}. Runs-raden får ingen --ref`)
+    return []
+  }
+}
+
+const SPEC_REF = () =>
+  refFlagga('skills/request-write-spec/references/specformat.md', 'references/specformat.md')
+const SCORE_REF = () => refFlagga('skills/request-score/references/poangskala.md', 'poangskala.md')
+
+/** En runs-rad. Arkivet är append-only och äger sina egna vägransregler; en
+ *  vägrad stämpling loggas men fäller aldrig körningen, kvittot på vad som
+ *  hände ligger kvar i steg/. */
+function addRun(dir, rad, ctx) {
+  const r = arkiv(
+    [
+      'add-run',
+      dir,
+      '--file',
+      rad.fil,
+      '--skill',
+      rad.skill,
+      '--agent',
+      rad.agent,
+      '--model',
+      rad.model ?? 'okänd',
+      ...(rad.fakt ? ['--fakturerad', rad.fakt] : []),
+      ...(rad.ref ?? []),
+      ...(rad.note ? ['--note', rad.note] : []),
+      ...(rad.doubleRun ? ['--double-run', rad.doubleRun] : []),
+      ...(rad.supersededBy ? ['--superseded-by', rad.supersededBy] : []),
+    ],
+    ctx,
+  )
+  if (r.status !== 0) logg(`VARNING add-run ${rad.fil}: ${felText(r)}`)
+  return r.status === 0
+}
+
+/** Ett ledigt filnamn: en andra avvisad läggning samma dag får -2, aldrig
+ *  samma namn som den första (arkivet skriver aldrig över ett kvitto). */
+function ledigtNamn(dir, bas, ext) {
+  let namn = `${bas}${ext}`
+  for (let i = 2; existsSync(path.join(dir, namn)); i++) namn = `${bas}-${i}${ext}`
+  return namn
+}
+
+/** Ett förkastat textsteg bokförs alltid (ADR-0099): dokumentet döps om med
+ *  `-avvisad-<datum>` och får en egen runs-rad med kontrollens felrader. */
+function avvisaDokument(dir, bas, brister, rad, ctx) {
+  const namn = ledigtNamn(dir, `${bas}-avvisad-${idag()}`, '.md')
+  try {
+    renameSync(path.join(dir, `${bas}.md`), path.join(dir, namn))
+  } catch (e) {
+    logg(`VARNING kunde inte döpa om ${bas}.md: ${e.message}`)
+    return null
+  }
+  addRun(dir, { ...rad, fil: namn, note: brister.map((b) => b.replace(/^- /, '')).join('; ') }, ctx)
+  return namn
+}
+
+/** Delkatalogerna för en bunt: skapas av `archive.mjs ny-del`, aldrig av den
+ *  inre processen själv (buntregeln i Experimentytan, ADR-0107 beslut 4).
+ *  Del 1 ligger ALDRIG i körningsroten. */
+function skapaDelar(antal, ctx) {
+  const delar = []
+  for (let i = 1; i <= antal; i++) {
+    const r = arkiv(
+      [
+        'ny-del',
+        ctx.katalog,
+        '--typ',
+        'bundle',
+        '--part',
+        String(i),
+        '--of',
+        String(antal),
+        '--request-id',
+        ctx.requestId,
+      ],
+      ctx,
+    )
+    if (r.status !== 0) return { fel: `ny-del ${i}/${antal}: ${felText(r)}` }
+    delar.push({ dir: r.stdout.trim(), delpost: { part: i, of: antal }, nr: i })
+  }
+  return { delar }
+}
+
+/** Granskarblocken i ett specifiersvar (ADR-0118): ett per spec. Ett delat
+ *  block över en bunt och ett saknat block är brister (omdispatch); två delar
+ *  med bytevis lika block är en varning, två små delar kan legitimt ha
+ *  tom/inga/nej rakt igenom. */
+export const granskaBuntBlock = ({ specar, delat }) => {
+  const brister = []
+  const varningar = []
+  if (delat && specar.length > 1)
+    brister.push(
+      '- granskarblock delat över bunten, ett per spec krävs: skriv "## Till granskaren" direkt efter varje spec',
+    )
+  specar.forEach((s, i) => {
+    if (s.granskarblock === null) brister.push(`- spec ${i + 1} saknar Till granskaren-block`)
+  })
+  for (let i = 0; i < specar.length; i++)
+    for (let j = i + 1; j < specar.length; j++)
+      if (specar[i].granskarblock !== null && specar[i].granskarblock === specar[j].granskarblock)
+        varningar.push(`del ${i + 1} och del ${j + 1} har identiska granskarblock`)
+  return { brister, varningar }
+}
+
+/** Specifiervarvet: ett agentsteg, uppdelning i specar, delkataloger vid bunt
+ *  och en stämplad spec.md per del. Returnerar `{ fel }` när körningen inte
+ *  kan fortsätta. */
+async function korSpecifier(ctx) {
+  const agent = ctx.eskalerad ? 'request-specifier-eskalerad' : 'request-specifier'
+  const prompt = specifierPrompt({
+    onskemal: ctx.onskemal,
+    manifest: ctx.manifest,
+    repoRot: ctx.repoRot,
+    deps: ctx.deps,
+    sprak: ctx.sprak,
+    eskalerad: ctx.eskalerad,
+    eskaleringsorsak: ctx.eskaleringsorsak,
+  })
+  const res = await korAgent({
+    agent,
+    modell: ctx.modell,
+    prompt,
+    fil: 'steg/01-specifier.json',
+    maxTurer: MAX_TURER.specifier,
+    ctx,
+  })
+  if (!res.ok) return { fel: `specifier: ${res.orsak}` }
+  let { body, modell: svansModell } = parseSvansrader(res.text)
+  let uppdelat = delaSpecifierSvar(body)
+  if (uppdelat.specar.length === 0) return { fel: 'specifier: svaret innehåller ingen spec' }
+  let block = granskaBuntBlock(uppdelat)
+  for (const v of block.varningar) logg(`VARNING specifier: ${v}`)
+  let meta = { agent, svansModell, fakt: fakturerad(res.svar, ctx.modell) }
+  // Bristerna (delat block, saknat block) rättas med EN omdispatch av HELA
+  // specifierprompten: inget är skrivet ännu, så det finns inget att peka
+  // om per del (ADR-0118).
+  if (block.brister.length > 0) {
+    const omRes = await korAgent({
+      agent,
+      modell: ctx.modell,
+      prompt: omdispatchPrompt(prompt, block.brister),
+      fil: 'steg/01b-specifier-omdispatch.json',
+      maxTurer: MAX_TURER.specifier,
+      ctx,
+    })
+    if (!omRes.ok) return { fel: `specifier: ${omRes.orsak}` }
+    ;({ body, modell: svansModell } = parseSvansrader(omRes.text))
+    uppdelat = delaSpecifierSvar(body)
+    if (uppdelat.specar.length === 0)
+      return { fel: 'specifier: omdispatchen innehåller ingen spec' }
+    block = granskaBuntBlock(uppdelat)
+    for (const v of block.varningar) logg(`VARNING specifier: ${v}`)
+    if (block.brister.length > 0)
+      return { fel: `specifier: ${block.brister.map((b) => b.replace(/^- /, '')).join('; ')}` }
+    meta = { agent, svansModell, fakt: fakturerad(omRes.svar, ctx.modell) }
+  }
+  const { specar } = uppdelat
+  const uppdelning =
+    specar.length === 1
+      ? { delar: [{ dir: ctx.katalog, delpost: null, nr: 1 }] }
+      : skapaDelar(specar.length, ctx)
+  if (uppdelning.fel) return { fel: uppdelning.fel }
+  for (const [i, del] of uppdelning.delar.entries())
+    skrivSpec(del, specar[i].spec, specar[i].granskarblock, meta, ctx)
+  logg(`SPECIFIER ${specar.length} spec(ar), ${uppdelning.delar.length} del(ar)`)
+  return { delar: uppdelning.delar, prompt, agent, meta }
+}
+
+/** spec.md + granskarblock.md i en del, med runs-raden. Granskarblocket är
+ *  internt underlag och stämplas inte: bara arkivkontraktets filer får rader. */
+function skrivSpec(del, spec, granskarblock, meta, ctx) {
+  writeFileSync(path.join(del.dir, 'spec.md'), spec.trim() + '\n')
+  if (granskarblock)
+    writeFileSync(path.join(del.dir, 'granskarblock.md'), granskarblock.trim() + '\n')
+  else logg(`VARNING ${path.basename(del.dir)}: svaret bar inget Till granskaren-block`)
+  addRun(
+    del.dir,
+    {
+      fil: 'spec.md',
+      skill: 'request-write-spec',
+      agent: meta.agent,
+      model: meta.svansModell,
+      fakt: meta.fakt,
+      ref: SPEC_REF(),
+    },
+    ctx,
+  )
+}
+
+/** Delens namn i loggen och delraderna: sökvägen relativt körningskatalogen,
+ *  eller katalognamnet när delen ÄR körningsroten. */
+const delNamn = (ctx, dir) => path.relative(ctx.katalog, dir) || path.basename(dir)
+
+/** Ett precheck-anrop: varningarna loggas, brister och kandidat tolkas, och en
+ *  exitkod skild från 0 UTAN tolkbart BRISTER-block är ett fel, aldrig ett
+ *  godkänt steg. En grind som failar öppet när den själv kraschar är ingen
+ *  grind. */
+function korPrecheck(del, ctx, { impact = false } = {}) {
+  const r = script('precheck.mjs', [del.dir, ...(impact ? ['--impact'] : [])], ctx)
+  const tolkad = tolkaPrecheck(r.stdout, r.status)
+  const etikett = `precheck${impact ? ' --impact' : ''}`
+  for (const v of tolkad.varningar) logg(`VARNING ${etikett} ${delNamn(ctx, del.dir)}: ${v}`)
+  if (tolkad.ok || tolkad.brister.length > 0) return { ...tolkad, fel: null }
+  const svans = (r.stderr || r.stdout || '').trim().split('\n').slice(-3).join(' | ').slice(0, 200)
+  return { ...tolkad, fel: `${etikett}: exit ${r.status}${svans ? ` (${svans})` : ''}` }
+}
+
+/** Formkontrollen per del (speca steg 6): brister rättas med EN omdispatch,
+ *  en kandidat routas till sitt stopputfall. Brister prövas först: en
+ *  kandidatmarkör i fel form är en brist, inte ett utfall. */
+async function prechecka(del, spec, ctx) {
+  let r = korPrecheck(del, ctx)
+  if (r.fel) return { status: 'ofärdig', orsak: r.fel }
+  if (r.brister.length > 0) {
+    const om = await specOmdispatch(del, spec, r.brister, ctx)
+    if (om.fel) return { status: 'ofärdig', orsak: `spec: ${om.fel}` }
+    r = korPrecheck(del, ctx)
+    if (r.fel) return { status: 'ofärdig', orsak: r.fel }
+    if (r.brister.length > 0) {
+      // Raden stämplas med OMDISPATCHENS modell: det är den läggningen som
+      // avvisas nu, inte den första.
+      avvisaDokument(
+        del.dir,
+        'spec',
+        r.brister,
+        {
+          skill: 'request-write-spec',
+          agent: spec.agent,
+          model: om.meta.svansModell,
+          fakt: om.meta.fakt,
+          ref: SPEC_REF(),
+        },
+        ctx,
+      )
+      return {
+        status: 'ofärdig',
+        orsak: `spec: ${r.brister.map((b) => b.replace(/^- /, '')).join('; ')}`,
+      }
+    }
+  }
+  const state = lasJson(path.join(del.dir, 'state.json'))
+  const stopp = routaSpecStopp({
+    kandidat: r.kandidat,
+    prisavgorande: r.prisavgorande,
+    respecVarv: state?.respec_varv ?? 0,
+  })
+  if (stopp) {
+    const s = arkiv(
+      [
+        'stopp',
+        del.dir,
+        '--utfall',
+        stopp.utfall,
+        '--kalla',
+        stopp.kalla,
+        ...(stopp.utfall === 'ESKALERA' ? ['--orsak', stopp.orsak] : []),
+      ],
+      ctx,
+    )
+    if (s.status !== 0) return { status: 'ofärdig', orsak: `stopp: ${felText(s)}` }
+    logg(`STOPP ${delNamn(ctx, del.dir)} ${stopp.utfall}${stopp.orsak ? `: ${stopp.orsak}` : ''}`)
+    return {
+      status: 'stopp',
+      orsak: stopp.orsak ? `${stopp.utfall}: ${stopp.orsak}` : stopp.utfall,
+    }
+  }
+  return { status: null }
+}
+
+/** EN omdispatch av specifiern (ADR-0092): hela ursprungsprompten plus
+ *  felraderna. Vid bunt begärs bara den fallna delens spec tillbaka. */
+async function specOmdispatch(del, spec, brister, ctx) {
+  avvisaDokument(
+    del.dir,
+    'spec',
+    brister,
+    {
+      skill: 'request-write-spec',
+      agent: spec.agent,
+      model: spec.meta.svansModell,
+      fakt: spec.meta.fakt,
+      ref: SPEC_REF(),
+    },
+    ctx,
+  )
+  const prompt = omdispatchPrompt(spec.prompt, brister, {
+    endastSpec: del.delpost ? del.delpost.part : null,
+  })
+  const fil = `steg/02-specifier-omdispatch-${del.delpost ? `del${del.delpost.part}` : 'rot'}.json`
+  const res = await korAgent({
+    agent: spec.agent,
+    modell: ctx.modell,
+    prompt,
+    fil,
+    maxTurer: MAX_TURER.specifier,
+    ctx,
+  })
+  if (!res.ok) return { fel: res.orsak }
+  const { body, modell: svansModell } = parseSvansrader(res.text)
+  const { specar } = delaSpecifierSvar(body)
+  if (specar.length === 0) return { fel: 'omdispatchen innehåller ingen spec' }
+  const meta = { agent: spec.agent, svansModell, fakt: fakturerad(res.svar, ctx.modell) }
+  skrivSpec(del, specar[0].spec, specar[0].granskarblock, meta, ctx)
+  return { ok: true, meta }
+}
+
+/** Analysen: ett agentsteg, impact.md med runs-rad, formkontroll med EN
+ *  omdispatch, och motsägelse mot specen som stopputfall (ADR-0106). */
+async function korAssessor(del, ctx) {
+  const spec = lasFil(path.join(del.dir, 'spec.md'))
+  if (spec === null) return { status: 'ofärdig', orsak: 'impact: spec.md saknas' }
+  const prompt = assessorPrompt({
+    repoRot: ctx.repoRot,
+    deps: ctx.deps,
+    spec,
+    granskarblock: lasFil(path.join(del.dir, 'granskarblock.md')) ?? 'inget granskarblock',
+    manifest: ctx.manifest,
+  })
+  const fil = `steg/1${del.nr}-assessor.json`
+  const res = await korAgent({
+    agent: 'request-assessor',
+    modell: ctx.modell,
+    prompt,
+    fil,
+    maxTurer: MAX_TURER.assessor,
+    ctx,
+  })
+  if (!res.ok) return { status: 'ofärdig', orsak: `impact: ${res.orsak}` }
+  const meta = skrivImpact(del, res, ctx)
+  let p = korPrecheck(del, ctx, { impact: true })
+  if (p.fel) return { status: 'ofärdig', orsak: p.fel }
+  if (p.brister.length > 0) {
+    const om = await impactOmdispatch(del, prompt, p.brister, meta, ctx)
+    if (om.fel) return { status: 'ofärdig', orsak: `impact: ${om.fel}` }
+    p = korPrecheck(del, ctx, { impact: true })
+    if (p.fel) return { status: 'ofärdig', orsak: p.fel }
+    if (p.brister.length > 0) {
+      avvisaDokument(del.dir, 'impact', p.brister, impactRad(om.svansModell, om.fakt), ctx)
+      return {
+        status: 'ofärdig',
+        orsak: `impact: ${p.brister.map((b) => b.replace(/^- /, '')).join('; ')}`,
+      }
+    }
+  }
+  if (p.avvikelse === 'motsägelse') {
+    const s = arkiv(
+      ['stopp', del.dir, '--utfall', 'TILLBAKA_TILL_SPEC', '--kalla', 'impact.md'],
+      ctx,
+    )
+    if (s.status !== 0) return { status: 'ofärdig', orsak: `stopp: ${felText(s)}` }
+    return { status: 'stopp', orsak: 'TILLBAKA_TILL_SPEC' }
+  }
+  return { status: null }
+}
+
+const impactRad = (svansModell, fakt) => ({
+  skill: 'request-assess-impact',
+  agent: 'request-assessor',
+  model: svansModell,
+  fakt,
+})
+
+/** Analysens kropp (svansraderna strippade) som impact.md, med runs-rad.
+ *  Ingen --ref: analysen har ingen referensfil att pinna. */
+function skrivImpact(del, res, ctx) {
+  const { body, modell: svansModell } = parseSvansrader(res.text)
+  writeFileSync(path.join(del.dir, 'impact.md'), body.trim() + '\n')
+  const fakt = fakturerad(res.svar, ctx.modell)
+  addRun(del.dir, { ...impactRad(svansModell, fakt), fil: 'impact.md' }, ctx)
+  return { svansModell, fakt }
+}
+
+/** EN omdispatch av assessorn. Den avvisade analysen bokförs före omtaget. */
+async function impactOmdispatch(del, prompt, brister, meta, ctx) {
+  avvisaDokument(del.dir, 'impact', brister, impactRad(meta.svansModell, meta.fakt), ctx)
+  const fil = `steg/1${del.nr}-assessor-omdispatch.json`
+  const res = await korAgent({
+    agent: 'request-assessor',
+    modell: ctx.modell,
+    prompt: omdispatchPrompt(prompt, brister),
+    fil,
+    maxTurer: MAX_TURER.assessor,
+    ctx,
+  })
+  if (!res.ok) return { fel: res.orsak }
+  return skrivImpact(del, res, ctx)
+}
+
+const lasJson = (p) => {
+  try {
+    return JSON.parse(readFileSync(p, 'utf8'))
+  } catch {
+    return null
+  }
+}
+const brottText = (kr) => kr.brott.map((b) => b.replace(/^- /, '')).join('; ')
+
+/** Kontrollkedjan för EN scorerkörning (kontroll.mjs): svansrader, JSON,
+ *  reparationer, check-lasta, resolve-anchors, contract-check och
+ *  fältomskrivning i en process. `--ut` nollas före varje anrop: en kvarlämnad
+ *  JSON från förra försöket skulle arkiveras som om den vore svaret. */
+function korKontroll(txt, ren, fixFil, del, ctx) {
+  const fixPath = path.join(ctx.katalog, fixFil)
+  // Både --ut och --fix-fil nollas: en kvarlämnad JSON från förra försöket
+  // skulle arkiveras som om den vore svaret, och ett kvarlämnat fix-svar
+  // räknas en gång till i korning.json vid en omkörning av samma katalog.
+  rmSync(ren, { force: true })
+  rmSync(fixPath, { force: true })
+  const r = script(
+    'kontroll.mjs',
+    [
+      txt,
+      path.join(del.dir, 'spec.md'),
+      path.join(del.dir, 'impact.md'),
+      '--expect-id',
+      ctx.requestId,
+      '--ut',
+      ren,
+      '--fixa-kundtext',
+      '--claude',
+      ctx.claude,
+      '--fix-fil',
+      fixPath,
+      '--state',
+      path.join(del.dir, 'state.json'),
+    ],
+    ctx,
+  )
+  const tolkad = tolkaKontroll(r.stdout, r.status)
+  samlaFixsteg(fixFil, fixPath, ctx)
+  if (tolkad.exit2) return { exit2: true, orsak: felText(r) }
+  if (tolkad.avvikelse) logg(`AVVIKELSE scorer ${path.basename(del.dir)}: ${tolkad.avvikelse}`)
+  return tolkad
+}
+
+/** Kundtextfixens råsvar är egna claude-anrop: de kostar pengar och hör till
+ *  inget agentsteg, så de räknas som egna steg i korning.json. */
+function samlaFixsteg(fil, fixPath, ctx) {
+  const rasvar = lasJson(fixPath)
+  if (!Array.isArray(rasvar)) return
+  for (const svar of rasvar)
+    ctx.samla({ fil, agent: 'kundtextfix', modell_begard: FIXMODELL, svar, wall_ms: null })
+}
+
+/** En scorerkörning från agentsvar till dom: kontrollkedjan, EN omdispatch vid
+ *  BROTT, kedjan igen. Kvarstående brott gör körningen avvisad (aldrig hela
+ *  delen: den andra körningen kan vara giltig). Exit 2 är dispatcherfel. */
+async function kontrolleraScorer(del, k, res, prompt, ctx) {
+  const txt = path.join(del.dir, `tmp-scorer-run${k}.txt`)
+  const ren = path.join(del.dir, `tmp-scorer-run${k}.json`)
+  const bas = `steg/2${del.nr}-scorer-run${k}`
+  const svarsrad = (kontroll, sista) => {
+    const doc = lasJson(ren)
+    const brott = scorerBrott(kontroll.brott, { doc, ok: kontroll.ok })
+    return {
+      giltig: brott.length === 0,
+      brott,
+      doc,
+      text: sista?.text ?? '',
+      txt,
+      ren,
+      modellSvans: kontroll.modell ?? parseSvansrader(sista?.text ?? '').modell,
+      fakt: fakturerad(sista?.svar, ctx.modell),
+      reparerat: kontroll.reparerat ?? [],
+    }
+  }
+  if (!res.ok) {
+    // Samma nollning som korKontroll gör före varje kedjeanrop: en kvarlämnad
+    // ren JSON från ett tidigare försök i samma katalog skulle annars läsas
+    // som det här stegets svar och arkiveras som en giltig poäng.
+    rmSync(ren, { force: true })
+    return svarsrad(
+      { brott: [`- agentsteget föll: ${res.orsak}`], modell: null, reparerat: [], ok: false },
+      res,
+    )
+  }
+  writeFileSync(txt, res.text)
+  let kontroll = korKontroll(txt, ren, `${bas}-kundtextfix.json`, del, ctx)
+  if (kontroll.exit2) return { exit2: true, orsak: `kontroll run${k}: ${kontroll.orsak}` }
+  let sista = res
+  if (kontroll.brott.length > 0) {
+    const fil = `${bas}-omdispatch.json`
+    const om = await korAgent({
+      agent: 'request-scorer',
+      modell: ctx.modell,
+      prompt: omdispatchPrompt(prompt, kontroll.brott),
+      fil,
+      maxTurer: MAX_TURER.scorer,
+      ctx,
+    })
+    if (!om.ok)
+      return svarsrad({ ...kontroll, brott: [...kontroll.brott, `- omdispatch: ${om.orsak}`] }, res)
+    writeFileSync(txt, om.text)
+    const andra = korKontroll(txt, ren, `${bas}-omdispatch-kundtextfix.json`, del, ctx)
+    if (andra.exit2) return { exit2: true, orsak: `kontroll run${k} (omdispatch): ${andra.orsak}` }
+    kontroll = { ...andra, reparerat: [...kontroll.reparerat, ...andra.reparerat] }
+    sista = om
+  }
+  return svarsrad(kontroll, sista)
+}
+
+/** Två scorerkörningar samtidigt (hävstång 2, #500): de är oberoende, och
+ *  dubbelkörningen krävs ändå för varje prisbärande poäng. */
+async function korScorers(del, ctx) {
+  const prompt = scorerPrompt({
+    requestId: ctx.requestId,
+    delpost: del.delpost,
+    specPath: path.join(del.dir, 'spec.md'),
+    impactPath: path.join(del.dir, 'impact.md'),
+  })
+  const svar = await Promise.all(
+    [1, 2].map((k) =>
+      korAgent({
+        agent: 'request-scorer',
+        modell: ctx.modell,
+        prompt,
+        fil: `steg/2${del.nr}-scorer-run${k}.json`,
+        maxTurer: MAX_TURER.scorer,
+        ctx,
+      }),
+    ),
+  )
+  const korningar = []
+  for (const [i, res] of svar.entries()) {
+    const kr = await kontrolleraScorer(del, i + 1, res, prompt, ctx)
+    if (kr.exit2) {
+      stadaTmp([
+        ...korningar,
+        {
+          txt: path.join(del.dir, `tmp-scorer-run${i + 1}.txt`),
+          ren: path.join(del.dir, `tmp-scorer-run${i + 1}.json`),
+        },
+      ])
+      return { status: 'ofärdig', orsak: `poäng: ${kr.orsak}` }
+    }
+    korningar.push(kr)
+  }
+  return { korningar }
+}
+
+/** Kontrollkedjans arbetsyta, aldrig arkivinnehåll: tmp-filerna tas bort när
+ *  varvet är arkiverat eller avbrutet. */
+const stadaTmp = (korningar) => {
+  for (const k of korningar) for (const p of [k?.txt, k?.ren]) if (p) rmSync(p, { force: true })
+}
+
+/** Prisfilen: kontrollkedjans rena JSON när den finns, annars ett kvitto på
+ *  vad som kom tillbaka. En avvisad körning utan JSON får aldrig försvinna
+ *  spårlöst, den kostade lika mycket som en giltig. */
+function skrivPris(del, namn, kr) {
+  const innehall = kr.doc ?? { avvisad: true, brott: kr.brott, text: kr.text }
+  writeFileSync(path.join(del.dir, namn), JSON.stringify(innehall, null, 2) + '\n')
+}
+
+const scorerNote = (kr, extra = []) =>
+  [...extra, ...kr.reparerat.map((r) => `reparerat: ${r}`)].filter(Boolean).join('; ') || null
+
+const scorerRad = (kr, fil, extra = {}) => ({
+  fil,
+  skill: 'request-score',
+  agent: 'request-scorer',
+  model: kr.modellSvans,
+  fakt: kr.fakt,
+  ref: SCORE_REF(),
+  ...extra,
+})
+
+/** Experimentresultat blir aldrig `priced` (Experimentytan); `assessed` är
+ *  den högsta status en körning kan nå här. */
+function sattAssessed(del, ctx) {
+  const r = arkiv(['set-status', del.dir, 'assessed'], ctx)
+  if (r.status !== 0) logg(`VARNING set-status assessed ${path.basename(del.dir)}: ${felText(r)}`)
+}
+
+/** Körning 1 avvisad: ingen giltig poäng finns. Körning 2 arkiveras ändå som
+ *  spekulativ dubbelkörning, den är körd och betald. */
+function arkiveraAvvisad(del, n, k1, k2, ctx) {
+  const huvud = `score-pricing-v${n}-avvisad.json`
+  skrivPris(del, huvud, k1)
+  addRun(del.dir, scorerRad(k1, huvud, { note: scorerNote(k1, [brottText(k1)]) }), ctx)
+  const run2 = `score-pricing-v${n}-run2${k2.giltig ? '' : '-avvisad'}.json`
+  skrivPris(del, run2, k2)
+  const note = scorerNote(k2, [
+    'spekulativ dubbelkörning utan giltig körning 1',
+    ...(k2.giltig ? [] : [brottText(k2)]),
+  ])
+  addRun(del.dir, scorerRad(k2, run2, { supersededBy: huvud, note }), ctx)
+  return { status: 'ofärdig', orsak: `poäng: ${brottText(k1)}` }
+}
+
+/** Körning 1 giltig men dubbelkörningen krävdes inte (stopputfall eller poäng
+ *  under 1, ADR-0098): körning 1 är gällande, körning 2 läggs som spekulativ. */
+function arkiveraEnkel(del, n, k1, k2, ctx) {
+  const huvud = `score-pricing-v${n}.json`
+  skrivPris(del, huvud, k1)
+  addRun(del.dir, scorerRad(k1, huvud, { note: scorerNote(k1) }), ctx)
+  const run2 = `score-pricing-v${n}-run2${k2.giltig ? '' : '-avvisad'}.json`
+  skrivPris(del, run2, k2)
+  const note = scorerNote(k2, [
+    'spekulativ dubbelkörning, ej krävd (ADR-0098/0116: poäng < 1 eller stopputfall utom OVER_SKALAN)',
+    ...(k2.giltig ? [] : [brottText(k2)]),
+  ])
+  addRun(del.dir, scorerRad(k2, run2, { supersededBy: huvud, note }), ctx)
+  sattAssessed(del, ctx)
+  if (!arStopputfall(k1.doc.outcome)) return { status: null }
+  // DELA_UPP kräver nya delkataloger, ny analys och ny poäng per del. Det
+  // körs inte autonomt av den inre processen i v1 (ADR-0113), delen stannar
+  // med utfallet synligt i stället för att låtsas vara färdig.
+  const orsak =
+    k1.doc.outcome === 'DELA_UPP'
+      ? 'DELA_UPP: delning körs inte autonomt av korning.mjs'
+      : k1.doc.outcome
+  return { status: 'stopp', orsak }
+}
+
+/** Båda giltiga och dubbelkörningen krävs: jämförelsen avgör vilken fil som
+ *  gäller. OLIKA går till människan (ADR-0092), aldrig till en tredje körning. */
+function arkiveraDubbel(del, n, k1, k2, ctx) {
+  const c = script('compare-scores.mjs', [k1.ren, k2.ren], ctx)
+  const jam = tolkaCompare(c.stdout, c.status)
+  if (jam.verdikt === 'FEL') return { status: 'ofärdig', orsak: `compare-scores: ${felText(c)}` }
+  const { huvud, run2, huvudAr, doubleRun } = filnamnForVarv({
+    n,
+    verdikt: jam.verdikt,
+    vinnare: jam.vinnare,
+  })
+  const vinnaren = huvudAr === 2 ? k2 : k1
+  const andra = huvudAr === 2 ? k1 : k2
+  const diff = jam.rader.map((r) => r.replace(/^- /, ''))
+  skrivPris(del, huvud, vinnaren)
+  skrivPris(del, run2, andra)
+  addRun(del.dir, scorerRad(vinnaren, huvud, { doubleRun, note: scorerNote(vinnaren) }), ctx)
+  addRun(
+    del.dir,
+    scorerRad(andra, run2, {
+      doubleRun,
+      note: scorerNote(andra, jam.verdikt === 'OLIKA' ? diff : []),
+      // En OLIKA har ingen gällande fil att peka på förrän domen är fälld.
+      ...(jam.verdikt === 'OLIKA' ? {} : { supersededBy: huvud }),
+    }),
+    ctx,
+  )
+  sattAssessed(del, ctx)
+  logg(`POÄNG ${path.basename(del.dir)} ${jam.verdikt} (${huvud})`)
+  if (jam.verdikt === 'OLIKA')
+    return { status: 'väntar på dom', orsak: `OLIKA: ${diff.join('; ')}` }
+  return arStopputfall(vinnaren.doc.outcome)
+    ? { status: 'stopp', orsak: vinnaren.doc.outcome }
+    : { status: null }
+}
+
+/** Arkiveringen av ett scorervarv. Tmp-filerna tas bort när de arkiverats:
+ *  de är kontrollkedjans arbetsyta, inte arkivinnehåll. */
+function arkiveraVarv(del, korningar, ctx) {
+  const [k1, k2] = korningar
+  const r = arkiv(['next-n', del.dir, '--typ', 'score'], ctx)
+  if (r.status !== 0) return { status: 'ofärdig', orsak: `next-n: ${felText(r)}` }
+  const n = Number(r.stdout.trim())
+  try {
+    if (!k1.giltig) return arkiveraAvvisad(del, n, k1, k2, ctx)
+    if (!behoverDubbelkorning(k1.doc)) return arkiveraEnkel(del, n, k1, k2, ctx)
+    return arkiveraDubbel(del, n, k1, k2, ctx)
+  } finally {
+    stadaTmp(korningar)
+  }
+}
+
+/** En del hela vägen: analys, två scorerkörningar, arkivering. */
+async function korDel(del, ctx) {
+  const namn = delNamn(ctx, del.dir)
+  const analys = await korAssessor(del, ctx)
+  if (analys.status !== null) return { namn, ...analys }
+  const scorers = await korScorers(del, ctx)
+  if (scorers.status) return { namn, status: scorers.status, orsak: scorers.orsak }
+  return { namn, ...arkiveraVarv(del, scorers.korningar, ctx) }
+}
+
+/** Mätningen på disk. Skrivs ALLTID: kostnaden är verklig även när körningen
+ *  föll eller avbröts, och en körning utan korning.json är omätbar i
+ *  efterhand. */
+const skrivKorningsjson = (ctx, allaSteg) =>
+  writeFileSync(
+    path.join(ctx.katalog, 'korning.json'),
+    JSON.stringify(slaIhopKorning(allaSteg), null, 2) + '\n',
+  )
+
+/** Avslutet: korning.json skrivs ALLTID (kostnaden är verklig även när
+ *  körningen föll), status vägs samman och sätts via archive.mjs, och sist
+ *  skrivs delraderna och bluf-tabellen på stderr. */
+function avsluta(ctx, allaSteg, rader, nyckel) {
+  let statusfel = null
+  skrivKorningsjson(ctx, allaSteg)
+  const status = sammanvagdStatus(rader.map((r) => r.status ?? null))
+  if (status !== null) {
+    const orsak = rader
+      .filter((r) => r.status === status && r.orsak)
+      .map((r) => `${r.namn}: ${r.orsak}`)
+      .join('; ')
+    const r = arkiv(
+      [
+        'experiment',
+        ctx.exp,
+        '--korning',
+        nyckel,
+        '--status',
+        status,
+        ...(orsak ? ['--orsak', orsak] : []),
+      ],
+      ctx,
+    )
+    if (r.status !== 0) {
+      // Utan den här raden stannar exit på 0 vid stopp och väntar på dom, och
+      // svep stämplar `klar` över en körning som behöver en människa.
+      statusfel = `experiment --status ${status} misslyckades: ${felText(r)}`
+      logg(`FEL ${statusfel}, körningen rapporteras som ofärdig i stället`)
+    }
+  }
+  for (const r of rader)
+    logg(`DEL ${r.namn} ${r.status ?? 'klar'}${r.orsak ? ` (${r.orsak})` : ''}`)
+  const bluf = arkiv(['bluf', ctx.katalog], ctx)
+  process.stderr.write(
+    (bluf.status === 0 ? bluf.stdout : `bluf: ${felText(bluf)}`).trimEnd() + '\n',
+  )
+  return status === 'ofärdig' || statusfel !== null ? 1 : 0
+}
+
+/** Signalavbrottet: döda barnen, skriv mätningen och lämna körningen som
+ *  `ofärdig` efter sig. Utan den här vägen överlever betalda `claude`-processer
+ *  en dödad korning.mjs, och korning.json skrivs aldrig, så både pengarna och
+ *  mätningen försvinner tyst. Kör aldrig återstoden av flödet: en avbruten
+ *  körning ÄR ofärdig. */
+function avbryt(ctx, allaSteg, nyckel, signal) {
+  const antal = ctx.barn.size
+  for (const barn of ctx.barn) barn.kill('SIGTERM')
+  skrivKorningsjson(ctx, allaSteg)
+  const r = arkiv(
+    [
+      'experiment',
+      ctx.exp,
+      '--korning',
+      nyckel,
+      '--status',
+      'ofärdig',
+      '--orsak',
+      `avbruten (${signal})`,
+    ],
+    ctx,
+  )
+  if (r.status !== 0) logg(`VARNING experiment --status ofärdig: ${felText(r)}`)
+  logg(`AVBRUTEN ${signal}: ${antal} barnprocess(er) dödade, korning.json skriven`)
+  process.exit(SIGNAL_EXIT)
+}
+
+async function main(argv) {
+  const val = tolkaArgv(argv)
+  if (val.fel) {
+    console.error(val.fel)
+    console.error(ANVANDNING)
+    return 2
+  }
+  const underlag = lasUnderlag(val)
+  if (underlag.fel) {
+    console.error(underlag.fel)
+    return 2
+  }
+  const allaSteg = []
+  const ctx = { ...val, ...underlag, barn: new Set(), samla: (steg) => allaSteg.push(steg) }
+  mkdirSync(path.join(ctx.katalog, 'steg'), { recursive: true })
+  const nyckel = `${path.basename(path.dirname(ctx.katalog))}/${path.basename(ctx.katalog)}`
+  for (const signal of ['SIGTERM', 'SIGINT'])
+    process.on(signal, () => avbryt(ctx, allaSteg, nyckel, signal))
+  logg(
+    `START ${nyckel} ${ctx.requestId} ${ctx.modell} (${ctx.sprak}${ctx.eskalerad ? ', eskalerad' : ''})`,
+  )
+
+  let rader
+  try {
+    rader = await korKorningen(ctx)
+  } catch (e) {
+    // korning.json skrivs ÄVEN när något kastar: kostnaden är redan dragen och
+    // stegen ligger på disk. Ett kast som tar mätningen med sig gör körningen
+    // omätbar i efterhand.
+    logg(`FEL oväntat: ${e?.stack ?? e}`)
+    rader = [
+      {
+        namn: path.basename(ctx.katalog),
+        status: 'ofärdig',
+        orsak: `oväntat fel: ${e?.message ?? e}`,
+      },
+    ]
+  }
+  return avsluta(ctx, allaSteg, rader, nyckel)
+}
+
+/** Specifier, formkontroll per del och de parallella delarna. Returnerar en
+ *  rad per del; kastar bara vid oväntade fel (main skriver mätningen ändå). */
+async function korKorningen(ctx) {
+  const spec = await korSpecifier(ctx)
+  if (spec.fel) return [{ namn: path.basename(ctx.katalog), status: 'ofärdig', orsak: spec.fel }]
+
+  // Formkontrollen per del körs före den parallella fasen: en del som stoppas
+  // eller faller här ska aldrig kosta en analys.
+  const rader = []
+  const kvar = []
+  for (const del of spec.delar) {
+    const namn = delNamn(ctx, del.dir)
+    const r = await prechecka(del, spec, ctx)
+    if (r.status === null) kvar.push(del)
+    else rader.push({ namn, ...r })
+  }
+  const resultat = await schemalagg(kvar, ctx.delarParallellt, (del) => korDel(del, ctx))
+  for (const [i, r] of resultat.entries())
+    rader.push(r.fel ? { namn: delNamn(ctx, kvar[i].dir), status: 'ofärdig', orsak: r.fel } : r)
+  return rader
+}
+
+/** Huvudloopen körs bara när scriptet startas direkt; en import (testerna)
+ *  exekverar ingenting. */
+const arDirektKord = () => {
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))
+  } catch {
+    return false
+  }
+}
+
+if (arDirektKord()) main(process.argv.slice(2)).then((kod) => process.exit(kod))