@haus-tech/haus-workflow 5.12.1 → 6.1.0

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

@@ -0,0 +1,651 @@
+#!/usr/bin/env node
+/**
+ * Startaren för produktionens prisning (ADR-0155 beslut 1, 3, 4 och 5):
+ * `bedöm`:s steg 3 till 7 körs som EN `korning.mjs`-process per post i
+ * produktionsläget (`--post`), startad härifrån, så huvudkonversationen
+ * dispatchar ingen agent för prisbenet. Huvudkonversationen behåller grinden,
+ * formkontrollen, BLUF:en, tavelskrivningen och avslutet; det här scriptet
+ * gör bokföringen runt körningen och skriver en tabell.
+ *
+ * Användning:
+ *   node bedom.mjs --repo-rot <abs> [--arkiv <abs>] --post <gid|gid/del-N> [--post ...]...
+ *                  [--parallellt 2] [--max-usd <n>] [--claude <kommando>] [--om]
+ *                  [--sprak <svenska|engelska>] [--design-mode <draft|intervju>]
+ *
+ * `--post` är relativ arkivroten: `--arkiv` när den ges (ARKIVROT: från
+ * `archive.mjs rot`), annars härledd ur --repo-rot:s git common dir
+ * (ADR-0154). `--repo-rot` är utcheckningen vars kod läses och får vara en
+ * worktree.
+ *
+ * Per post, i ordning: förkontroll (state.json läsbar, ingen experimentkatalog,
+ * ingen splitrot med `del-N/` under sig, `approval` satt, inget stående
+ * `stopp`, inte redan `priced`/`guard_run` utan `--om`; annars raden `grind`
+ * och inget startas), taket, körningskatalogen
+ * `<post>/korningar/<YYYYMMDDTHHMMSS>/`, kvittot `archive.mjs korning-start`
+ * (en levande pid ger raden `pågår` och den tomma katalogen tas bort),
+ * `korning.mjs` med `stderr.log` och `matning.json` i körningskatalogen och
+ * `--startare <egen pid>` (dör startaren hårt avbryter körningen sig själv),
+ * `korning.json`:s `total_cost_usd`, `archive.mjs sparr` och statusen. Kvittot
+ * rensas alltid med `archive.mjs korning-slut` i en finally.
+ *
+ * Taket (beslut 4): `max_usd_per_batch` i `.haus-workflow/request.json`
+ * (`<arkiv>/../request.json`), 100 USD när nyckeln saknas, `--max-usd` vinner
+ * för en körning. Före varje poststart jämförs summan mot taket: de klara
+ * posterna med sin USD plus varje post i flykt till de klaras snittkostnad
+ * (0 så länge ingen är klar). När summan nått taket startas inga fler poster
+ * (raden `tak nått`), och ingen pågående körning dödas. Två poster som startar
+ * samtidigt innan någon är klar passerar båda kontrollen: det är accepterat,
+ * taket stoppar nästa start och aldrig en körning som pågår.
+ *
+ * stdout under körningen: `START <post>`, `KLAR <post> <status>`,
+ * `GRIND <post>: <orsak>`, `PÅGÅR <post> (pid N)`, `TAK <post>`; till sist
+ * tabellen `| post | status | poäng | utfall | wall | USD |` och raden
+ * `tak: <n> USD, använt: <m.mm> USD`.
+ *
+ * Exit 0 = varje rad är `priced`, `stopp` eller `väntar på dom`; 1 = minst en
+ * rad är `ofärdig`, `pågår`, `grind` eller `tak nått`; 2 = användningsfel.
+ * SIGINT och SIGTERM skickar SIGTERM till varje pågående körning, skriver
+ * matning.json med signalen, rensar varje kvitto med korning-slut och avslutar
+ * med 130. Ett oväntat kast i huvudloopen skrivs på stderr och ger exit 2.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync, realpathSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { korInre, losArkiv, schemalagg, skrivMatning, usd } from './svep.mjs'
+
+const HAR = path.dirname(fileURLToPath(import.meta.url))
+const ARCHIVE = path.join(HAR, 'archive.mjs')
+const KORNING = path.join(HAR, 'korning.mjs')
+
+export const STANDARD_TAK_USD = 100
+const STANDARD_PARALLELLT = 2
+const SIGNAL_EXIT = 130
+/** Signalerna som avbryter batchen; samma hanterare för båda. */
+export const AVBROTTSSIGNALER = ['SIGINT', 'SIGTERM']
+const SPRAKEN = ['svenska', 'engelska']
+const DESIGNLAGEN = ['draft', 'intervju']
+const VARDEFLAGGOR = [
+  'repo-rot',
+  'arkiv',
+  'post',
+  'parallellt',
+  'max-usd',
+  'claude',
+  'sprak',
+  'design-mode',
+]
+const BOOLFLAGGOR = ['om']
+/** Statusar som är ett resultat: exit 0 när varje rad bär en av dem. */
+const RESULTAT = ['priced', 'stopp', 'väntar på dom']
+
+export const ANVANDNING = [
+  'användning: bedom.mjs --repo-rot <abs> [--arkiv <abs>] --post <gid|gid/del-N> [--post ...]...',
+  `                      [--parallellt ${STANDARD_PARALLELLT}] [--max-usd <n>] [--claude <kommando>] [--om]`,
+  `                      [--sprak <${SPRAKEN.join('|')}>] [--design-mode <${DESIGNLAGEN.join('|')}>]`,
+].join('\n')
+
+// ---------------------------------------------------------------------------
+// Rena hjälpare (testas in-process i tests/request-bedom.test.js)
+// ---------------------------------------------------------------------------
+
+/** Argumenttolkning, fail-closed som svep.mjs: `{ fel }` vid användningsfel
+ *  (exit 2 i main), annars de tolkade valen. */
+export function tolkaArgv(argv) {
+  const poster = []
+  const enkla = {}
+  let om = 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)) {
+      om = 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++
+    if (namn === 'post') poster.push(v)
+    else enkla[namn] = v
+  }
+  const saknas = [
+    ...(enkla['repo-rot'] === undefined ? ['--repo-rot'] : []),
+    ...(poster.length === 0 ? ['--post'] : []),
+  ]
+  if (saknas.length > 0) return { fel: `saknar ${saknas.join(', ')}` }
+  if (!path.isAbsolute(enkla['repo-rot']))
+    return { fel: `--repo-rot måste vara en absolut sökväg (fick "${enkla['repo-rot']}")` }
+  if (enkla.arkiv !== undefined && !path.isAbsolute(enkla.arkiv))
+    return { fel: `--arkiv måste vara en absolut sökväg (fick "${enkla.arkiv}")` }
+  // `123` och `123/` är samma post: två körningar på den skulle vägras av
+  // kvittot ändå, men en dubblett i argv är ett skrivfel och stoppar före start.
+  const normerade = poster.map((p) => p.replace(/\/+$/, ''))
+  const dubblett = normerade.find((p, i) => normerade.indexOf(p) !== i)
+  if (dubblett !== undefined) return { fel: `--post ${dubblett} står två gånger` }
+  const parText = enkla.parallellt ?? String(STANDARD_PARALLELLT)
+  if (!/^\d+$/.test(parText) || Number(parText) < 1)
+    return { fel: `--parallellt måste vara ett heltal >= 1 (fick "${parText}")` }
+  let maxUsd = null
+  if (enkla['max-usd'] !== undefined) {
+    maxUsd = Number(enkla['max-usd'])
+    if (enkla['max-usd'].trim() === '' || !Number.isFinite(maxUsd) || maxUsd < 0)
+      return { fel: `--max-usd måste vara ett tal >= 0 (fick "${enkla['max-usd']}")` }
+  }
+  if (enkla.sprak !== undefined && !SPRAKEN.includes(enkla.sprak))
+    return { fel: `--sprak måste vara ${SPRAKEN.join(' eller ')} (fick "${enkla.sprak}")` }
+  if (enkla['design-mode'] !== undefined && !DESIGNLAGEN.includes(enkla['design-mode']))
+    return {
+      fel: `--design-mode måste vara ${DESIGNLAGEN.join(' eller ')} (fick "${enkla['design-mode']}")`,
+    }
+  return {
+    repoRot: enkla['repo-rot'],
+    arkiv: enkla.arkiv ?? null,
+    poster: normerade,
+    parallellt: Number(parText),
+    maxUsd,
+    claude: enkla.claude ?? 'claude',
+    om,
+    sprak: enkla.sprak ?? null,
+    designMode: enkla['design-mode'] ?? null,
+  }
+}
+
+/** En post namnges relativt arkivroten (`<gid>` eller `<gid>/del-N`), aldrig
+ *  som absolut sökväg och aldrig utanför roten. `{ dir }` eller `{ fel }`. */
+export function losPost(post, arkiv) {
+  if (path.isAbsolute(post))
+    return { fel: `--post ${post}: ange posten relativ arkivroten (<gid> eller <gid>/del-N)` }
+  const dir = path.join(arkiv, post)
+  const rel = path.relative(arkiv, dir)
+  if (rel === '' || rel === '..' || rel.startsWith(`..${path.sep}`))
+    return { fel: `--post ${post}: pekar utanför arkivroten` }
+  return { dir }
+}
+
+/** Taket för körningen: flaggan vinner, sedan `max_usd_per_batch` i
+ *  `<arkiv>/../request.json` (`.haus-workflow/request.json`), sedan 100. En
+ *  saknad eller trasig fil är defaulten, aldrig ett fel. */
+export function lasTak({ arkiv, maxUsd = null }) {
+  if (maxUsd !== null && maxUsd !== undefined) return maxUsd
+  const v = lasRequestJson(arkiv)?.max_usd_per_batch
+  if (typeof v === 'number' && Number.isFinite(v) && v >= 0) return v
+  return STANDARD_TAK_USD
+}
+
+/** `<arkiv>/../request.json` som objekt, eller null när den saknas eller är
+ *  trasig (defaulten gäller då, aldrig ett fel). */
+function lasRequestJson(arkiv) {
+  try {
+    const cfg = JSON.parse(readFileSync(path.join(arkiv, '..', 'request.json'), 'utf8'))
+    return cfg !== null && typeof cfg === 'object' && !Array.isArray(cfg) ? cfg : null
+  } catch {
+    return null
+  }
+}
+
+/** Designläget (ADR-0156): flaggan vinner, sedan `design_mode` i request.json
+ *  (`draft`, `intervju`; `interview` är `intervju`), annars `intervju`. Vägrar
+ *  aldrig: ett okänt värde i filen varnar (VARNING) och ger `intervju`, en
+ *  saknad nyckel eller en oläsbar fil är tyst `intervju`. */
+export function lasDesignlage({ arkiv, designMode = null }) {
+  if (designMode !== null && designMode !== undefined) return designMode
+  const v = lasRequestJson(arkiv)?.design_mode
+  if (v === undefined) return 'intervju'
+  if (v === 'draft') return 'draft'
+  if (v === 'intervju' || v === 'interview') return 'intervju'
+  console.error(`VARNING: design_mode i request.json okänt värde "${v}", intervju gäller`)
+  return 'intervju'
+}
+
+const lasState = (dir) => {
+  try {
+    const s = JSON.parse(readFileSync(path.join(dir, 'state.json'), 'utf8'))
+    return s !== null && typeof s === 'object' && !Array.isArray(s) ? s : null
+  } catch {
+    return null
+  }
+}
+
+/** En splitrot har sina delar som `del-N/`-kataloger under sig; delarna
+ *  prissätts var för sig och föräldern flyttas när den sista är klar. */
+const arSplitrot = (dir) => {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).some(
+      (e) => e.isDirectory() && /^del-\d+$/.test(e.name),
+    )
+  } catch {
+    return false
+  }
+}
+
+/** De billiga förutsättningarna, samma som korning.mjs:s
+ *  lasUnderlagProduktion prövar först, plus vägran att prissätta om utan
+ *  `--om`. `null` när posten får starta, annars orsaken. */
+export function forkontroll(dir, { om = false } = {}) {
+  const state = lasState(dir)
+  if (state === null) return 'state.json saknas eller trasig'
+  if (state.experiment === true) return 'experimentkatalog'
+  if (arSplitrot(dir)) return `delad post: prissätt delarna ${path.basename(dir)}/del-N`
+  if (
+    state.approval === null ||
+    typeof state.approval !== 'object' ||
+    Array.isArray(state.approval)
+  )
+    return 'approval saknas: kör bedöm-grinden'
+  // Ett stående stopp (granskarblock.md, ett designkvitto, en analys) köper
+  // aldrig en analys och två scorers; inte heller med --om.
+  if (state.stopp !== null && typeof state.stopp === 'object' && !Array.isArray(state.stopp))
+    return `stopp står (${state.stopp.utfall}, ${state.stopp.kalla}): respec eller designa först`
+  if (!om && (state.status === 'priced' || state.status === 'guard_run'))
+    return 'redan prissatt (--om kör om)'
+  return null
+}
+
+const stampel = (d) => d.toISOString().replace(/[-:]/g, '').slice(0, 15)
+
+/** Skapar `<post>/korningar/<YYYYMMDDTHHMMSS>` (UTC) och returnerar den;
+ *  finns stämpeln redan prövas `-2`, `-3` och så vidare. */
+export function korningsKatalog(post, now = new Date()) {
+  const rot = path.join(post, 'korningar')
+  mkdirSync(rot, { recursive: true })
+  const bas = stampel(now)
+  for (let n = 1; ; n++) {
+    const dir = path.join(rot, n === 1 ? bas : `${bas}-${n}`)
+    try {
+      mkdirSync(dir)
+      return dir
+    } catch (e) {
+      if (e?.code !== 'EEXIST') throw e
+    }
+  }
+}
+
+/** En designgranskning som stoppade utkastet (ADR-0156 beslut 3): posten
+ *  står på designed med state.design.review.verdict `stopp`. */
+const granskningenStoppade = (state) =>
+  state?.status === 'designed' && state?.design?.review?.verdict === 'stopp'
+
+/** Statusen för en körd post. En process som föll eller dödades är
+ *  `ofärdig` oavsett vad state.json säger; annars stopp (state.stopp, eller
+ *  en designgranskning som stoppade på status designed), spärr (OLIKA eller
+ *  annat som väntar på en dom), priced, och allt annat är en avvikelse. */
+export function avgorStatus({ exitCode, signal = null, state, sparrExit }) {
+  if (signal || exitCode !== 0) {
+    const orsak =
+      exitCode === null || exitCode === undefined
+        ? `processen dödades (${signal ?? 'okänd signal'})`
+        : `exit ${exitCode}`
+    return { status: 'ofärdig', orsak }
+  }
+  // Stoppets orsak följer med till tabellen (intervju krävs: …), så raden
+  // routas utan att någon läser state.json.
+  if (state?.stopp)
+    return typeof state.stopp.orsak === 'string' && state.stopp.orsak !== ''
+      ? { status: 'stopp', orsak: state.stopp.orsak }
+      : { status: 'stopp' }
+  // P4-21: en granskning som stoppade utkastet står i state.design.review,
+  // inte i state.stopp; utan den här raden blev den `ofärdig` i tabellen.
+  if (granskningenStoppade(state))
+    return { status: 'stopp', orsak: 'designgranskningen stoppade (design-review.md)' }
+  if (sparrExit === 1) return { status: 'väntar på dom' }
+  if (state?.status === 'priced') return { status: 'priced' }
+  return { status: 'ofärdig', orsak: `status ${state?.status ?? 'okänd'} utan stopp eller spärr` }
+}
+
+/** Har summan (de klara posterna plus de i flykt till snittet) nått taket? */
+export const kapNatt = (summaUsd, tak) => summaUsd >= tak
+
+/** Standardlöparen för archive.mjs: synkron, cwd i posten. */
+export const arkivStandard = (args, cwd) =>
+  spawnSync(process.execPath, [ARCHIVE, ...args], { cwd, encoding: 'utf8' })
+
+const felText = (r) => (r.stderr || r.stdout || '').trim() || `exit ${r.status}`
+
+/** Kvittot (beslut 3): `archive.mjs korning-start`. `{ ok: true }`,
+ *  `{ pagar: true, pid }` när en levande pid redan håller posten, annars
+ *  `{ fel }`. En övertagen död pid är ok; varningen skickas vidare. */
+export function startaKorning(dir, pid, runDir = null, { arkivKor = arkivStandard } = {}) {
+  const r = arkivKor(
+    ['korning-start', dir, '--pid', String(pid), ...(runDir ? ['--katalog-korning', runDir] : [])],
+    dir,
+  )
+  if (r.status === 0) {
+    const varning = /VARNING: .*/.exec(r.stderr ?? '')?.[0]
+    return varning ? { ok: true, varning } : { ok: true }
+  }
+  const pagar = /pågår \(pid (\d+)\)/.exec(r.stderr ?? '')
+  if (r.status === 2 && pagar) return { pagar: true, pid: Number(pagar[1]) }
+  return { fel: `korning-start: ${felText(r)}` }
+}
+
+/** Rensar kvittot med `archive.mjs korning-slut`. */
+export function avslutaKorning(dir, { arkivKor = arkivStandard } = {}) {
+  const r = arkivKor(['korning-slut', dir], dir)
+  return r.status === 0 ? { ok: true } : { ok: false, fel: `korning-slut: ${felText(r)}` }
+}
+
+/** Poäng och utfall ur postens gällande huvudprisfil
+ *  `score-pricing-v<maxN>.json` (utan suffix, samma fil som bluf läser), tomt
+ *  vid ett stopp och `-` när ingen prisfil finns. */
+export function lasPoang(dir) {
+  // En approximation: den högsta prisfilen på disk står för bluf:s upplösning
+  // av den gällande filen; BLUF:en i steg 8 kommer alltid ur bluf, aldrig härifrån.
+  const state = lasState(dir)
+  if (state?.stopp || granskningenStoppade(state)) return { poang: '', utfall: '' }
+  let maxN = 0
+  try {
+    for (const f of readdirSync(dir)) {
+      const m = /^score-pricing-v(\d+)\.json$/.exec(f)
+      if (m && Number(m[1]) > maxN) maxN = Number(m[1])
+    }
+  } catch {
+    return { poang: '-', utfall: '-' }
+  }
+  if (maxN === 0) return { poang: '-', utfall: '-' }
+  try {
+    const data = JSON.parse(readFileSync(path.join(dir, `score-pricing-v${maxN}.json`), 'utf8'))
+    return { poang: data?.score ?? '-', utfall: data?.outcome ?? '-' }
+  } catch {
+    return { poang: '-', utfall: '-' }
+  }
+}
+
+/** Sluttabellen: en rad per post i argv-ordning, USD med två decimaler. */
+export function renderaTabell(rader) {
+  const wall = (ms) => (Number.isFinite(ms) ? `${ms}ms` : '-')
+  const cell = (v) => String(v ?? '-').replace(/\|/g, '\\|')
+  return [
+    '| post | status | poäng | utfall | wall | USD |',
+    '| --- | --- | --- | --- | --- | --- |',
+    ...rader.map(
+      (r) =>
+        `| ${cell(r.post)} | ${cell(`${r.status}${r.orsak ? ` (${r.orsak})` : ''}`)} | ${cell(r.poang)} | ${cell(r.utfall)} | ${wall(r.wall_ms)} | ${usd(r.usd, 2)} |`,
+    ),
+  ].join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// Batchen (löparna injiceras i testerna; standard är archive.mjs och korning.mjs)
+// ---------------------------------------------------------------------------
+
+/** Argumenten till korning.mjs i produktionsläget (efter scriptets sökväg).
+ *  `--startare` är startarens pid: korning.mjs vaktar den och avbryter sig
+ *  själv om startaren dör utan att städa (SIGKILL). */
+export const korningArgv = ({
+  runDir,
+  dir,
+  repoRot,
+  claude,
+  sprak,
+  designMode = 'intervju',
+  startare,
+}) => [
+  '--katalog',
+  runDir,
+  '--post',
+  dir,
+  '--repo-rot',
+  repoRot,
+  '--modell',
+  'default',
+  '--claude',
+  claude,
+  '--startare',
+  String(startare),
+  '--design-mode',
+  designMode,
+  ...(sprak ? ['--sprak', sprak] : []),
+]
+
+/** korning.mjs i produktionsläget via svep.mjs:s korInre (stderr.log och
+ *  matning.json i körningskatalogen). */
+const korningStandard = ({ runDir, dir, repoRot, claude, sprak, designMode, pagaende, startare }) =>
+  korInre({
+    katalog: runDir,
+    repoRot,
+    pagaende,
+    args: [KORNING, ...korningArgv({ runDir, dir, repoRot, claude, sprak, designMode, startare })],
+  })
+
+const lasUsd = (runDir) => {
+  try {
+    const k = JSON.parse(readFileSync(path.join(runDir, 'korning.json'), 'utf8'))
+    return typeof k?.total_cost_usd === 'number' ? k.total_cost_usd : null
+  } catch {
+    return null
+  }
+}
+
+/** En post, hela ordningen ur ADR-0155. Kastar aldrig medvetet; ett kast
+ *  blir en `ofärdig`-rad i korBatch. */
+async function korPost(post, ctx) {
+  const { ut, arkivKor, korKorning, kvitton, summa, tak, konto } = ctx
+  const rad = (status, extra = {}) => ({ post, status, ...extra })
+  const los = losPost(post, ctx.arkiv)
+  if (los.fel) {
+    ut(`GRIND ${post}: ${los.fel}`)
+    return rad('grind', { orsak: los.fel })
+  }
+  const { dir } = los
+  if (!existsSync(dir)) {
+    const orsak = `katalogen saknas: ${dir}`
+    ut(`GRIND ${post}: ${orsak}`)
+    return rad('grind', { orsak })
+  }
+  const grind = forkontroll(dir, { om: ctx.om })
+  if (grind) {
+    ut(`GRIND ${post}: ${grind}`)
+    return rad('grind', { orsak: grind, ...lasPoang(dir) })
+  }
+  if (kapNatt(summa(), tak)) {
+    ut(`TAK ${post}`)
+    return rad('tak nått')
+  }
+  const runDir = korningsKatalog(dir, ctx.now ? ctx.now() : new Date())
+  const start = startaKorning(dir, ctx.pid ?? process.pid, runDir, { arkivKor })
+  if (start.pagar) {
+    rmdirSync(runDir)
+    ut(`PÅGÅR ${post} (pid ${start.pid})`)
+    return rad('pågår', { orsak: `pid ${start.pid}` })
+  }
+  if (start.fel) {
+    rmdirSync(runDir)
+    ut(`KLAR ${post} ofärdig`)
+    return rad('ofärdig', { orsak: start.fel })
+  }
+  if (start.varning) console.error(`${post}: ${start.varning}`)
+  kvitton.add(dir)
+  konto.iFlykt++
+  let belopp = null
+  try {
+    ut(`START ${post}`)
+    const k = await korKorning({
+      runDir,
+      dir,
+      repoRot: ctx.repoRot,
+      claude: ctx.claude,
+      sprak: ctx.sprak,
+      designMode: ctx.designMode,
+      pagaende: ctx.pagaende,
+      startare: ctx.pid ?? process.pid,
+    })
+    belopp = lasUsd(runDir)
+    const avg = k?.spawnfel
+      ? { status: 'ofärdig', orsak: `kunde inte starta korning.mjs: ${k.spawnfel}` }
+      : avgorStatus({
+          exitCode: k?.exitCode ?? null,
+          signal: k?.signal ?? null,
+          state: lasState(dir),
+          sparrExit: arkivKor(['sparr', dir], dir).status,
+        })
+    ut(`KLAR ${post} ${avg.status}`)
+    return rad(avg.status, {
+      ...(avg.orsak ? { orsak: avg.orsak } : {}),
+      ...lasPoang(dir),
+      wall_ms: k?.wall_ms ?? null,
+      usd: belopp,
+    })
+  } finally {
+    // Posten är klar för taket: ur flykten, in bland de klara med sin USD
+    // (en post utan korning.json räknas som 0).
+    konto.iFlykt--
+    konto.klara++
+    if (Number.isFinite(belopp)) konto.anvant += belopp
+    const slut = avslutaKorning(dir, { arkivKor })
+    if (!slut.ok) console.error(`VARNING ${post}: ${slut.fel}`)
+    kvitton.delete(dir)
+  }
+}
+
+/** Summan taket prövas mot: de klara posternas USD plus varje post i flykt
+ *  till de klaras snittkostnad (0 så länge ingen är klar). */
+export const taksumma = ({ anvant, klara, iFlykt }) =>
+  anvant + (klara > 0 ? iFlykt * (anvant / klara) : 0)
+
+/** Kör posterna med högst `parallellt` i flykt. Taket prövas vid varje
+ *  poststart mot `taksumma` (en post utan korning.json räknas som 0).
+ *  Returnerar raderna i argv-ordning och de klara posternas summa. */
+export async function korBatch({
+  poster,
+  arkiv,
+  repoRot,
+  parallellt,
+  tak,
+  om,
+  claude,
+  sprak,
+  designMode = 'intervju',
+  ut,
+  arkivKor = arkivStandard,
+  korKorning = korningStandard,
+  pagaende = new Map(),
+  kvitton = new Set(),
+  pid = process.pid,
+  now,
+}) {
+  const konto = { anvant: 0, klara: 0, iFlykt: 0 }
+  const ctx = {
+    arkiv,
+    repoRot,
+    om,
+    claude,
+    sprak,
+    designMode,
+    tak,
+    ut,
+    arkivKor,
+    korKorning,
+    pagaende,
+    kvitton,
+    pid,
+    now,
+    konto,
+    summa: () => taksumma(konto),
+  }
+  const resultat = await schemalagg(poster, parallellt, (post) => korPost(post, ctx))
+  const rader = resultat.map((r, i) =>
+    r?.fel !== undefined ? { post: poster[i], status: 'ofärdig', orsak: r.fel } : r,
+  )
+  return { rader, anvant: konto.anvant }
+}
+
+/** Avbrottet (SIGINT eller SIGTERM): SIGTERM till varje körning,
+ *  matning.json med signalen, och varje kvitto rensas, så nasta-steg inte
+ *  visar en körning som inte längre finns. Exit 130. */
+export const avbrottsHanterare =
+  ({
+    pagaende,
+    kvitton,
+    avsluta = avslutaKorning,
+    exit = process.exit,
+    logg = (rad) => console.error(rad),
+  }) =>
+  (signal) => {
+    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,
+      })
+    }
+    for (const dir of kvitton) avsluta(dir)
+    logg(
+      `avbrutet (${signal}): ${pagaende.size} körning(ar) dödade, ${kvitton.size} kvitto(n) rensade`,
+    )
+    exit(SIGNAL_EXIT)
+  }
+
+/** Samma hanterare för varje signal i AVBROTTSSIGNALER. */
+export function registreraAvbrott(proc, hanterare) {
+  for (const signal of AVBROTTSSIGNALER) proc.on(signal, () => hanterare(signal))
+}
+
+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 arkiv = val.arkiv ?? losArkiv(val.repoRot)
+  const felPoster = val.poster.map((p) => losPost(p, arkiv).fel).filter(Boolean)
+  if (felPoster.length > 0) {
+    for (const f of felPoster) console.error(f)
+    console.error(ANVANDNING)
+    return 2
+  }
+  const tak = lasTak({ arkiv, maxUsd: val.maxUsd })
+  const designMode = lasDesignlage({ arkiv, designMode: val.designMode })
+  const ut = (rad) => process.stdout.write(rad + '\n')
+  const pagaende = new Map()
+  const kvitton = new Set()
+
+  registreraAvbrott(process, avbrottsHanterare({ pagaende, kvitton }))
+
+  const { rader, anvant } = await korBatch({
+    poster: val.poster,
+    arkiv,
+    repoRot: val.repoRot,
+    parallellt: val.parallellt,
+    tak,
+    om: val.om,
+    claude: val.claude,
+    sprak: val.sprak,
+    designMode,
+    ut,
+    pagaende,
+    kvitton,
+  })
+  ut('')
+  ut(renderaTabell(rader))
+  ut(`tak: ${tak} USD, använt: ${anvant.toFixed(2)} USD`)
+  return rader.every((r) => RESULTAT.includes(r.status)) ? 0 : 1
+}
+
+/** 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))
+    .catch((e) => {
+      console.error(e?.stack ?? String(e))
+      process.exit(2)
+    })