@haus-tech/haus-workflow 5.0.1 → 5.2.0

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

@@ -0,0 +1,737 @@
+#!/usr/bin/env node
+/**
+ * Startaren för `utvärdera`-svepet (plan utvardera-parallellt-svep, Task 2):
+ * kö, parallellitet, spawn av den inre headless-processen, mätning,
+ * proveniens, modellverifiering och status som deterministisk kod i stället
+ * för ett handskrivet svep.sh per experiment. SKILL.md beskriver flödet och
+ * anropar detta script; reglerna testas in-process i tests/request-svep.test.js
+ * (de rena hjälparna exporteras, huvudloopen körs bara när scriptet startas
+ * direkt).
+ *
+ * Två tickets åt gången, varje ticket kör sina valda modeller med högst
+ * `--modeller-parallellt` (default 4) i flykt, och nästa ticket startar först
+ * när en tickets samtliga modeller är klara (beslut 2026-09-02; modelltaket
+ * #526, ADR-0120: sex agentprocesser per modell utan tak gav en last som
+ * wall_ms mättes under utan att bokföras). `experiment.json` skrivs ALDRIG
+ * härifrån direkt, bara via `archive.mjs experiment` (låst
+ * läs-modifiera-skriv), så samtidiga varv
+ * aldrig tappar varandras rader (#493). Övriga arkivsteg (ny-korning,
+ * proveniens, sparr) anropas som kommandon av samma skäl som ADR-0094: ett
+ * steg som ålägger startaren en skrivning måste peka ut vem som utför den.
+ *
+ * Användning:
+ *   node svep.mjs --repo-rot <abs> --konto <namn> --modell <m> [--modell <m>]...
+ *                 --exp <experiments/<slug>> [--exp ...]...
+ *                 [--tickets-parallellt 2] [--modeller-parallellt 4]
+ *                 [--om | --hoppa-över] [--claude <kommando>]
+ *
+ * Ett relativt --exp löses mot <repo-rot>/.haus-workflow/requests/. Varje
+ * experimentkatalog måste bära onskemal.md, kallmanifest.md och experiment.json
+ * med `ticket` (huvudkonversationen förbereder dem, utvärdera steg 1 till 3);
+ * saknas något märks ticketen och hoppas över, svepet fortsätter.
+ *
+ * Per (ticket, modell): återupptagning ur experiment.json, ny-korning, startar
+ * `korning.mjs` per varv, som kör agentstegen som egna `claude -p --agent`-
+ * processer och skriver korning.json själv, stderr till stderr.log,
+ * matning.json (även vid krasch), proveniens, modellverifiering mot
+ * modelUsage (ADR-0099) och status via `archive.mjs experiment`.
+ *
+ * Exit 0 = ingen körning blev ofärdig, 1 = minst en ofärdig, 2 = användningsfel.
+ * Ctrl-C dödar barnprocesserna, skriver matning.json och status ofärdig för de
+ * som kördes, och avslutar med 130.
+ */
+import { existsSync, readFileSync, writeFileSync, readdirSync, realpathSync } from 'node:fs'
+import { spawn, spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { canonicalModel, matcharModell, avgorDeps, schemalagg } from './lib.mjs'
+
+// matcharModell, avgorDeps och schemalagg flyttade till lib.mjs (delade
+// byggstenar för requestmotorns kontrollscript); re-exporteras här så
+// befintliga importer (tests/request-svep.test.js och senare korning.mjs)
+// är oförändrade.
+export { matcharModell, avgorDeps, schemalagg }
+
+const HAR = path.dirname(fileURLToPath(import.meta.url))
+const ARCHIVE = path.join(HAR, 'archive.mjs')
+const KORNING = path.join(HAR, 'korning.mjs')
+
+export const UNDERLAG = ['onskemal.md', 'kallmanifest.md', 'experiment.json']
+export const STATUSAR = ['klar', 'ofärdig', 'stopp', 'väntar på dom']
+/** Statusar den inre processen själv får sätta och som startaren behåller. */
+const INRE_BEHALLS = ['stopp', 'väntar på dom', 'ofärdig']
+const STANDARD_TAK = 2
+/** Modeller per ticket i flykt. Fyra täcker det vanliga svepet (opus, sonnet,
+ *  fable plus en till) utan att sex agentprocesser per modell staplas
+ *  obegränsat (#526). */
+const STANDARD_MODELLTAK = 4
+const SIGINT_EXIT = 130
+const VARDEFLAGGOR = [
+  'repo-rot',
+  'konto',
+  'modell',
+  'exp',
+  'tickets-parallellt',
+  'modeller-parallellt',
+  'claude',
+]
+const BOOLFLAGGOR = ['om', 'hoppa-över']
+
+export const ANVANDNING = [
+  'användning: svep.mjs --repo-rot <abs> --konto <namn> --modell <m> [--modell <m>]...',
+  '                     --exp <experiments/<slug>> [--exp ...]...',
+  `                     [--tickets-parallellt ${STANDARD_TAK}] [--modeller-parallellt ${STANDARD_MODELLTAK}]`,
+  '                     [--om | --hoppa-över] [--claude <kommando>]',
+].join('\n')
+
+// ---------------------------------------------------------------------------
+// Rena hjälpare (testas in-process)
+// ---------------------------------------------------------------------------
+
+/** Argumenttolkning. Returnerar `{ fel }` vid användningsfel (exit 2 i main),
+ *  annars de tolkade valen. Alla saknade flaggor namnges på en gång, så
+ *  anroparen inte behöver rätta en i taget (ADR-0039). */
+export function tolkaArgv(argv) {
+  const listor = { modell: [], exp: [] }
+  const enkla = {}
+  const bool = { om: false, 'hoppa-över': false }
+  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 (BOOLFLAGGOR.includes(namn)) {
+      bool[namn] = true
+      continue
+    }
+    if (!VARDEFLAGGOR.includes(namn)) return { fel: `okänd flagga: --${namn}` }
+    const v = argv[i + 1]
+    // Ett flaggvärde får aldrig tyst bli nästa flaggas namn (samma regel som
+    // archive.mjs): `--konto --modell` är ett fel, inte kontot "--modell".
+    if (v === undefined || v.startsWith('--')) return { fel: `--${namn} kräver ett värde` }
+    i++
+    if (namn in listor) listor[namn].push(v)
+    else enkla[namn] = v
+  }
+  const saknas = ['repo-rot', 'konto', 'modell', 'exp'].filter((n) =>
+    n in listor ? listor[n].length === 0 : enkla[n] === undefined,
+  )
+  if (saknas.length > 0) return { fel: `saknar ${saknas.map((n) => `--${n}`).join(', ')}` }
+  if (bool.om && bool['hoppa-över']) return { fel: '--om och --hoppa-över utesluter varandra' }
+  if (!path.isAbsolute(enkla['repo-rot']))
+    return { fel: `--repo-rot måste vara en absolut sökväg (fick "${enkla['repo-rot']}")` }
+  const dubbletter = listor.modell.filter((m, i) => listor.modell.indexOf(m) !== i)
+  if (dubbletter.length > 0)
+    return {
+      fel: `--modell ${dubbletter[0]} står två gånger: samma värde pekar på samma katalog och mäter ingen skillnad`,
+    }
+  const takText = enkla['tickets-parallellt'] ?? String(STANDARD_TAK)
+  const taket = Number(takText)
+  if (!/^\d+$/.test(takText) || taket < 1)
+    return { fel: `--tickets-parallellt måste vara ett heltal >= 1 (fick "${takText}")` }
+  const modelltakText = enkla['modeller-parallellt'] ?? String(STANDARD_MODELLTAK)
+  const modellerParallellt = Number(modelltakText)
+  if (!/^\d+$/.test(modelltakText) || modellerParallellt < 1)
+    return { fel: `--modeller-parallellt måste vara ett heltal >= 1 (fick "${modelltakText}")` }
+  return {
+    repoRot: enkla['repo-rot'],
+    konto: enkla.konto,
+    modeller: listor.modell,
+    exps: listor.exp,
+    taket,
+    modellerParallellt,
+    om: bool.om,
+    hoppaOver: bool['hoppa-över'] || !bool.om,
+    claude: enkla.claude ?? 'claude',
+  }
+}
+
+/** Ett relativt --exp är arkivrelativt (`experiments/<slug>`), som SKILL.md
+ *  skriver det; ett absolut används som det är. */
+export function losExp(exp, repoRot) {
+  return path.isAbsolute(exp) ? exp : path.join(repoRot, '.haus-workflow', 'requests', exp)
+}
+
+/** `default` som modellvärde ger katalognamnet `baseline/` (Experimentytan). */
+export const modellKatalog = (modell) => (modell === 'default' ? 'baseline' : modell)
+
+/** Kontrollerar att en experimentkatalog bär underlaget huvudkonversationen
+ *  ska ha förberett. Returnerar `{ ok: false, saknas: [...] }` eller
+ *  `{ ok: true, ticket, eskalerad, eskaleringsorsak, experiment }`. Läser
+ *  bara; skriver aldrig. */
+export function kontrolleraUnderlag(expDir) {
+  const saknas = UNDERLAG.filter((f) => !existsSync(path.join(expDir, f)))
+  let experiment = null
+  if (!saknas.includes('experiment.json')) {
+    try {
+      experiment = JSON.parse(readFileSync(path.join(expDir, 'experiment.json'), 'utf8'))
+    } catch (e) {
+      saknas.push(`experiment.json (ogiltig JSON: ${e.message})`)
+    }
+    if (experiment !== null) {
+      // Rapporten läser `request_id`; äldre experiment (IPC 14001) skrev `ticket`.
+      const t = experiment.request_id ?? experiment.ticket
+      if (t === undefined || t === null || String(t).trim() === '')
+        saknas.push('experiment.json saknar `request_id`')
+    }
+  }
+  if (saknas.length > 0) return { ok: false, saknas }
+  return {
+    ok: true,
+    ticket: String(experiment.request_id ?? experiment.ticket),
+    eskalerad: experiment.eskalerad === true,
+    eskaleringsorsak:
+      typeof experiment.eskaleringsorsak === 'string' ? experiment.eskaleringsorsak : null,
+    experiment,
+  }
+}
+
+/** Modellens gällande körning i experiment.json: den högsta k<N> under
+ *  katalognamnet. `null` när modellen saknar körningar. */
+export function senasteKorning(experiment, katalognamn) {
+  const re = new RegExp(`^${katalognamn.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/k(\\d+)$`)
+  let basta = null
+  for (const [nyckel, rad] of Object.entries(experiment?.korningar ?? {})) {
+    const m = re.exec(nyckel)
+    if (!m) continue
+    const n = Number(m[1])
+    if (basta === null || n > basta.n)
+      basta = {
+        n,
+        nyckel,
+        status: rad?.status ?? null,
+        orsak: rad?.orsak ?? null,
+        // Startarens pid medan körningen pågår (#516); null i slutstatusen
+        // och i äldre filer.
+        pid: Number.isInteger(rad?.pid) ? rad.pid : null,
+      }
+  }
+  return basta
+}
+
+/** Lever processen? Signal 0 levererar inget men prövar att pid:n finns.
+ *  EPERM betyder att den finns men tillhör någon annan (det andra kontots
+ *  svep, ADR-0093), alltså levande. ESRCH och allt annat är död. */
+export const processLever = (pid) => {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (e) {
+    return e?.code === 'EPERM'
+  }
+}
+
+/** Återupptagningsregeln ur SKILL.md:s Batch-avsnitt. `klar` och `stopp` är
+ *  resultat värda att skydda: de hoppas utan --om. `ofärdig` är avbruten data
+ *  och körs om, UTOM när raden bär en pid som lever: då är det ingen avbruten
+ *  körning utan en som pågår i ett annat svep (två konton mot samma checkout,
+ *  ADR-0093), och en omkörning vore en dubblett av en dyr körning (#516). En
+ *  död pid eller ingen pid alls (äldre rad, korning.mjs:s eget avbrott) körs
+ *  om som förut, så #493:s skydd står kvar. `--om` rör inte det: flaggan
+ *  gäller resultat, inte pågående processer. `väntar på dom` omvärderas med
+ *  `archive.mjs sparr`, svepet är den enda aktören för den statusen. Ingen
+ *  körning alls (status undefined) körs. `levande` är injicerbar för
+ *  testerna. */
+export function aterupptagning(status, { om = false, pid = null, levande = processLever } = {}) {
+  if (status === 'väntar på dom') return 'prova-sparr'
+  if (status === 'klar' || status === 'stopp') return om ? 'kör' : 'hoppa'
+  if (status === 'ofärdig' && pid !== null && levande(pid)) return 'hoppa'
+  return 'kör'
+}
+
+/** Argumenten till den inre processen (plan requestmotor-korning, Task 3):
+ *  `korning.mjs` som en egen node-process i stället för en prompt på stdin
+ *  till en sonnet-orkestrator. Första elementet är korning.mjs:s absoluta
+ *  sökväg, så anropet blir `spawn(process.execPath, korningArgs({...}))`. */
+export function korningArgs({ katalog, expDir, repoRot, gid, modell, claude }) {
+  return [
+    KORNING,
+    '--katalog',
+    katalog,
+    '--exp',
+    expDir,
+    '--repo-rot',
+    repoRot,
+    '--request-id',
+    gid,
+    '--modell',
+    modell,
+    '--claude',
+    claude,
+  ]
+}
+
+/** Modellverifiering mot faktureringen (ADR-0099): den kanoniserade
+ *  nyckelmängden ur modelUsage måste vara en delmängd av {modellen, sonnet,
+ *  haiku}. `sonnet` är kundtextfixen (kontroll.mjs --fixa-kundtext), `haiku`
+ *  CLI:ns egna hjälpanrop (ett dussin output-tokens). `default` kör
+ *  agenternas egna defaults och prövas aldrig. */
+export function verifieraModeller(modelUsage, modell) {
+  if (modell === 'default') return { ok: true }
+  const nycklar = [...new Set(Object.keys(modelUsage ?? {}).map(canonicalModel))]
+  const obegarda = nycklar.filter(
+    (k) => !matcharModell(k, modell) && !matcharModell(k, 'sonnet') && !matcharModell(k, 'haiku'),
+  )
+  if (obegarda.length > 0) return { ok: false, orsak: `MODELL-avvikelse: ${obegarda.join(', ')}` }
+  return { ok: true }
+}
+
+/** Statusregeln (plan Task 2, punkt 7): exit skilt från 0 eller modellfel ger
+ *  `ofärdig` med orsak; en status den inre processen redan satt behålls
+ *  (`behalls: true`, ingen skrivning); annars `klar`. */
+export function avgorStatus({ exitCode, signal = null, modellfel = null, innerStatus = null }) {
+  if (exitCode !== 0) {
+    const orsak =
+      exitCode === null ? `processen dödades (${signal ?? 'okänd signal'})` : `exit ${exitCode}`
+    return { status: 'ofärdig', orsak }
+  }
+  if (modellfel) return { status: 'ofärdig', orsak: modellfel }
+  if (INRE_BEHALLS.includes(innerStatus)) return { status: innerStatus, behalls: true }
+  return { status: 'klar' }
+}
+
+/** Katalogerna `sparr` ska köras mot: löven i del-trädet (bunt eller
+ *  delning, `del-N/del-M` vid DELA_UPP i en buntdel), eller körningsroten
+ *  när den saknar delar. */
+export function sparrKataloger(dir) {
+  let delar = []
+  try {
+    delar = readdirSync(dir, { withFileTypes: true })
+      .filter((d) => d.isDirectory() && /^del-\d+$/.test(d.name))
+      .map((d) => path.join(dir, d.name))
+      .sort()
+  } catch {
+    return [dir]
+  }
+  return delar.length === 0 ? [dir] : delar.flatMap(sparrKataloger)
+}
+
+/** Sluttabellen: en rad per (ticket, modell). */
+export function renderaTabell(rader) {
+  const wall = (ms) => (Number.isFinite(ms) ? `${ms}ms` : '-')
+  const usd = (u) => (Number.isFinite(u) ? u.toFixed(4) : '-')
+  return [
+    '| ticket | modell | körning | status | wall | USD |',
+    '| --- | --- | --- | --- | --- | --- |',
+    ...rader.map(
+      (r) =>
+        `| ${r.ticket} | ${r.modell} | ${r.korning ?? '-'} | ${r.status}${r.orsak ? ` (${r.orsak})` : ''} | ${wall(r.wall_ms)} | ${usd(r.usd)} |`,
+    ),
+  ].join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// Det riktiga arbetet (verifieras för hand i E2E, plan Task 4)
+// ---------------------------------------------------------------------------
+
+/** Ett archive.mjs-anrop, synkront: alla sökvägar är absoluta så cwd spelar
+ *  ingen roll utöver tydlighet. */
+const arkiv = (args, cwd) =>
+  spawnSync(process.execPath, [ARCHIVE, ...args], { encoding: 'utf8', cwd })
+
+const felText = (r) => (r.stderr || r.stdout || '').trim() || `exit ${r.status}`
+
+const skrivMatning = (katalog, matning) =>
+  writeFileSync(path.join(katalog, 'matning.json'), JSON.stringify(matning, null, 2) + '\n')
+
+const lasKorningsrad = (expDir, nyckel) => {
+  try {
+    const exp = JSON.parse(readFileSync(path.join(expDir, 'experiment.json'), 'utf8'))
+    return exp?.korningar?.[nyckel] ?? null
+  } catch {
+    return null
+  }
+}
+
+/** Startar `korning.mjs` som en egen node-process, utan stdin, och tar tiden
+ *  runt den. korning.json skrivs av korning.mjs självt (filens ägare); här
+ *  sparas bara stderr som stderr.log. matning.json skrivs ÄVEN när processen
+ *  faller eller inte går att starta: en kraschad körning har en klocktid.
+ *  `pagaende` är svepets register för Ctrl-C. */
+function korInre({ claude, gid, modell, katalog, expDir, repoRot, pagaende, nyckel }) {
+  return new Promise((resolve) => {
+    const startad = new Date()
+    let stderr = ''
+    let klar = false
+    const avsluta = ({ exitCode, signal, spawnfel = null }) => {
+      if (klar) return
+      klar = true
+      const avslutad = new Date()
+      const wall_ms = avslutad.getTime() - startad.getTime()
+      writeFileSync(path.join(katalog, 'stderr.log'), stderr)
+      const matning = {
+        startad: startad.toISOString(),
+        avslutad: avslutad.toISOString(),
+        wall_ms,
+        exit_code: exitCode,
+        ...(signal ? { signal } : {}),
+        ...(spawnfel ? { fel: spawnfel } : {}),
+      }
+      skrivMatning(katalog, matning)
+      resolve({ exitCode, signal, spawnfel, wall_ms })
+    }
+    let barn
+    try {
+      barn = spawn(
+        process.execPath,
+        korningArgs({ katalog, expDir, repoRot, gid, modell, claude }),
+        {
+          cwd: repoRot,
+          stdio: ['ignore', 'pipe', 'pipe'],
+        },
+      )
+    } catch (e) {
+      avsluta({ exitCode: null, signal: null, spawnfel: e.message })
+      return
+    }
+    pagaende.set(barn, { katalog, startad, expDir, nyckel })
+    // stdout ignoreras: korning.json skrivs av korning.mjs själv, inte via
+    // startarens stdout-buffert. Lyssnaren dränerar bara strömmen.
+    barn.stdout.on('data', () => {})
+    barn.stderr.on('data', (d) => {
+      stderr += d
+    })
+    barn.on('error', (e) => {
+      pagaende.delete(barn)
+      avsluta({ exitCode: null, signal: null, spawnfel: e.message })
+    })
+    barn.on('close', (code, signal) => {
+      pagaende.delete(barn)
+      avsluta({ exitCode: code, signal })
+    })
+  })
+}
+
+/** #493: en körning som ny-korning skapat men som dör innan slutstatusen
+ *  skrivs fanns förr inte i experiment.json alls. Raden skrivs vid start som
+ *  ofärdig och skrivs över av slutstatusen; ett fel här är en varning. Raden
+ *  bär startarens pid (#516) så ett andra svep ser att körningen pågår;
+ *  slutstatusen skrivs utan --pid och tar bort den. */
+export function registreraStart({ expDir, nyckel, arkiv: arkivFn, pid = process.pid }) {
+  const r = arkivFn([
+    'experiment',
+    expDir,
+    '--korning',
+    nyckel,
+    '--status',
+    'ofärdig',
+    '--orsak',
+    'startad, inte avslutad',
+    '--pid',
+    String(pid),
+  ])
+  return { varning: r.status === 0 ? null : `experiment --status ofärdig: ${felText(r)}` }
+}
+
+/** Ett varv (ticket, modell): startarens hela ansvar enligt plan Task 2
+ *  punkt 2 till 7. Kastar aldrig; ett fel blir en `ofärdig`-rad. `deps`,
+ *  `eskalerad` och `eskaleringsorsak` skickas inte längre in: korning.mjs
+ *  läser dem själv ur repo-roten och experiment.json (ADR-0113), och en
+ *  parameter som ingen läser blir tyst fel så fort någon börjar tro på den. */
+export async function korVarv({ gid, modell, expDir, repoRot, konto, claude, pagaende, ut }) {
+  const varningar = []
+  const modellKat = path.join(expDir, modellKatalog(modell))
+  const ny = arkiv(['ny-korning', modellKat, '--request-id', gid], repoRot)
+  if (ny.status !== 0)
+    return {
+      modell,
+      status: 'ofärdig',
+      orsak: `ny-korning: ${felText(ny)}`,
+      korning: null,
+      wall_ms: null,
+      usd: null,
+      varningar,
+    }
+  const katalog = ny.stdout.trim()
+  const nyckel = `${modellKatalog(modell)}/${path.basename(katalog)}`
+  const start = registreraStart({ expDir, nyckel, arkiv: (args) => arkiv(args, repoRot) })
+  if (start.varning) varningar.push(start.varning)
+  ut(`START ${gid} ${modell} -> ${katalog}`)
+
+  const { exitCode, signal, spawnfel, wall_ms } = await korInre({
+    claude,
+    gid,
+    modell,
+    katalog,
+    expDir,
+    repoRot,
+    pagaende,
+    nyckel,
+  })
+
+  // Proveniens EFTER korning.json, aldrig före: annars saknar stämpeln
+  // faktureringsdatan (SKILL.md steg 4).
+  const prov = arkiv(
+    [
+      'proveniens',
+      katalog,
+      '--modell',
+      modell,
+      '--konto',
+      konto,
+      '--underlag',
+      path.join(expDir, 'kallmanifest.md'),
+    ],
+    repoRot,
+  )
+  if (prov.status !== 0) varningar.push(`proveniens: ${felText(prov)}`)
+
+  let usd = null
+  let modellfel = null
+  try {
+    const korning = JSON.parse(readFileSync(path.join(katalog, 'korning.json'), 'utf8'))
+    if (typeof korning.total_cost_usd === 'number') usd = korning.total_cost_usd
+    if (exitCode === 0) {
+      // korning.mjs har redan gjort verifieringen per steg (modellverifiering);
+      // svepets egen verifieraModeller är reserven när det fältet saknas
+      // (äldre korning.json eller en inre process som föll före summeringen).
+      modellfel =
+        korning.modellverifiering?.ok === false
+          ? `MODELL-avvikelse: ${korning.modellverifiering.avvikelser.join(', ')}`
+          : verifieraModeller(korning.modelUsage, modell).orsak
+    }
+  } catch (e) {
+    if (exitCode === 0) modellfel = `korning.json går inte att läsa: ${e.message}`
+  }
+
+  const inre = lasKorningsrad(expDir, nyckel)
+  const avg = spawnfel
+    ? { status: 'ofärdig', orsak: `kunde inte starta ${claude}: ${spawnfel}` }
+    : avgorStatus({ exitCode, signal, modellfel, innerStatus: inre?.status ?? null })
+  if (!avg.behalls) {
+    const st = arkiv(
+      [
+        'experiment',
+        expDir,
+        '--korning',
+        nyckel,
+        '--status',
+        avg.status,
+        ...(avg.orsak ? ['--orsak', avg.orsak] : []),
+      ],
+      repoRot,
+    )
+    if (st.status !== 0) varningar.push(`experiment --status: ${felText(st)}`)
+  }
+  const orsak = avg.orsak ?? inre?.orsak ?? null
+  ut(
+    `KLAR ${gid} ${modell} ${avg.status} ${wall_ms}ms${usd !== null ? ` ${usd.toFixed(4)} USD` : ''}`,
+  )
+  return { modell, status: avg.status, orsak, korning: nyckel, wall_ms, usd, varningar }
+}
+
+/** `väntar på dom` omvärderas: sparr exit 0 på alla löv betyder att domen är
+ *  fälld, då blir körningen `klar`. Annars står den kvar. */
+function provaSparr({ gid, modell, expDir, repoRot, nyckel, ut }) {
+  const alla = sparrKataloger(path.join(expDir, nyckel)).every(
+    (k) => arkiv(['sparr', k], repoRot).status === 0,
+  )
+  if (!alla) {
+    ut(`VÄNTAR ${gid} ${modell} väntar på dom (${nyckel})`)
+    return {
+      modell,
+      status: 'väntar på dom',
+      korning: nyckel,
+      wall_ms: null,
+      usd: null,
+      varningar: [],
+    }
+  }
+  const varningar = []
+  const st = arkiv(['experiment', expDir, '--korning', nyckel, '--status', 'klar'], repoRot)
+  if (st.status !== 0) varningar.push(`experiment --status: ${felText(st)}`)
+  ut(`DOM ${gid} ${modell} klar (${nyckel}, domen är fälld)`)
+  return {
+    modell,
+    status: 'klar',
+    orsak: 'dom fälld',
+    korning: nyckel,
+    wall_ms: null,
+    usd: null,
+    varningar,
+  }
+}
+
+/** Modellerna för en ticket, högst `taket` i flykt (#526): samma
+ *  schemaläggare som tickets, en nivå ner. `korModell(modell)` kastar aldrig
+ *  (korVarv fångar allt), men ett kast landar ändå som en `ofärdig`-rad för
+ *  den modellen i stället för att stoppa de andra. Raderna kommer i
+ *  modellordning. */
+export async function korModeller(modeller, taket, korModell) {
+  const resultat = await schemalagg(modeller, taket, korModell)
+  return resultat.map((r, i) =>
+    r?.fel === undefined
+      ? r
+      : {
+          modell: modeller[i],
+          status: 'ofärdig',
+          orsak: r.fel,
+          korning: null,
+          wall_ms: null,
+          usd: null,
+          varningar: [],
+        },
+  )
+}
+
+/** En ticket: underlagskontroll, varianter, sedan modellerna med högst
+ *  `--modeller-parallellt` i flykt. */
+async function korTicket(exp, val, pagaende, ut) {
+  const namn = path.basename(exp)
+  const u = kontrolleraUnderlag(exp)
+  if (!u.ok) {
+    ut(`SAKNAS ${namn}: ${u.saknas.join(', ')}`)
+    return {
+      ticket: namn,
+      rader: [
+        { modell: '-', status: 'underlag saknas', orsak: u.saknas.join(', '), korning: null },
+      ],
+    }
+  }
+  const varningar = []
+  const va = arkiv(
+    ['experiment', exp, ...val.modeller.flatMap((m) => ['--variant', m])],
+    val.repoRot,
+  )
+  if (va.status !== 0) varningar.push(`experiment --variant: ${felText(va)}`)
+  const rader = await korModeller(val.modeller, val.modellerParallellt, async (modell) => {
+    const senaste = senasteKorning(u.experiment, modellKatalog(modell))
+    const beslut = aterupptagning(senaste?.status ?? undefined, {
+      om: val.om,
+      pid: senaste?.pid ?? null,
+    })
+    if (beslut === 'hoppa' && senaste.status === 'ofärdig') {
+      // #516: körningen pågår i ett annat svep. Raden heter `pågår`, inte
+      // `ofärdig`: tabellen ska inte påstå att den föll.
+      ut(
+        `HOPPAR ${u.ticket} ${modell} pågår i en annan process (pid ${senaste.pid}, ${senaste.nyckel})`,
+      )
+      return {
+        modell,
+        status: 'pågår',
+        orsak: `i en annan process (pid ${senaste.pid})`,
+        korning: senaste.nyckel,
+        wall_ms: null,
+        usd: null,
+        varningar: [],
+      }
+    }
+    if (beslut === 'hoppa') {
+      ut(`HOPPAR ${u.ticket} ${modell} ${senaste.status} (${senaste.nyckel})`)
+      return {
+        modell,
+        status: senaste.status,
+        orsak: senaste.orsak,
+        korning: senaste.nyckel,
+        wall_ms: null,
+        usd: null,
+        varningar: [],
+      }
+    }
+    if (beslut === 'prova-sparr')
+      return provaSparr({
+        gid: u.ticket,
+        modell,
+        expDir: exp,
+        repoRot: val.repoRot,
+        nyckel: senaste.nyckel,
+        ut,
+      })
+    return korVarv({
+      gid: u.ticket,
+      modell,
+      expDir: exp,
+      repoRot: val.repoRot,
+      konto: val.konto,
+      claude: val.claude,
+      pagaende,
+      ut,
+    })
+  })
+  return { ticket: u.ticket, rader, varningar }
+}
+
+async function main(argv) {
+  const val = tolkaArgv(argv)
+  if (val.fel) {
+    console.error(val.fel)
+    console.error(ANVANDNING)
+    return 2
+  }
+  if (!existsSync(val.repoRot)) {
+    console.error(`--repo-rot finns inte: ${val.repoRot}`)
+    return 2
+  }
+  const ut = (rad) => process.stdout.write(rad + '\n')
+  const pagaende = new Map()
+
+  // Ctrl-C: döda barnen, lämna matning.json och status ofärdig efter dem, så
+  // ett återupptaget svep kör om precis de varv som avbröts.
+  process.on('SIGINT', () => {
+    for (const [barn, info] of pagaende) {
+      barn.kill('SIGTERM')
+      const avslutad = new Date()
+      skrivMatning(info.katalog, {
+        startad: info.startad.toISOString(),
+        avslutad: avslutad.toISOString(),
+        wall_ms: avslutad.getTime() - info.startad.getTime(),
+        exit_code: null,
+        signal: 'SIGINT',
+      })
+      arkiv(
+        [
+          'experiment',
+          info.expDir,
+          '--korning',
+          info.nyckel,
+          '--status',
+          'ofärdig',
+          '--orsak',
+          'avbruten med Ctrl-C',
+        ],
+        val.repoRot,
+      )
+    }
+    console.error(`avbrutet: ${pagaende.size} körning(ar) dödade, matning.json skrivna`)
+    process.exit(SIGINT_EXIT)
+  })
+
+  const exps = val.exps.map((e) => losExp(e, val.repoRot))
+  const resultat = await schemalagg(exps, val.taket, (exp) => korTicket(exp, val, pagaende, ut))
+
+  const rader = []
+  for (const [i, r] of resultat.entries()) {
+    if (r.fel) {
+      rader.push({ ticket: path.basename(exps[i]), modell: '-', status: 'fel', orsak: r.fel })
+      continue
+    }
+    for (const rad of r.rader) rader.push({ ticket: r.ticket, ...rad })
+    for (const v of [...(r.varningar ?? []), ...r.rader.flatMap((x) => x.varningar ?? [])])
+      console.error(`VARNING ${r.ticket}: ${v}`)
+  }
+  ut('')
+  ut(renderaTabell(rader))
+  // Saknat underlag är också exit 1: ett svep som tyst hoppar en ticket ser
+  // annars lyckat ut i en loggrad ingen läser. Detsamma gäller `pågår`
+  // (#516): svepet har inget resultat för den raden, det andra svepet har.
+  return rader.some(
+    (r) =>
+      r.status === 'ofärdig' ||
+      r.status === 'fel' ||
+      r.status === 'underlag saknas' ||
+      r.status === 'pågår',
+  )
+    ? 1
+    : 0
+}
+
+/** 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))