@haus-tech/haus-workflow 4.9.0 → 5.0.0

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

@@ -0,0 +1,1376 @@
+#!/usr/bin/env node
+/**
+ * Arkivmekanikens normativa hem (ADR-0092): runs-stämpling, N-räkning och
+ * spärrstatus som deterministisk kod. SKILL.md beskriver flödet och anropar
+ * detta script; reglerna testas i tests/request-archive.test.js i stället
+ * för att drifta som prosa. Skriver aldrig om en befintlig runs-rad:
+ * arkivet är write-once, bara append.
+ *
+ * Del 1: add-run, next-n, sparr. Del 2 (Task 7): utslag (granskardomar),
+ * set-status (statusövergångar, med spärr på priced) och kalibrering
+ * (läs-enbart svepvy över kalibreringsnotiser).
+ *
+ * Användning:
+ *   node archive.mjs add-run <katalog> --file F --skill S --agent A --model M [flaggor]
+ *   node archive.mjs next-n <katalog> --typ classification [--typ score]
+ *   node archive.mjs ny-korning <modellkatalog>
+ *   node archive.mjs proveniens <körningskatalog> --modell M --konto K --underlag F [--datum D]
+ *   node archive.mjs sparr <katalog>
+ *   node archive.mjs utslag <katalog> --typ viktning|kalibrering|sakandring --beslutad-av N [...]
+ *   node archive.mjs set-status <katalog> <status>
+ *   node archive.mjs kalibrering <arkivrot>
+ * Exit 0 = ok, 1 = spärrad (sparr/set-status priced), 2 = användnings-/tillståndsfel.
+ */
+import {
+  readFileSync,
+  writeFileSync,
+  openSync,
+  closeSync,
+  renameSync,
+  unlinkSync,
+  statSync,
+  chmodSync,
+  readdirSync,
+  existsSync,
+  mkdirSync,
+} from 'node:fs'
+import path from 'node:path'
+import { createHash } from 'node:crypto'
+import {
+  markerStrippedSha256,
+  claudeDir,
+  canonicalModel,
+  CLASS_UTFALL,
+  SCORE_OUTCOMES,
+} from './lib.mjs'
+
+const [cmd, katalog, ...rest] = process.argv.slice(2)
+
+if (!cmd || !katalog) {
+  console.error(
+    'användning: archive.mjs <add-run|next-n|ny-korning|proveniens|sparr|utslag|set-status|kalibrering> <katalog> [flaggor]',
+  )
+  process.exit(2)
+}
+
+/** Ett flaggvärde får aldrig tyst bli nästa flaggas namn — `--file --skill`
+ *  ska vara ett fel, inte att `--file` råkar få värdet "--skill". */
+const valueAt = (name, i) => {
+  const v = rest[i + 1]
+  if (v === undefined || v.startsWith('--')) {
+    console.error(`--${name} kräver ett värde`)
+    process.exit(2)
+  }
+  return v
+}
+const flag = (name) => {
+  const i = rest.indexOf(`--${name}`)
+  return i === -1 ? null : valueAt(name, i)
+}
+const flags = (name) => rest.flatMap((v, i) => (v === `--${name}` ? [valueAt(name, i)] : []))
+/** En obligatorisk flagga som saknas är ett fel, aldrig en default: en
+ *  proveniensstämpel med gissad modell eller gissat konto ser exakt lika
+ *  giltig ut som en riktig och är omöjlig att upptäcka i efterhand. */
+const requireFlag = (name) => {
+  const v = flag(name)
+  if (v === null) {
+    console.error(`--${name} krävs`)
+    process.exit(2)
+  }
+  return v
+}
+const has = (name) => rest.includes(`--${name}`)
+
+/** Sökvägen till en katalogs state.json. Parametern har `katalog` som
+ *  default så varje befintlig anropare är oförändrad; `proveniens` behöver
+ *  den för att kunna stämpla delkatalogerna med samma kod som föräldern, i
+ *  stället för en andra skrivväg som kan glida isär. */
+const statePath = (d = katalog) => path.join(d, 'state.json')
+const today = () => new Date().toISOString().slice(0, 10)
+
+/** Trasig eller saknad state.json är alltid ett arkivfel (exit 2). En
+ *  parsningsbar men icke-objekt state.json (array, tal, sträng, null) är
+ *  LIKA trasig i acceptanskriteriets mening — annars skriver `sparr` OK rakt
+ *  igenom en korrupt post, och `add-run` mot en `[]` sparar tillbaka en tom
+ *  array (JSON.stringify slänger objektegenskaper på en array) och tappar
+ *  raden tyst. Samma sak gäller varje SKRIVBAR listas fält specifikt: en
+ *  behållare kan vara ett giltigt objekt medan fältet ändå är trasigt
+ *  (`"abc"`, `{}`, `5`). `[...(state.X ?? []), row]` sprider VAD SOM HELST
+ *  itererbart — en sträng sprids tecken för tecken till lika många
+ *  skräprader (och write-once bryts TYST: en `utslag` mot `granskarutslag:
+ *  "abc"` skriver om hela fältet till `['a','b','c',rad]` och rapporterar
+ *  OK), och ett icke-itererbart värde (objekt, tal) kastar ett oupptäckt
+ *  TypeError med exit 1 (kontraktets "spärrad", inte "trasigt arkiv"). Läs-
+ *  sidan är lika illa träffad: `liftedByUtslag` gör `.some()` på fältet, och
+ *  ett objekt/tal där kraschar OKONTROLLERAT (ingen `.some`-metod) med exit 1
+ *  — `sparr` och `set-status priced` dör med stacktrace i stället för att
+ *  vägra rent. Saknas fältet helt är det giltigt (ny post, tom lista); finns
+ *  det men är inte en array, eller har ett element som inte är ett objekt,
+ *  är det exit 2 — INNAN någon av de två (skriv- eller läs-)vägarna någonsin
+ *  når fältet. */
+class ArkivFel extends Error {}
+
+/** Validerar att ETT skrivbart listfält (runs, granskarutslag) verkligen är
+ *  en array av objekt — inte bara att behållaren (state) är ett objekt.
+ *  Delad mellan de två listorna med flit: `runs` fick fyra fixrundor i Task 6
+ *  för att komma fram till den här kontrollen, och `granskarutslag` är exakt
+ *  samma sårbarhetsklass (samma spridningsmönster vid skrivning, samma
+ *  `.some()`-krasch vid läsning) — samma fix, en gång, inte en andra kopia
+ *  som kan glida isär från den första. */
+const assertRowArrayField = (parsed, field, d = katalog) => {
+  if (parsed[field] === undefined) return
+  if (!Array.isArray(parsed[field])) {
+    throw new ArkivFel(
+      `${statePath(d)} har ett ${field}-fält som inte är en array (fick ${typeof parsed[field]})`,
+    )
+  }
+  // Behållarnivån räcker inte — varje ELEMENT måste vara ett objekt också.
+  // `null` i listan kraschar okontrollerat så fort någon läser en egenskap
+  // (TypeError, exit 1 — "spärrad" i det här kontraktet); ett tal eller en
+  // sträng kraschar inte direkt men sparas tillbaka som skräp och förblir
+  // osynligt för alltid.
+  const badIndex = parsed[field].findIndex(
+    (r) => r === null || typeof r !== 'object' || Array.isArray(r),
+  )
+  if (badIndex !== -1) {
+    throw new ArkivFel(
+      `${statePath(d)} har en ${field}-rad som inte är ett objekt (index ${badIndex})`,
+    )
+  }
+}
+
+const readStateOrThrow = (d = katalog) => {
+  let raw
+  try {
+    raw = readFileSync(statePath(d), 'utf8')
+  } catch (e) {
+    throw new ArkivFel(`kan inte läsa ${statePath(d)}: ${e.message}`)
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch (e) {
+    throw new ArkivFel(`${statePath(d)} är trasig JSON: ${e.message}`)
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    const fick = parsed === null ? 'null' : Array.isArray(parsed) ? 'array' : typeof parsed
+    throw new ArkivFel(`${statePath(d)} är inte ett state-objekt (fick ${fick})`)
+  }
+  assertRowArrayField(parsed, 'runs', d)
+  assertRowArrayField(parsed, 'granskarutslag', d)
+  return parsed
+}
+
+/** Läser state.json eller avslutar med exit 2. Används bara av de rena
+ *  läskommandona (next-n, sparr) som aldrig håller ett lås. */
+const loadStateOrExit = () => {
+  try {
+    return readStateOrThrow()
+  } catch (e) {
+    console.error(e.message)
+    process.exit(2)
+  }
+}
+
+/** Skriver state.json atomärt: till en temp-fil i samma katalog, sedan
+ *  rename över målet. rename(2) byter ut hela filen i ett steg, så en
+ *  läsare ser antingen hela den gamla eller hela den nya filen, ALDRIG en
+ *  trunkerad fil (till skillnad från writeFileSync direkt mot state.json,
+ *  som trunkerar målet innan den nya datan är skriven). Kastar ArkivFel på
+ *  skrivfel (t.ex. EACCES) i stället för att låta undantaget nå toppen som
+ *  en okontrollerad krasch med exit 1 — i det här kontraktet betyder exit 1
+ *  spärrad, och ett misslyckat skrivförsök är inte det. */
+const writeStateOrThrow = (s, d = katalog) => {
+  const rand = Math.random().toString(36).slice(2, 8)
+  const tmp = path.join(d, `.state.json.tmp-${process.pid}-${rand}`)
+  try {
+    writeFileSync(tmp, JSON.stringify(s, null, 2) + '\n')
+    // rename(2) byter inod, så temp-filens läge (satt av umask vid writeFileSync)
+    // skulle annars tyst ersätta en avsiktligt hårdare rättighet på den
+    // befintliga state.json (t.ex. 0600) med standardläget. Bevara det gamla
+    // läget om filen redan fanns; en ny post har inget läge att bevara.
+    try {
+      chmodSync(tmp, statSync(statePath(d)).mode)
+    } catch {
+      // ingen befintlig state.json (ny post) — inget läge att bevara.
+    }
+    renameSync(tmp, statePath(d))
+  } catch (e) {
+    try {
+      unlinkSync(tmp)
+    } catch {
+      // temp-filen skapades aldrig eller är redan borta — inget att städa.
+    }
+    throw new ArkivFel(`kunde inte skriva ${statePath(d)}: ${e.message}`)
+  }
+}
+
+/** Synkron sömn (blockerar tråden) för låsets pollning. Standardknepet för
+ *  att sova utan async i ett rent CLI-script: Atomics.wait somnar tills
+ *  timeouten går ut eftersom ingen annan agent notifierar den här cellen. */
+const sleepMs = (ms) => {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
+}
+
+/** `Number(x) || fallback` mappar ett uttryckligt `"0"` till fallback (0 är
+ *  falsy) — fel för en tröskel där 0 är ett giltigt, meningsfullt värde
+ *  ("ta över direkt"). Bara ett saknat/tomt/otolkbart värde faller tillbaka. */
+const envMs = (name, fallback) => {
+  const v = process.env[name]
+  if (v === undefined || v === '') return fallback
+  const n = Number(v)
+  return Number.isFinite(n) ? n : fallback
+}
+
+const LOCK_POLL_MS = 20
+// Fallback-horisont för när pid:et i låsfilen INTE går att pröva liv mot
+// (oläsbart innehåll, t.ex. `touch .archive.lock`) — då är ålder den enda
+// signal som finns. När pid:et ÄR läsbart avgör livskontrollen
+// ({@link isAlive}) i stället, oavsett ålder: en add-run tar normalt
+// millisekunder, men en riktig, levande innehavare ska aldrig bli bestulen
+// bara för att den råkar ta lång tid. Överridebar för tester.
+const LOCK_STALE_MS = envMs('ARCHIVE_LOCK_STALE_MS', 60 * 1000)
+// Kort nådeperiod innan en väntande process säger något — vanlig konkurrens
+// (två Bash-anrop i samma orkestratormeddelande) löses inom någon
+// millisekund och ska inte skriva ett ord till stderr.
+const LOCK_WARN_AFTER_MS = envMs('ARCHIVE_LOCK_WARN_AFTER_MS', 500)
+
+/** Läser pid + tidsstämpel ur en låsfil. `null` om filen försvann mellan
+ *  EEXIST och läsningen (ägaren släppte den just då — inget att invänta).
+ *  Pid:et måste vara ett positivt heltal (samma guard som hydrate-lock.ts
+ *  rad 132, `Number.isInteger(pid) && pid > 0`) — `process.kill` tolkar 0,
+ *  negativa tal och andra icke-positiva värden som PROCESSGRUPPER, som
+ *  nästan alltid "lyckas" oavsett vad som faktiskt körs. Utan den här
+ *  guarden skulle en låsfil vars första rad råkar vara "0" eller "-1"
+ *  alltid läsas som "levande" och hänga för alltid. Ett sådant pid
+ *  behandlas som oläsbart och faller till mtime-vägen nedan. */
+const readLockInfo = (lockPath) => {
+  let content
+  try {
+    content = readFileSync(lockPath, 'utf8')
+  } catch {
+    return null
+  }
+  const [pidLine, tsLine] = content.split('\n')
+  const parsedPid = Number.parseInt(pidLine, 10)
+  const pid = Number.isInteger(parsedPid) && parsedPid > 0 ? parsedPid : null
+  const ts = Date.parse(tsLine)
+  if (pid !== null && Number.isFinite(ts)) {
+    return { pid, ageMs: Date.now() - ts }
+  }
+  // Oläsbart eller ofullständigt innehåll (t.ex. `touch .archive.lock` som i
+  // granskningens repro, eller ett pid som inte är ett positivt heltal) —
+  // filens egen mtime är det enda ålderssignal som finns.
+  try {
+    return { pid: null, ageMs: Date.now() - statSync(lockPath).mtimeMs }
+  } catch {
+    return null
+  }
+}
+
+/** Samma livslängdsprobe som `hydrate-lock.ts`: en signal 0 mot ett dött pid
+ *  ger ESRCH (död), mot ett levande pid stör den inte processen alls. EPERM
+ *  betyder att processen finns men ägs av en annan användare — levande, och
+ *  att läsa det som dött hade kunnat stjäla en pågående körning. */
+const isAlive = (pid) => {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (e) {
+    return e.code === 'EPERM'
+  }
+}
+
+/**
+ * Exklusivt filsystemslås runt add-runs läs-ändra-skriv. Utan detta tappar
+ * två samtidiga add-run-anrop en rad tyst och rapporterar båda OK: orkestratorn
+ * (en LLM i Claude Code) skickar rutinmässigt två Bash-anrop i samma
+ * meddelande, och SKILL.md steg 8 kräver att paret arkiveras atomärt.
+ * `openSync(path, 'wx')` är atomärt på OS-nivå (misslyckas med EEXIST om
+ * filen redan finns) — det är hela låsprimitivet.
+ *
+ * Ett kvarlämnat lås (processen dödad mitt i kritiska sektionen) får ALDRIG
+ * bricka posten permanent, och en LEVANDE innehavare får ALDRIG bli bestulen
+ * bara för att den tar lång tid — de två felen är varandras spegelbild och
+ * båda stängs av samma konvention som `hydrate-lock.ts` (ADR-0074): pid +
+ * tidsstämpel i låsfilen, en `process.kill(pid, 0)`-probe avgör liv när
+ * pid:et går att läsa, ålder är fallback-signalen när det inte gör det
+ * (t.ex. `touch .archive.lock`, som saknar ett pid att pröva) — MEN ålder
+ * gäller även på livsgrenen som ett tak: `process.kill(pid, 0)` svarar bara
+ * på om NÅGOT med det numret lever, inte om det är samma process som skrev
+ * låsfilen. macOS pid-utrymmet slår runt vid 99999 (en aktiv utvecklingsmaskin
+ * bränner igenom det på timmar till dagar), så ett lås från en krasch för
+ * länge sedan kan mycket väl namnge en helt orelaterad, levande process
+ * idag. En riktig add-run håller låset i millisekunder, så ett lås som är
+ * `LOCK_STALE_MS` gammalt OCH namnger en levande process är inte en
+ * långsam arkivering, det är ett återanvänt pid — och där, precis som för
+ * ett dött pid, är det debris. Utan taket blir en återanvänd-pid-krock en
+ * OBEGRÄNSAD väntan, vilket är ett strikt sämre utfall än referensen:
+ * `hydrate-lock.ts` returnerar bara `{acquired:false}` i sitt "okänt"-fall
+ * (en hoppad hydrering), den här funktionen har ingen "hoppa över"-väg att
+ * falla tillbaka på.
+ */
+const acquireLock = () => {
+  const lockPath = path.join(katalog, '.archive.lock')
+  const start = Date.now()
+  let warned = false
+  const maybeWarn = (info) => {
+    if (warned || Date.now() - start <= LOCK_WARN_AFTER_MS) return
+    warned = true
+    console.error(
+      `väntar på ${lockPath} (innehas av pid ${info.pid ?? 'okänt'}, ` +
+        `${Math.round(info.ageMs / 1000)} s gammalt). Tas över automatiskt så snart ägaren ` +
+        `inte längre lever, eller under alla omständigheter efter ` +
+        `${Math.round(LOCK_STALE_MS / 1000)} s. Om ingen add-run faktiskt kör: radera filen ` +
+        `för hand och försök igen.`,
+    )
+  }
+
+  for (;;) {
+    try {
+      const fd = openSync(lockPath, 'wx')
+      writeFileSync(fd, `${process.pid}\n${new Date().toISOString()}\n`)
+      closeSync(fd)
+      return lockPath
+    } catch (e) {
+      if (e.code !== 'EEXIST') {
+        console.error(`kunde inte låsa ${lockPath}: ${e.message}`)
+        process.exit(2)
+      }
+      const info = readLockInfo(lockPath)
+      if (info === null) {
+        // TOCTOU: låsfilen försvann mellan EEXIST och läsningen. Ägaren kan
+        // ha släppt den (nästa varv i loopen tar den fria filen), ELLER en
+        // annan väntande process hann skapa ett NYTT, levande lås i exakt
+        // det fönstret — en unlink här skulle då radera det levande låset
+        // (granskningens deterministiska repro: fördröjning i just den
+        // punkten gav två processer i kritisk sektion samtidigt). Samma
+        // hantering som hydrate-lock.ts rad 181–188: ett nytt försök,
+        // ALDRIG en unlink.
+        continue
+      }
+      let debris
+      if (info.pid !== null) {
+        let alive
+        try {
+          alive = isAlive(info.pid)
+        } catch {
+          alive = true // okänt tolkas som levande, samma avvägning som hydrate-lock.ts
+        }
+        // Åldertaket gäller ÄVEN här: `alive` bara betyder att NÅGON process
+        // med det numret lever just nu, inte att det är samma process som
+        // skrev låsfilen. Ett pid-utrymme wrappar (macOS runt 99999), så ett
+        // lås som redan är LOCK_STALE_MS gammalt namnger med rimlig
+        // sannolikhet en återanvänd pid, inte en äkta, ovanligt långsam
+        // add-run — se motiveringen i funktionens docstring.
+        debris = !alive || info.ageMs > LOCK_STALE_MS
+      } else {
+        // Oläsbart innehåll — inget pid att pröva liv mot, bara mtime kvar.
+        debris = info.ageMs > LOCK_STALE_MS
+      }
+      if (!debris) {
+        maybeWarn(info)
+        sleepMs(LOCK_POLL_MS)
+        continue
+      }
+      try {
+        unlinkSync(lockPath)
+      } catch {
+        // redan borttagen av någon annan väntande process — varva om.
+      }
+      continue
+    }
+  }
+}
+const releaseLock = (lockPath) => {
+  try {
+    unlinkSync(lockPath)
+  } catch {
+    // redan borta — inget att göra.
+  }
+}
+
+/**
+ * Kända arkivfilnamn — allt annat är ett formfel i `--file` (t.ex. ett
+ * saknat "v" i "classification-pricing-1.json") som annars tyst arkiverar
+ * en rad som varken `next-n` eller `sparr` någonsin ser, eftersom ingendera
+ * matchar mönstret nedan.
+ *
+ * Alla tre mönstren matchar bara BASEN (spec, impact, eller typ + "-pricing-v"
+ * / "-guard-v" + siffror) och tillåter sedan en godtycklig kebab-suffixsvans
+ * — en uppräknad lista över exakta suffix visade sig ofullständig mot de
+ * skarpa arkiven på två sätt: en avvisad spec-leg (`spec-v1-avvisad.md`,
+ * ett precheck-BRIST-kvitto) matchade inte alls, och ett `run2`-ben kan i
+ * sig bli avvisat (kontraktsbrott på omkörningen) eller få en löpnummersvans
+ * vid upprepning (`-run2-avvisad-2`). Verifierat mot UNIONEN av `runs[].file`
+ * ur samtliga `state.json` i hemglass-workspace + haus-workflows egen
+ * dogfood-katalog (inklusive experiments/-trädets bunt-/del-underkataloger)
+ * — inte bara filer som råkar finnas kvar på disk, en avvisad läggning
+ * arkiveras ibland bara som kvitto i runs-raden. 19 distinkta namn, alla
+ * pinnade i tests/request-archive.test.js.
+ */
+const SPEC_RE = /^spec(-[a-z0-9-]+)?\.md$/
+const IMPACT_RE = /^impact(-[a-z0-9-]+)?\.md$/
+const PRICING_RE = /^(classification|score)-(pricing|guard)-v\d+(-[a-z0-9-]+)?\.json$/
+const FILE_PATTERNS = [SPEC_RE, IMPACT_RE, PRICING_RE]
+const isKnownFile = (file) => FILE_PATTERNS.some((re) => re.test(file))
+
+/**
+ * Underlagsprovenienens per filtyp — vilka dokument som faktiskt var indata
+ * till just den här filen, aldrig filen själv. En spec (avvisad eller ej)
+ * har inget underlag i repot (kundens råa önskemål räknas inte); en analys
+ * ser bara specen; pricing- och guard-filer ser bägge. Delar SPEC_RE/
+ * IMPACT_RE med `isKnownFile` ovan så de två aldrig kan glida isär — en
+ * avvisad spec-leg som vitlistan släpper igenom men underlagFor inte känner
+ * igen hade fallit till standardfallet och påstått spec.md+impact.md som
+ * sitt eget underlag, vilket är fel för en spec-leg. Verifierat mot riktiga
+ * arkiv i hemglass-workspace: spec.md-raden (och den avvisade
+ * spec-v1-avvisad.md-raden) bär tomt underlag_sha256, en
+ * impact(-superseded)-rad bär bara spec.md, en pricing-rad bär båda.
+ */
+const underlagFor = (file) => {
+  if (SPEC_RE.test(file)) return []
+  if (IMPACT_RE.test(file)) return ['spec.md']
+  return ['spec.md', 'impact.md']
+}
+
+/** Axlarna på ETT ställe — `next-n`s giltiga `--typ`-värden och `sparr`s
+ *  par (typ + svensk axelbeskrivning) fick tidigare stå dubbelt. */
+const AXLAR = [
+  { typ: 'classification', axel: 'klassaxeln' },
+  { typ: 'score', axel: 'poängaxeln' },
+]
+const TYPER = AXLAR.map((a) => a.typ)
+
+/** Stopputfall per axel för `set-status priced`-grinden. OFFERT (klass) och
+ *  POANG (poäng) är giltiga, prisbärande utfall och står medvetet UTANFÖR
+ *  listorna — allt annat kräver människa eller kund innan posten kan bli
+ *  priced. Källa: request-score/SKILL.md:s outcome-uppräkning. CLASS_STOP
+ *  finns kvar enbart för äldre arkiv med en klassaxel (ADR-0098); dess
+ *  källa var den borttagna request-classify/SKILL.md.
+ */
+const CLASS_STOP = ['KONCEPT', 'DIAGNOS', 'TILLBAKA_TILL_SPEC', 'INPUT_SAKNAS', 'ESKALERA']
+const SCORE_STOP = [
+  'KONCEPT',
+  'DIAGNOS',
+  'TILLBAKA_TILL_SPEC',
+  'DELA_UPP',
+  'OVER_SKALAN',
+  'INPUT_SAKNAS',
+  // ADR-0098: flyttad hit från CLASS_STOP när klassningen togs bort.
+  'ESKALERA',
+]
+
+/** Tak för antal körningar per modell. Skyddet är mot en trasig loop, inte mot
+ *  Tims arbetssätt: 999 körningar av samma modell på samma post är alltid ett
+ *  fel, aldrig en avsikt. */
+const MAX_KORNINGAR = 999
+
+/** Referensuppsättningen som `skill_sha256` täcker, relativt Claude-
+ *  konfigkatalogen. Listan bor HÄR och inte i anroparens flaggor: fem
+ *  sökvägar på kommandoraden är fem chanser att hasha över fel uppsättning,
+ *  och en hash över fel uppsättning ser precis lika giltig ut som en riktig.
+ *  request-classifier.md togs bort med klassaxeln (ADR-0098) — hashen byter
+ *  därmed värde, vilket är korrekt: en körning före och efter borttagningen
+ *  är inte samma kontrakt. */
+const PROVENIENS_REFERENSER = [
+  'agents/request-assessor.md',
+  'agents/request-scorer.md',
+  'agents/request-specifier-eskalerad.md',
+  'agents/request-specifier.md',
+  'skills/request/SKILL.md',
+]
+
+/** Kända statusvärden (SKILL.md: "spec_draft | spec_synced | assessed |
+ *  priced | guard_run"). `set-status` skrev tidigare VILKEN STRÄNG SOM HELST
+ *  rakt in i state.json — inklusive en flaggformad sträng om anroparen råkat
+ *  glömma statusvärdet (`set-status <katalog> --nagot-annat`), vilket hade
+ *  gett en tyst, obegriplig status i stället för ett fel. */
+const STATUSAR = ['spec_draft', 'spec_synced', 'assessed', 'priced', 'guard_run']
+
+/** Giltiga `--double-run`-värden (SKILL.md runs-kontraktet: "bekräftad" |
+ *  "olika" | "tolerans" | null). `add-run` skrev tidigare VILKEN STRÄNG SOM
+ *  HELST rakt in i fältet, samma klass av brist som `STATUSAR` ovan stänger
+ *  för statusvärdet, bara på det fält `sparr` faktiskt läser för att avgöra
+ *  om en post är spärrad. Läs- och skrivsidan delar den här listan med
+ *  flit: `sparr` (se `sparrSkal` nedan) behandlar ett värde UTANFÖR listan
+ *  som blockerande snarare än som "okänt, alltså inget att bry sig om". De
+ *  två måste stå still tillsammans, annars kan skrivsidan vitlista ett värde
+ *  lässidan aldrig lär sig känna igen (eller tvärtom). */
+const DOUBLE_RUN_VALUES = ['bekräftad', 'olika', 'tolerans']
+
+/** Gällande fil per typ: högsta N bland suffixfria -pricing-vN-filnamn i runs.
+ *  -run2 och -avvisad matchar mönstret aldrig, så de räknas aldrig med här,
+ *  och guard-filer (…-guard-vN.json) har ett annat namnmönster och matchar
+ *  inte heller — de har en egen N-sekvens, skild från pricing. */
+const GALLANDE_RE = (typ) => new RegExp(`^${typ}-pricing-v(\\d+)\\.json$`)
+const maxN = (runs, typ) =>
+  Math.max(0, ...runs.map((r) => Number(GALLANDE_RE(typ).exec(r.file ?? '')?.[1] ?? 0)))
+
+if (cmd === 'add-run') {
+  // Samma fail-closed-princip som `next-n` redan tillämpar (se dess kommentar
+  // ovan): varje token i `rest` måste höra till en KÄND flagga, annars är det
+  // ett fel, aldrig ett tyst struntvärde. Utan den här kontrollen försvann ett
+  // felstavat flaggnamn (`--double_run`, JSON-fältets understreck i stället
+  // för flaggans bindestreck) rakt in i tomma intet: `flag('double-run')`
+  // hittar den aldrig, `doubleRun` blir `null`, och `--double_run olika`
+  // stämplade en rad som "inget att bry sig om" i stället för att fälla ett
+  // fel, granskningens repro. `--file`/`--skill`/`--agent`/`--model` tar
+  // ETT värde var, `--ref` kan upprepas (nyckel=värde), `--partial-rerun` tar
+  // aldrig ett värde (booleansk flagga, som `has()` redan förutsätter).
+  const ADD_RUN_VARDEFLAGGOR = [
+    'file',
+    'skill',
+    'agent',
+    'model',
+    // ADR-0099: den fakturerade modellen, när dispatchern känner den. Raden
+    // bär både vad agenten uppgav och vad faktureringen visar.
+    'fakturerad',
+    'ref',
+    'effort',
+    'note',
+    'double-run',
+    'superseded-by',
+    'pairs-with',
+  ]
+  const ADD_RUN_BOOLFLAGGOR = ['partial-rerun']
+  const konsumerat = new Set()
+  rest.forEach((v, i) => {
+    if (!v.startsWith('--')) return
+    const namn = v.slice(2)
+    if (ADD_RUN_VARDEFLAGGOR.includes(namn)) {
+      konsumerat.add(i)
+      konsumerat.add(i + 1)
+    } else if (ADD_RUN_BOOLFLAGGOR.includes(namn)) {
+      konsumerat.add(i)
+    }
+  })
+  const ovantat = rest.filter((_, i) => !konsumerat.has(i))
+  if (ovantat.length > 0) {
+    console.error(
+      `add-run: okänd eller ej konsumerad flagga/argument (${ovantat.join(' ')}), ` +
+        `giltiga flaggor: ${[...ADD_RUN_VARDEFLAGGOR, ...ADD_RUN_BOOLFLAGGOR].map((n) => `--${n}`).join(', ')}`,
+    )
+    process.exit(2)
+  }
+
+  const file = flag('file')
+  const skill = flag('skill')
+  const agent = flag('agent')
+  const model = flag('model')
+  if (!file || !skill || !agent || !model) {
+    console.error('add-run kräver --file, --skill, --agent, --model')
+    process.exit(2)
+  }
+  if (!isKnownFile(file)) {
+    console.error(
+      `--file "${file}" matchar inget känt arkivmönster ` +
+        '(spec eller impact med valfri kebab-svans, t.ex. spec-v1-avvisad.md eller ' +
+        'impact-superseded-<datum>.md; <typ>-pricing-vN eller <typ>-guard-vN med valfri ' +
+        'suffixsvans, t.ex. -run2-avvisad)',
+    )
+    process.exit(2)
+  }
+  const referens = {}
+  for (const kv of flags('ref')) {
+    const eq = kv.indexOf('=')
+    if (eq === -1) {
+      console.error(`--ref kräver formen nyckel=värde, fick "${kv}"`)
+      process.exit(2)
+    }
+    referens[kv.slice(0, eq)] = kv.slice(eq + 1)
+  }
+  const effort = flag('effort')
+  const note = flag('note')
+  const doubleRun = flag('double-run')
+  // Samma vitlista som lässidan (`sparrSkal`, `DOUBLE_RUN_VALUES`) delar,
+  // annars kan skrivsidan sätta ett värde ("OLIKA" versalt, "oavgjord", vad
+  // som helst) som lässidan aldrig känner igen som blockerande. Granskningens
+  // repro: `--double-run OLIKA` (fel skiftläge) passerade `sparr` och
+  // `set-status priced` rakt igenom, eftersom `rad.double_run === 'olika'`
+  // (gemener, exakt sträng) aldrig matchade den lagrade versalen.
+  if (doubleRun !== null && !DOUBLE_RUN_VALUES.includes(doubleRun)) {
+    console.error(`okänt --double-run: "${doubleRun}" (giltiga: ${DOUBLE_RUN_VALUES.join(', ')})`)
+    process.exit(2)
+  }
+  const supersededBy = flag('superseded-by')
+  const partialRerun = has('partial-rerun')
+  const pairsWith = flag('pairs-with')
+
+  // Kritisk sektion: från låset förvärvas till det släpps får ingen annan
+  // add-run-process läsa eller skriva state.json för samma katalog.
+  const lockPath = acquireLock()
+  let rowCount
+  try {
+    const state = readStateOrThrow()
+    // Dubblettvakt: en PRICING-/GUARD-fil (klass- eller poängaxelns
+    // prisbärande dokument) får aldrig stämplas två gånger. Write-once är
+    // append-only på RADNIVÅ, men varje läsare (sparr, pricedBlockers,
+    // gallandeDokumentFil) tar den SENASTE raden för ett givet filnamn, så
+    // en andra add-run mot samma `--file` är i praktiken "senast vinner", och
+    // en vanlig omstämpling utan `--double-run` kan tyst desarmera en stående
+    // `double_run: "olika"`-spärr (granskningens repro). spec.md och
+    // impact.md är UNDANTAGNA med flit: en respec ERSÄTTER innehållet under
+    // samma filnamn (se SKILL.md, "Respec över befintlig katalog invaliderar
+    // analysen") och skriver en ny, legitim runs-rad för samma `--file` varje
+    // gång. De bär inget `double_run`/`partial_rerun`-tillstånd att desarmera,
+    // så en repeterad stämpling där är avsedd, inte en lucka.
+    if (PRICING_RE.test(file) && (state.runs ?? []).some((r) => r.file === file)) {
+      throw new ArkivFel(
+        `--file "${file}" är redan arkiverad (finns som runs-rad). En pricing-/guard-fil ` +
+          'kan aldrig stämplas två gånger, det skulle tyst kunna desarmera en stående spärr ' +
+          '(en riktig omkörning får ett NYTT filnamn via next-n, t.ex. -run2 eller nästa vN)',
+      )
+    }
+    const row = {
+      file,
+      skill,
+      agent,
+      // ADR-0099: två fält — uppgiven (MODELL-svansraden, agentens självrapport)
+      // och fakturerad (faktureringslagret, när den är känd). Äldre arkiv bär
+      // en ren sträng här; läsare ska tåla båda formerna.
+      model: { uppgiven: model, fakturerad: flag('fakturerad') ?? null },
+      effort,
+      date: today(),
+      reference_sha256: referens,
+      underlag_sha256: {},
+      double_run: doubleRun,
+      superseded_by: supersededBy,
+      partial_rerun: partialRerun,
+      pairs_with: pairsWith,
+    }
+    if (note) row.note = note
+    for (const u of underlagFor(file)) {
+      const p = path.join(katalog, u)
+      try {
+        row.underlag_sha256[u] = markerStrippedSha256(p)
+      } catch (e) {
+        if (e.code !== 'ENOENT')
+          throw new ArkivFel(`kunde inte hasha underlaget ${p}: ${e.message}`)
+        // ENOENT: underlagsfilen finns inte ännu (t.ex. impact.md före assessorn) —
+        // hoppa över den, arkivera aldrig en påhittad hash.
+      }
+    }
+    state.runs = [...(state.runs ?? []), row]
+    writeStateOrThrow(state)
+    rowCount = state.runs.length
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log(`OK: runs-rad för ${file} (${rowCount} rader)`)
+} else if (cmd === 'next-n') {
+  // `flags('typ')` bara SAMLAR IN varje värde som direkt följer ett `--typ`
+  // — den validerar aldrig att RESTEN av `rest` är just sådana par. Ett
+  // anrop skrivet som `--typ classification score` (en flagga, tänkt som en
+  // lista) ger alltså `typer = ['classification']` och tyst SLÄNGER
+  // `score` som ett obehandlat positionsargument, ingen varning. Det är
+  // granskningens repro: `--n` blev 1 för lågt eftersom scoreaxelns varv
+  // aldrig räknades med, och `add-run` skriver sedan över en redan
+  // arkiverad fil (ingen överskrivningsvakt där) — helt tyst, exit 0.
+  // Fail-closed-principen som resten av scriptet följer (se t.ex.
+  // `valueAt` ovan) kräver att den här formen vägras, inte tolkas löst:
+  // command-formen är upprepad `--typ <värde>`, ALDRIG en flagga med flera
+  // värden, och varje token i `rest` måste höra till ett sådant par.
+  const konsumerat = new Set()
+  rest.forEach((v, i) => {
+    if (v === '--typ') {
+      konsumerat.add(i)
+      konsumerat.add(i + 1)
+    }
+  })
+  const ovantat = rest.filter((_, i) => !konsumerat.has(i))
+  if (ovantat.length > 0) {
+    console.error(
+      `next-n: oväntat argument (${ovantat.join(' ')}) — upprepa --typ per axel, ` +
+        't.ex. `--typ classification --typ score`, aldrig `--typ classification score`',
+    )
+    process.exit(2)
+  }
+  const typer = flags('typ')
+  if (typer.length === 0) {
+    console.error('next-n kräver minst en --typ classification|score')
+    process.exit(2)
+  }
+  const okanda = typer.filter((t) => !TYPER.includes(t))
+  if (okanda.length > 0) {
+    console.error(`okänd --typ: ${okanda.join(', ')} (giltiga: ${TYPER.join(', ')})`)
+    process.exit(2)
+  }
+  const runs = loadStateOrExit().runs ?? []
+  console.log(String(Math.max(...typer.map((t) => maxN(runs, t))) + 1))
+} else if (cmd === 'sparr') {
+  const state = loadStateOrExit()
+  const skal = sparrSkal(state)
+  if (skal.length === 0) {
+    console.log('OK')
+  } else {
+    for (const s of skal) console.log(`SPÄRRAD: ${s}`)
+    process.exit(1)
+  }
+} else if (cmd === 'utslag') {
+  const typ = flag('typ')
+  if (!['viktning', 'kalibrering', 'sakandring'].includes(typ)) {
+    console.error('utslag kräver --typ viktning|kalibrering|sakandring')
+    process.exit(2)
+  }
+  const beslutadAv = flag('beslutad-av')
+  if (!beslutadAv) {
+    console.error('utslag kräver --beslutad-av <namn>')
+    process.exit(2)
+  }
+  const row = { typ, date: today(), beslutad_av: beslutadAv }
+  if (typ === 'viktning') {
+    const beslut = flag('beslut')
+    const axel = flag('axel')
+    const gallerFil = flag('galler-fil')
+    // flag('n') === null (flaggan saknas helt) måste skiljas från ett
+    // ogiltigt värde — Number(null) är 0, ett GILTIGT heltal, så en bar
+    // `Number(flag('n'))` hade tyst gjort en SAKNAD --n till n=0 i stället
+    // för att vägra. Number(NaN) är aldrig ett heltal, så den vägen vägrar
+    // korrekt både "saknas" och "otolkbart".
+    const nRaw = flag('n')
+    const n = nRaw === null ? NaN : Number(nRaw)
+    if (!beslut || !axel || !gallerFil || !Number.isInteger(n) || n < 0) {
+      console.error('viktning kräver --beslut, --axel, --n (icke-negativt heltal), --galler-fil')
+      process.exit(2)
+    }
+    // --axel är inte fritext: fel värde (t.ex. "bogus") skriver ett utslag
+    // som failar STÄNGT (liftedByUtslag matchar aldrig okänt axelnamn mot
+    // TYPER), men VILSELEDER granskaren, som tror posten är upplåst medan
+    // sparr fortfarande spärrar. Samma vitlista som next-n redan använder.
+    if (!TYPER.includes(axel)) {
+      console.error(`okänd --axel: ${axel} (giltiga: ${TYPER.join(', ')})`)
+      process.exit(2)
+    }
+    // galler_fil är det prisbärande dokumentet ett viktningsutslag pekar på
+    // (se gallandeDokumentFil), fem kontroller, alla nödvändiga:
+    // (1) samma filnamnsmönster add-run redan vitlistar, så ett påhittat
+    //     namn inte kan lyfta en spärr mot ett dokument som aldrig skulle
+    //     godkänts som runs-rad;
+    // (2) filen måste faktiskt höra till den axel utslaget namnger, annars
+    //     kan ett viktningsutslag för "classification" peka på en score-fil,
+    //     och gallandeDokumentFil skulle läsa fel dokuments utfall/outcome;
+    // (3) filen måste vara en PRICING-fil (aldrig guard) för just den axeln,
+    //     med ett läsbart versionsnummer. En guard-fil matchar (1) och (2)
+    //     men hör till en annan mekanik och kan aldrig vara ett prisunderlag;
+    // (4) filnamnets versionsnummer får aldrig vara HÖGRE än --n. Fix-runda 1
+    //     låste detta till EXAKT --n, men det stängde en legitim dom: efter
+    //     en beställd omkörning (döm, "Beställ omkörning") har axeln bumpats
+    //     till ett nytt varv (säg v3), granskaren ser DÅ tre körningar (de två
+    //     ursprungliga plus omkörningen) och kan mycket väl döma att en av de
+    //     ursprungliga (v1 eller v2) hade rätt hela tiden. Med exakt-matchning
+    //     vägrade scriptet den domen (`--n 3 --galler-fil ...-v2.json`) medan
+    //     `--n 2` inte lyfter något (2 är inte gällande n längre), och
+    //     write-once gjorde det till en permanent död rad. `<=` löser det
+    //     utan att öppna dörren åt fel håll: en dom kan peka BAKÅT på ett
+    //     varv som redan fanns när den skrevs, aldrig FRAMÅT på ett som inte
+    //     fanns än (det är samma "domen honoreras för fel varv"-brist som
+    //     skrivtidskontrollen för --n själv stänger, se nedan, bara
+    //     spegelvänd till filnamnssidan);
+    // (5) filen måste FAKTISKT vara arkiverad, alltså finnas som en `runs`-rad
+    //     (kontrolleras nedan, inne i den kritiska sektionen där `state` finns)
+    //     OCH finnas på disk nu. `runs`-kravet stänger en plantering (en JSON-
+    //     fil som råkar matcha namnmönstret men aldrig gick via `add-run`);
+    //     disk-kravet stänger att domen pekar på ett dokument ingenting kan
+    //     läsa, vilket annars mötte priced-kontrollen som ett integritetsfel
+    //     (ArkivFel) första gången någon försökte läsa den.
+    if (!isKnownFile(gallerFil)) {
+      console.error(`--galler-fil "${gallerFil}" matchar inget känt arkivmönster`)
+      process.exit(2)
+    }
+    if (!gallerFil.startsWith(`${axel}-`)) {
+      console.error(`--galler-fil "${gallerFil}" hör inte till axeln ${axel}`)
+      process.exit(2)
+    }
+    const versionMatch = new RegExp(`^${axel}-pricing-v(\\d+)(-[a-z0-9-]+)?\\.json$`).exec(
+      gallerFil,
+    )
+    if (!versionMatch) {
+      console.error(
+        `--galler-fil "${gallerFil}" är inte en pricing-fil för axeln ${axel} ` +
+          '(guard-filer kan aldrig vara prisunderlag för ett viktningsutslag)',
+      )
+      process.exit(2)
+    }
+    const gallerFilN = Number(versionMatch[1])
+    if (gallerFilN > n) {
+      console.error(
+        `--galler-fil "${gallerFil}" pekar på ett FRAMTIDA varv (v${gallerFilN}) för --n ${n}, ` +
+          'en dom kan bara gälla ett varv som redan fanns när den skrevs',
+      )
+      process.exit(2)
+    }
+    if (!existsSync(path.join(katalog, gallerFil))) {
+      console.error(`--galler-fil "${gallerFil}" finns inte i ${katalog}`)
+      process.exit(2)
+    }
+    Object.assign(row, { beslut, axel, n, galler_fil: gallerFil })
+  } else if (typ === 'kalibrering') {
+    const fraga = flag('fraga')
+    const lasning1 = flag('lasning1')
+    const lasning2 = flag('lasning2')
+    if (!fraga || !lasning1 || !lasning2) {
+      console.error('kalibrering kräver --fraga, --lasning1, --lasning2')
+      process.exit(2)
+    }
+    Object.assign(row, { fraga, lasning1, lasning2 })
+  } else {
+    const beslut = flag('beslut')
+    if (!beslut) {
+      console.error('sakandring kräver --beslut')
+      process.exit(2)
+    }
+    row.beslut = beslut
+  }
+
+  // Samma lås som add-run — write-once gäller granskarutslag precis som runs.
+  const lockPath = acquireLock()
+  let rowCount
+  try {
+    const state = readStateOrThrow()
+    // n får aldrig peka på ett varv som inte finns ÄN. Kontrolleras här, inne
+    // i den kritiska sektionen och mot samma `state` som just lästs — annars
+    // kan --n namnge ett framtida varv (next-n skriver ut maxN+1, ett utslags
+    // --n betyder maxN, de två självklara talen skiljer med ett i just den
+    // förväxlingen) och en människa kan aldrig ha dömt om ett dokument som
+    // inte fanns när domen skrevs. Detta är den SUBSTANTIELLA halvan av
+    // fixen: den stänger dörren vid källan, innan en spekulativ rad någonsin
+    // kan hamna i granskarutslag. `liftingUtslag`s `===`-jämförelse (se dess
+    // kommentar) är den KOMPLETTERANDE halvan — djupförsvar mot en rad som
+    // ändå finns (äldre arkiv från före den här kontrollen, eller ett
+    // handredigerat state.json), inte en ersättning för den här kontrollen.
+    if (row.typ === 'viktning') {
+      const gallande = maxN(state.runs ?? [], row.axel)
+      if (row.n > gallande) {
+        throw new ArkivFel(
+          `--n ${row.n} är högre än gällande varv (${gallande}) för ${row.axel} — ` +
+            'ett utslag kan bara handla om ett varv som redan finns',
+        )
+      }
+      // Disk-existensen (kontrollerad ovan, före låset) bevisar att FILEN
+      // finns, inte att den kom dit via en legitim `add-run`. Utan detta
+      // kunde en planterad JSON, aldrig arkiverad, ändå lyfta en spärr och
+      // bli priced-kontrollens gällande dokument.
+      if (!(state.runs ?? []).some((r) => r.file === row.galler_fil)) {
+        throw new ArkivFel(
+          `--galler-fil "${row.galler_fil}" finns inte bland arkiverade körningar ` +
+            `för ${row.axel} (state.json.runs). Ett utslag kan bara peka på en fil ` +
+            'som faktiskt arkiverades via add-run',
+        )
+      }
+    }
+    state.granskarutslag = [...(state.granskarutslag ?? []), row]
+    writeStateOrThrow(state)
+    rowCount = state.granskarutslag.length
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log(`OK: ${typ}-utslag (${rowCount} rader)`)
+} else if (cmd === 'set-status') {
+  const status = rest[0]
+  if (!status) {
+    console.error('set-status kräver ett statusvärde')
+    process.exit(2)
+  }
+  if (!STATUSAR.includes(status)) {
+    console.error(`okänt statusvärde: ${status} (giltiga: ${STATUSAR.join(', ')})`)
+    process.exit(2)
+  }
+  const lockPath = acquireLock()
+  let stopp = []
+  try {
+    const state = readStateOrThrow()
+    if (status === 'priced') {
+      // pricedBlockers kan kasta ArkivFel (trasigt/saknat gällande pricing-
+      // fil) — den vägen fångas av samma catch nedan och blir exit 2, ALDRIG
+      // tolkat som "inget blockerar".
+      stopp = pricedBlockers(state)
+    }
+    if (stopp.length === 0) {
+      state.status = status
+      writeStateOrThrow(state)
+    }
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  if (stopp.length > 0) {
+    for (const s of stopp) console.log(`VÄGRAR priced: ${s}`)
+    process.exit(1)
+  }
+  console.log(`OK: status ${status}`)
+} else if (cmd === 'kalibrering') {
+  // Läs-enbart svepvy: `katalog` är här arkivROTEN, inte en enskild post.
+  // Ingen lås, ingen skrivning — en trasig state.json någonstans i trädet
+  // ska aldrig stoppa hela listningen, bara hoppas över och rapporteras.
+  const root = katalog
+  const rader = []
+  const hoppade = []
+  const walk = (dir) => {
+    let entries
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch (e) {
+      hoppade.push(`${dir}: ${e.message}`)
+      return
+    }
+    if (entries.some((e) => e.isFile() && e.name === 'state.json')) {
+      const p = path.join(dir, 'state.json')
+      try {
+        const parsed = JSON.parse(readFileSync(p, 'utf8'))
+        const utslagList = Array.isArray(parsed?.granskarutslag) ? parsed.granskarutslag : []
+        for (const u of utslagList) {
+          if (u && typeof u === 'object' && u.typ === 'kalibrering') {
+            const rel = path.relative(root, dir) || '.'
+            rader.push(`${rel} · ${u.fraga} · ${u.beslutad_av} · ${u.date}`)
+          }
+        }
+      } catch (e) {
+        hoppade.push(`${p}: ${e.message}`)
+      }
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) walk(path.join(dir, entry.name))
+    }
+  }
+  walk(root)
+  for (const r of rader) console.log(r)
+  for (const h of hoppade) console.error(`hoppar över: ${h}`)
+} else if (cmd === 'ny-korning') {
+  // katalog är HÄR modellkatalogen (experiments/<slug>/<modell>), inte en
+  // postkatalog. Den skapas om den saknas: första körningen av en modell ska
+  // inte kräva ett förberedande steg.
+  try {
+    mkdirSync(katalog, { recursive: true })
+  } catch (e) {
+    console.error(`kunde inte skapa modellkatalogen ${katalog}: ${e.message}`)
+    process.exit(2)
+  }
+  for (let n = 1; n <= MAX_KORNINGAR; n++) {
+    const p = path.join(katalog, `k${n}`)
+    try {
+      // UTAN recursive: mkdir är atomiskt och kastar EEXIST om namnet är taget.
+      // Med recursive:true skulle den tyst lyckas på en befintlig katalog, och
+      // två samtidiga processer skulle dela körningskatalog. Det är hela
+      // poängen med det här subkommandot.
+      mkdirSync(p)
+      console.log(p)
+      process.exit(0)
+    } catch (e) {
+      if (e.code === 'EEXIST') continue
+      console.error(`kunde inte skapa ${p}: ${e.message}`)
+      process.exit(2)
+    }
+  }
+  console.error(`fler än ${MAX_KORNINGAR} körningar i ${katalog}, något är fel`)
+  process.exit(2)
+} else if (cmd === 'proveniens') {
+  // katalog är HÄR körningskatalogen (experiments/<slug>/<modell>/k<N>).
+  // Stämplingen stod tidigare bara som prosa i SKILL.md steg 4 och blev
+  // därför aldrig av: varje state.json på experimentytan saknade nyckeln och
+  // rapportens proveniensblock visade streck. Ett steg som ålägger startaren
+  // en skrivning måste anropa ett kommando.
+  const modell = requireFlag('modell')
+  const konto = requireFlag('konto')
+  const underlagFil = requireFlag('underlag')
+  const datum = flag('datum') ?? today()
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(datum)) {
+    console.error(`--datum måste vara YYYY-MM-DD (fick "${datum}")`)
+    process.exit(2)
+  }
+
+  /** Hashen räknas över hashar, inte över sammanslaget innehåll: sorterade
+   *  rader "<relativ sökväg>:<markör-strippad filhash>". Sorteringen gör
+   *  värdet oberoende av läsordning, och markör-strippningen är oundgänglig
+   *  av samma skäl som i runs[] — installern stämplar om filerna vid varje
+   *  haus-release, så en rå hel-fils-hash skulle byta värde utan att något
+   *  innehåll ändrats. */
+  const referensHash = () => {
+    const rader = []
+    for (const rel of [...PROVENIENS_REFERENSER].sort()) {
+      const p = path.join(claudeDir(), rel)
+      try {
+        rader.push(`${rel}:${markerStrippedSha256(p)}`)
+      } catch (e) {
+        // Aldrig en tyst överhoppad fil: hoppas en fil över betyder hashen
+        // något annat än förra veckan, utan att skillnaden syns någonstans.
+        console.error(`kunde inte läsa referensfilen ${p}: ${e.message}`)
+        process.exit(2)
+      }
+    }
+    return createHash('sha256').update(rader.join('\n')).digest('hex')
+  }
+
+  let underlagHash
+  try {
+    underlagHash = markerStrippedSha256(underlagFil)
+  } catch (e) {
+    console.error(`kunde inte läsa underlaget ${underlagFil}: ${e.message}`)
+    process.exit(2)
+  }
+
+  const stampel = {
+    modell,
+    datum,
+    konto,
+    skill_sha256: referensHash(),
+    underlag_sha256: underlagHash,
+  }
+
+  // ADR-0099: faktureringslagret är primär verifieringskälla för modell-
+  // override. Finns körningens korning.json antecknas den kanoniserade
+  // nyckelmängden ur modelUsage (suffix som `[1m]` strippas) — det är den
+  // startaren jämför mot varvets begärda modell. Saknas filen skrivs inget
+  // fält: en påhittad tom lista ser ut som "inga modeller anropades".
+  try {
+    const korning = JSON.parse(readFileSync(path.join(katalog, 'korning.json'), 'utf8'))
+    const nycklar = Object.keys(korning.modelUsage ?? {})
+    if (nycklar.length > 0)
+      stampel.fakturerade_modeller = [...new Set(nycklar.map(canonicalModel))].sort()
+  } catch (e) {
+    if (e.code !== 'ENOENT') {
+      console.error(`kunde inte läsa korning.json för fakturerade_modeller: ${e.message}`)
+      process.exit(2)
+    }
+  }
+
+  // Delarna är samma körning: samma modell, samma datum, samma hashar. De
+  // stämplas var för sig i sin egen state.json, aldrig genom att rapporten
+  // låter delkolumnen ärva förälderns värden vid läsning.
+  const delar = readdirSync(katalog, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && /^del-\d+$/.test(e.name))
+    .map((e) => path.join(katalog, e.name))
+    // En delkatalog utan state.json är inte en körning ännu och hoppas över;
+    // att fälla hela stämplingen på den vore att låta ett halvfärdigt DELA_UPP
+    // blockera proveniensen för allt annat.
+    .filter((d) => existsSync(path.join(d, 'state.json')))
+    .sort()
+
+  const lockPath = acquireLock()
+  try {
+    // Två pass med flit: alla kataloger prövas mot en befintlig stämpel INNAN
+    // någon skrivs, annars kan en avvikande del-2 lämna föräldern stämplad och
+    // delarna halvstämplade, ett läge ingen kod städar upp.
+    const attSkriva = []
+    for (const d of [katalog, ...delar]) {
+      const state = readStateOrThrow(d)
+      const befintlig = state.proveniens
+      if (befintlig === undefined) {
+        attSkriva.push([d, state])
+        continue
+      }
+      const skiljer = Object.keys(stampel).filter(
+        (k) => (befintlig === null ? undefined : befintlig[k]) !== stampel[k],
+      )
+      if (skiljer.length > 0) {
+        throw new ArkivFel(
+          `${statePath(d)} har redan en proveniens som skiljer sig (${skiljer.join(', ')}) — arkivet är append-only, en omstämpling raderar just den skillnad stämpeln finns för att visa`,
+        )
+      }
+    }
+    for (const [d, state] of attSkriva) writeStateOrThrow({ ...state, proveniens: stampel }, d)
+    releaseLock(lockPath)
+    console.log(
+      attSkriva.length === 0
+        ? 'OK: proveniens oförändrad'
+        : `OK: proveniens stämplad i ${attSkriva.length} katalog(er)`,
+    )
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+} else {
+  console.error(
+    'okänt kommando (add-run, next-n, ny-korning, proveniens, sparr, utslag, set-status, kalibrering)',
+  )
+  process.exit(2)
+}
+
+/** Det SENASTE viktningsutslaget (om något) som lyfter en axel vid ett givet
+ *  gällande n — namnger axeln, har ett `n` som är EXAKT det gällande n:et
+ *  (inte "minst lika högt"), och bär en `galler_fil`.
+ *
+ *  Jämförelsen är AVSIKTLIGT `===`, inte `>=`. Ett utslag gäller EXAKT det
+ *  varv det skrevs för — en människa kan bara döma om ett dokument hon har
+ *  läst, aldrig om ett framtida varv som inte finns än. Ett nytt varv är en
+ *  ny bedömning ingen har dömt om, och ska kräva ett NYTT utslag i stället
+ *  för att ärva ett gammalt. Med `>=` lyfte/omdirigerade en rad med ett för
+ *  högt `n` (skrivet innan det varvet ens fanns — utslags `--n` betyder
+ *  gällande maxN, medan `next-n` skriver ut maxN+1, så de två självklara
+ *  talen skiljer med ett och är lätta att förväxla) VARJE varv från och med
+ *  det att arkivet skrevs och tills gällande n hann i kapp — och en absurt
+ *  hög `--n` (t.ex. 1000, som `utslag` accepterar som ett vanligt heltal)
+ *  gjorde blocket PERMANENT lyft för alla varv upp till dess, eftersom
+ *  write-once gör raden omöjlig att dra tillbaka. `utslag`s skrivtidskontroll
+ *  (`n > maxN` vägras, se dess kommentar) stänger dörren vid källan för NYA
+ *  rader; den här `===`-jämförelsen är det KOMPLETTERANDE djupförsvaret på
+ *  lässidan — mot en rad som ändå finns (äldre arkiv från före
+ *  skrivtidskontrollen, eller ett handredigerat state.json), inte en ersättning
+ *  för skrivtidskontrollen. FÖRSÖK ALDRIG "förenkla" tillbaka till `>=` — det
+ *  återinför exakt den permanenta-block-buggen.
+ *
+ *  "Senaste" (inte första) matchande rad: write-once gäller ORDNINGEN
+ *  raderna skrevs i, inte att bara den första domen om en axel räknas för
+ *  alltid — samma princip som `sparrSkal` redan använder för att hitta den
+ *  senaste runs-raden för en fil (`[...runs].reverse().find(...)`).
+ *
+ *  Delad av `liftedByUtslag` (som bara bryr sig OM något lyfter) och
+ *  `gallandeDokumentFil` (som bryr sig om VILKEN fil den domen pekar på) —
+ *  ett enda ställe som avgör detta, så de två aldrig kan råka svara på olika
+ *  frågor om två utslag skulle peka åt olika håll. */
+function liftingUtslag(state, typ, n) {
+  return (
+    [...(state.granskarutslag ?? [])]
+      .reverse()
+      .find((u) => u.typ === 'viktning' && u.axel === typ && (u.n ?? 0) === n && u.galler_fil) ??
+    null
+  )
+}
+
+/** Granskarutslag med typ, axel och gällande N som lyfter spärren när ett
+ *  senare riktat varv landat LIKA/LIKA_TOLERANS: en viktningsrad som namnger
+ *  just den axeln och exakt det gällande n:et (se `liftingUtslag`) räcker.
+ *  `utslag`-kommandot är den enda skrivvägen till granskarutslag, så utan en
+ *  sådan rad är arkivet tomt här och funktionen alltid falsk — det är
+ *  "stubben" tills utslag finns, inte ett hårdkodat `return false`. */
+function liftedByUtslag(state, typ, n) {
+  return liftingUtslag(state, typ, n) !== null
+}
+
+/** Sparr-spärrens skäl, utan I/O — delad av `sparr`-kommandot och
+ *  `pricedBlockers` (set-status priced måste vägra av exakt samma skäl).
+ *
+ *  TRE skäl blockerar, och inget är de andras specialfall:
+ *  (1) `double_run: "olika"` på gällande fil, den ordinarie dubbelkörnings-
+ *      oenigheten (se `bedöm` steg 6 i SKILL.md);
+ *  (2) `partial_rerun: true` på gällande fil UTAN en matchande dom. En
+ *      beställd omkörning (`döm`, vägen "Beställ omkörning") skriver ALDRIG
+ *      ett jämförelseutslag av sig själv, det är en mätning som väntar på
+ *      granskarens dom, inte ett utslag i sig. Fix-runda 1-regression: den
+ *      gamla mekaniken tvingade dubbelkörning på det riktade varvet, så
+ *      raden bar alltid `double_run: "olika"/"bekräftad"/"tolerans"` från
+ *      compare-scriptet. Task 8 tog bort den tvångsdubblingen (döm beställer
+ *      EN körning) utan att ersätta spärren: en ensam körning har inget att
+ *      jämföra mot, så raden fick `double_run: null`, och (1) ensam missade
+ *      den helt: sparr gav OK och `set-status priced` gick igenom med tomt
+ *      `granskarutslag` (granskningens repro). `partial_rerun` är signalen
+ *      här, inte `double_run`s värde: vilket värde det än råkar bära (eller
+ *      sakna) väntar en partial_rerun-rad alltid på en explicit dom.
+ *  (3) `double_run` bär ett värde som INTE är `null`/`undefined` och INTE
+ *      finns i `DOUBLE_RUN_VALUES`. Ett okänt värde tolkas som blockerande,
+ *      aldrig som "inget att bry sig om". `add-run` vitlistar numera värdet
+ *      vid SKRIVNING (se dess kommentar), men den kontrollen skyddar bara
+ *      RADER SOM SKRIVS EFTER fixen. Skarpa arkiv från före den (eller ett
+ *      handredigerat state.json) kan bära ett värde ingen vitlista någonsin
+ *      godkände, konkret `"oavgjord"`, ett ord en tidigare orkestrator-
+ *      generation hittade på för "kunde inte avgöras" innan `sparr` ens
+ *      fanns som kod. Fail-OPEN här (bara jämföra mot exakt `"olika"` och
+ *      strunta i resten) läser en okänd sträng som en frisläppt post, precis
+ *      den läsordning granskningen visade. Fail-CLOSED, som `pricedBlockers`
+ *      redan tillämpar på pricing-filens `utfall`/`outcome`-enum, är den
+ *      enda säkra tolkningen av ett fält vars hela existens är att avgöra om
+ *      en människa redan sagt sitt: vet scriptet inte vad värdet betyder, kan
+ *      det aldrig veta att INGEN dom krävs. */
+function sparrSkal(state) {
+  const runs = state.runs ?? []
+  const skal = []
+  for (const { typ, axel } of AXLAR) {
+    const n = maxN(runs, typ)
+    if (n === 0) continue
+    const fil = `${typ}-pricing-v${n}.json`
+    const rad = [...runs].reverse().find((r) => r.file === fil)
+    if (!rad || liftedByUtslag(state, typ, n)) continue
+    if (rad.double_run != null && !DOUBLE_RUN_VALUES.includes(rad.double_run)) {
+      skal.push(
+        `${axel} bär okänt double_run "${rad.double_run}" på ${fil}, ett värde som inte ` +
+          'går att tolka som avgjort räknas som blockerande',
+      )
+    } else if (rad.double_run === 'olika') {
+      skal.push(`${axel} bär double_run "olika" på ${fil} utan dom`)
+    } else if (rad.partial_rerun === true) {
+      skal.push(`${axel} har en beställd omkörning (partial_rerun) på ${fil} som väntar på dom`)
+    }
+  }
+  return skal
+}
+
+/** Den GÄLLANDE dokumentfilen för en axel vid n — det som ska läsas för
+ *  stopputfallskontrollen och räknas som posten prisbärande underlag. Detta
+ *  är en MEDVETEN PRECISERING utöver briefen, som bara sa "läs JSON-filen ur
+ *  katalogen" utan att ta ställning till VILKEN fil när ett viktningsutslag
+ *  pekar om den gällande handlingen.
+ *
+ *  Om ett viktningsutslag har lyft spärren för denna n, ÄR dess `galler_fil`
+ *  det gällande dokumentet — inte den vanliga `<typ>-pricing-v<n>.json`. Det
+ *  är hela poängen med fältet: granskningens repro visade att utan den här
+ *  halvan pekar domen på en fil ingenting läser. Konkret kedja som annars
+ *  prissätter en post en människa dömt ska eskaleras: klassfilen v2 säger
+ *  MEDIUM, dess run2 säger ESKALERA, granskaren dömer (via `utslag --typ
+ *  viktning --galler-fil classification-pricing-v2-run2.json`) att run2
+ *  gäller. Om priced-kontrollen då fortsätter läsa v2.json i stället för
+ *  run2.json ser den bara MEDIUM och släpper igenom en post som borde
+ *  eskaleras. Så länge gällande dokument alltid är galler_fil när ett lyft
+ *  finns, läser båda halvorna (stopputfall OCH prisunderlag) samma fil som
+ *  domen faktiskt pekar på. */
+function gallandeDokumentFil(state, typ, n) {
+  return liftingUtslag(state, typ, n)?.galler_fil ?? `${typ}-pricing-v${n}.json`
+}
+
+/** Läser en gällande pricing-fil (classification eller score) ur katalogen
+ *  och returnerar den PARSADE, validerade datan. Arkivet PÅSTÅR via sin
+ *  runs-rad (eller ett viktningsutslags `galler_fil`) att filen finns och är
+ *  gällande — saknas den, är den trasig JSON, eller är den parsningsbar men
+ *  inte ett objekt (array, tal, sträng, null), är det ett integritetsfel i
+ *  arkivet, ALDRIG en grön lampa för priced. Samma princip som
+ *  `readStateOrThrow` redan tillämpar på state.json (se dess kommentar) —
+ *  prisfilsläsaren hade inte ärvt den kontrollen, så en fil som PARSAR men
+ *  saknar utfall (`{}`, `null`, `[]`) gav `?.classification?.utfall` /
+ *  `?.outcome` lika med `undefined`, som inte finns i någon stopplista, och
+ *  grinden rapporterade att inget blockerar. Kastar ArkivFel; anroparen
+ *  (set-status) fångar det och avslutar med exit 2, skilt från den vanliga
+ *  spärr-vägran (exit 1). */
+function readPricingFileOrThrow(fil) {
+  const p = path.join(katalog, fil)
+  let raw
+  try {
+    raw = readFileSync(p, 'utf8')
+  } catch (e) {
+    throw new ArkivFel(`gällande fil ${p} saknas eller går inte att läsa: ${e.message}`)
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch (e) {
+    throw new ArkivFel(`${p} är trasig JSON: ${e.message}`)
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    const fick = parsed === null ? 'null' : Array.isArray(parsed) ? 'array' : typeof parsed
+    throw new ArkivFel(`${p} är inte ett objekt (fick ${fick})`)
+  }
+  return parsed
+}
+
+/** Parfullständighet: ett pris är klass GÅNGER poäng, så `priced` kräver att
+ *  BÅDA axlarna faktiskt bildar ett par, inte bara att ingenting annat råkar
+ *  spärra. `sparrSkal` (ovan) blockerar en ENSKILD axel vars SENASTE rad bär
+ *  `double_run: "olika"` eller en oavgjord `partial_rerun` — den itererar
+ *  axlarna OBEROENDE av varandra och hoppar helt över en axel vars `maxN`
+ *  är 0, så den ser aldrig att den ANDRA axeln saknas eller pekar på ett
+ *  annat varv. Två granskningsrepron visade detta konkret: en katalog med
+ *  BARA klassaxeln arkiverad (poängaxeln aldrig körd, kanske avvisad av
+ *  contract-check och aldrig omkörd) gick till `priced` med exit 0 — och en
+ *  katalog med klass på v2 och poäng på v1 (två varv som aldrig arkiverades
+ *  TILLSAMMANS, ingen ATOMÄR arkivering skedde) gick också igenom. Ingen av
+ *  scenarierna rör en ENSKILD rad på fel sätt, så `sparrSkal` har inget att
+ *  hänga upp sig på.
+ *
+ *  Legitim ojämnhet finns: en riktad omkörning (döm, "Beställ omkörning",
+ *  Task 8) bumpar AVSIKTLIGT bara den oeniga axelns N och lämnar den stående
+ *  axeln kvar på sitt gamla varv (se `bedöm` steg 8 och runs-kontraktet i
+ *  SKILL.md för `partial_rerun`/`pairs_with`). Det är INTE samma sak som de
+ *  två repronas trasiga tillstånd: raden som bär det högre N:et bär då
+ *  `partial_rerun: true` — själva avsikten att vara ojämn står skriven på
+ *  raden. Utan den flaggan, eller utan att någon rad alls finns för en axel,
+ *  finns ingen förklaring, och paret är helt enkelt inte komplett.
+ *  `sparrSkal` blockerar separat en OAVGJORD riktad omkörning (raden väntar
+ *  på granskarens dom) — den här kontrollen är inte en ersättning för den,
+ *  bara den KOMPLETTERANDE strukturella kontrollen att paret existerar och,
+ *  om det avviker, att avvikelsen är just en sådan förklarad omkörning. */
+function pairIncomplete(state) {
+  const runs = state.runs ?? []
+  const nClass = maxN(runs, 'classification')
+  const nScore = maxN(runs, 'score')
+  // ADR-0098: klassaxeln är borttagen — nya arkiv har bara poängaxeln och
+  // prövas aldrig mot par-regeln. Regeln finns kvar ENBART för äldre arkiv
+  // som bär en klassaxel: där är ett halvt eller omatchat par fortfarande
+  // precis lika fel som när båda axlarna skrevs.
+  if (nClass === 0) return null
+  if (nScore === 0) {
+    return 'paret är inte komplett — poängaxeln har ingen gällande fil'
+  }
+  if (nClass === nScore) return null
+  // Den axel som ligger FÖRE (lägre N) är den stående axeln i en riktad
+  // omkörning — det är den HÖGRE axelns senaste rad som bär förklaringen,
+  // om någon finns.
+  const [hogreTyp, hogreN] = nClass > nScore ? ['classification', nClass] : ['score', nScore]
+  const fil = `${hogreTyp}-pricing-v${hogreN}.json`
+  const rad = [...runs].reverse().find((r) => r.file === fil)
+  if (rad?.partial_rerun === true) return null
+  return (
+    `paret är inte komplett — klassaxelns gällande varv (v${nClass}) och ` +
+    `poängaxelns (v${nScore}) skiljer sig utan en förklarad enaxlig omkörning ` +
+    `(${fil} saknar partial_rerun: true)`
+  )
+}
+
+/** Skäl som vägrar `set-status priced`: sparr-spärren, parfullständigheten,
+ *  experimentmarkören, och gällande klass-/poängfils utfall om det är ett
+ *  stopputfall. Kastar ArkivFel vidare (från readPricingFileOrThrow, eller
+ *  när utfallsfältet inte är ett KÄNT värde ur protokollets enum — se
+ *  CLASS_UTFALL/SCORE_OUTCOMES i lib.mjs) på ett trasigt arkiv — set-status
+ *  översätter det till exit 2, aldrig "inget blockerar".
+ *
+ *  Enum-kontrollen är en ALLOW-lista, inte bara "är det en sträng". CLASS_STOP/
+ *  SCORE_STOP nedan är DENY-listor (stopputfall) — en deny-lista släpper
+ *  igenom allt den inte känner igen, så en felstavning ("OFERT"), en tom
+ *  sträng, eller fel skiftläge ("eskalera") hade passerat grinden OGRANSKAT
+ *  eftersom inget av dem finns i deny-listan. Allow-listan failar STÄNGT i
+ *  stället: allt utanför de kända värdena är ett integritetsfel, prövat
+ *  FÖRE deny-listan någonsin tillfrågas. */
+function pricedBlockers(state) {
+  const skal = [...sparrSkal(state)]
+  const parBrist = pairIncomplete(state)
+  if (parBrist) skal.push(parBrist)
+  if (state.experiment === true) {
+    skal.push('experimentvariant blir aldrig priced')
+  }
+  const runs = state.runs ?? []
+  const nClass = maxN(runs, 'classification')
+  if (nClass > 0) {
+    const fil = gallandeDokumentFil(state, 'classification', nClass)
+    const data = readPricingFileOrThrow(fil)
+    const utfall = data.classification?.utfall
+    if (!CLASS_UTFALL.includes(utfall)) {
+      throw new ArkivFel(
+        `${path.join(katalog, fil)}: classification.utfall: ogiltigt värde "${utfall}" ` +
+          `(giltiga: ${CLASS_UTFALL.join(', ')})`,
+      )
+    }
+    if (CLASS_STOP.includes(utfall)) skal.push(`${fil} har stopputfallet ${utfall}`)
+  }
+  const nScore = maxN(runs, 'score')
+  if (nScore > 0) {
+    const fil = gallandeDokumentFil(state, 'score', nScore)
+    const data = readPricingFileOrThrow(fil)
+    const outcome = data.outcome
+    if (!SCORE_OUTCOMES.includes(outcome)) {
+      throw new ArkivFel(
+        `${path.join(katalog, fil)}: outcome: ogiltigt värde "${outcome}" ` +
+          `(giltiga: ${SCORE_OUTCOMES.join(', ')})`,
+      )
+    }
+    if (SCORE_STOP.includes(outcome)) skal.push(`${fil} har stopputfallet ${outcome}`)
+  }
+  return skal
+}