@haus-tech/haus-workflow 5.0.1 → 5.2.0

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

@@ -8,17 +8,32 @@
  *
  * 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).
+ * (läs-enbart svepvy över kalibreringsnotiser). Del 3 (plan requestmotor-14001,
+ * Task 6): stopp (stopputfall utan scorer, ur spec.md eller impact.md), respec
+ * (nollställning inför en ny spec) och bluf (tabellvy över en katalog och dess
+ * delar), samt effort ur agentdefinitionen i add-run och ett state.json-skelett
+ * från ny-korning. Del 4 (plan utvardera-parallellt-svep, Task 1): experiment,
+ * den enda skrivaren av experiment.json på experimentytan, låst och atomisk,
+ * så samtidiga svep-processer aldrig tappar varandras rader (#493). Del 5
+ * (#530): nasta-steg, läs-enbart tabell över var posten står, vad en människa
+ * väntas göra och vilket /request-kommando som kör vidare, ur SKILL.md:s
+ * egna grindar (regeltabellen står ovanför `nastaStegFor`).
  *
  * 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 ny-korning <modellkatalog> [--request-id G]
+ *   node archive.mjs ny-del <körningskatalog> --typ bundle|split --part N --of M --request-id G
  *   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 stopp <katalog> --utfall KONCEPT|DIAGNOS|TILLBAKA_TILL_SPEC|ESKALERA --kalla spec.md|impact.md|granskarblock.md [--orsak <text>]
+ *   node archive.mjs respec <katalog>
+ *   node archive.mjs bluf <katalog>
+ *   node archive.mjs nasta-steg <katalog>
  *   node archive.mjs kalibrering <arkivrot>
+ *   node archive.mjs experiment <experimentkatalog> [--satt K=V]... [--variant M]... [--korning M/kN --status S [--orsak T] [--pid N]]
  * Exit 0 = ok, 1 = spärrad (sparr/set-status priced), 2 = användnings-/tillståndsfel.
  */
 import {
@@ -38,8 +53,13 @@ import path from 'node:path'
 import { createHash } from 'node:crypto'
 import {
   markerStrippedSha256,
+  stripHausMarker,
   claudeDir,
   canonicalModel,
+  kandidatIn,
+  avvikelseEtikett,
+  prisavgorandeVal,
+  findUpward,
   CLASS_UTFALL,
   SCORE_OUTCOMES,
 } from './lib.mjs'
@@ -48,7 +68,7 @@ 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]',
+    'användning: archive.mjs <add-run|next-n|ny-korning|ny-del|proveniens|sparr|utslag|set-status|stopp|respec|bluf|nasta-steg|kalibrering|experiment> <katalog> [flaggor]',
   )
   process.exit(2)
 }
@@ -81,6 +101,35 @@ const requireFlag = (name) => {
 }
 const has = (name) => rest.includes(`--${name}`)
 
+/** Fail-closed flaggkontroll, samma princip som add-run och next-n tillämpar
+ *  inline: varje token i `rest` måste höra till en KÄND flagga, annars är det
+ *  ett fel (exit 2), aldrig ett tyst struntvärde. Värdeflaggor konsumerar
+ *  nästa token, booleska flaggor bara sig själva. */
+const avvisaOkandaFlaggor = (kommando, vardeflaggor, boolflaggor = []) => {
+  const konsumerat = new Set()
+  rest.forEach((v, i) => {
+    if (!v.startsWith('--')) return
+    const namn = v.slice(2)
+    if (vardeflaggor.includes(namn)) {
+      konsumerat.add(i)
+      konsumerat.add(i + 1)
+    } else if (boolflaggor.includes(namn)) {
+      konsumerat.add(i)
+    }
+  })
+  const ovantat = rest.filter((_, i) => !konsumerat.has(i))
+  if (ovantat.length > 0) {
+    const giltiga = [...vardeflaggor, ...boolflaggor].map((n) => `--${n}`)
+    console.error(
+      `${kommando}: okänd eller ej konsumerad flagga/argument (${ovantat.join(' ')}), ` +
+        (giltiga.length === 0
+          ? 'kommandot tar inga flaggor'
+          : `giltiga flaggor: ${giltiga.join(', ')}`),
+    )
+    process.exit(2)
+  }
+}
+
 /** 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
@@ -158,6 +207,16 @@ const readStateOrThrow = (d = katalog) => {
   }
   assertRowArrayField(parsed, 'runs', d)
   assertRowArrayField(parsed, 'granskarutslag', d)
+  // `stopp` är null, saknat (äldre arkiv) eller ett objekt { utfall, kalla,
+  // date }. Allt annat är trasigt: pricedBlockers och bluf läser fältet, och
+  // en sträng där hade tyst lästs som "inget stopp".
+  if (
+    parsed.stopp !== undefined &&
+    parsed.stopp !== null &&
+    (typeof parsed.stopp !== 'object' || Array.isArray(parsed.stopp))
+  ) {
+    throw new ArkivFel(`${statePath(d)} har ett stopp-fält som varken är null eller ett objekt`)
+  }
   return parsed
 }
 
@@ -180,31 +239,73 @@ const loadStateOrExit = () => {
  *  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 writeStateOrThrow = (s, d = katalog) => writeJsonAtomiskOrThrow(s, d, 'state.json')
+
+/** Samma rename-dans för vilken JSON-fil som helst i en katalog: state.json
+ *  och experiment.json delar en enda skrivväg i stället för två kopior som
+ *  kan glida isär (filnamnet är den enda skillnaden). */
+const writeJsonAtomiskOrThrow = (s, d, fil) => {
+  const mal = path.join(d, fil)
   const rand = Math.random().toString(36).slice(2, 8)
-  const tmp = path.join(d, `.state.json.tmp-${process.pid}-${rand}`)
+  const tmp = path.join(d, `.${fil}.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.
+    // befintliga filen (t.ex. 0600) med standardläget. Bevara det gamla
+    // läget om filen redan fanns; en ny fil har inget läge att bevara.
     try {
-      chmodSync(tmp, statSync(statePath(d)).mode)
+      chmodSync(tmp, statSync(mal).mode)
     } catch {
-      // ingen befintlig state.json (ny post) — inget läge att bevara.
+      // ingen befintlig fil (ny post), inget läge att bevara.
     }
-    renameSync(tmp, statePath(d))
+    renameSync(tmp, mal)
   } 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}`)
+    throw new ArkivFel(`kunde inte skriva ${mal}: ${e.message}`)
   }
 }
 
+/** Läser experiment.json i katalogen d. Saknad fil är GILTIG (ny post, tom
+ *  behållare), trasig JSON eller en icke-objekt-fil är ett arkivfel. De två
+ *  fält kommandot skriver strukturerat valideras på samma sätt som runs i
+ *  state.json: `varianter` måste vara en array av strängar och `korningar`
+ *  ett objekt, annars sprids skräp tyst vid nästa skrivning. Alla andra
+ *  fält (även äldre `baselinemodell`/`kandidatmodell`) lämnas orörda. */
+const readExperimentOrThrow = (d) => {
+  const fil = path.join(d, 'experiment.json')
+  if (!existsSync(fil)) return { state: {}, fanns: false }
+  let parsed
+  try {
+    parsed = JSON.parse(readFileSync(fil, 'utf8'))
+  } catch (e) {
+    throw new ArkivFel(`${fil} ä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(`${fil} är inte ett objekt (fick ${fick})`)
+  }
+  if (
+    parsed.varianter !== undefined &&
+    (!Array.isArray(parsed.varianter) || parsed.varianter.some((v) => typeof v !== 'string'))
+  ) {
+    throw new ArkivFel(`${fil} har ett varianter-fält som inte är en array av strängar`)
+  }
+  if (
+    parsed.korningar !== undefined &&
+    (parsed.korningar === null ||
+      typeof parsed.korningar !== 'object' ||
+      Array.isArray(parsed.korningar))
+  ) {
+    throw new ArkivFel(`${fil} har ett korningar-fält som inte är ett objekt`)
+  }
+  return { state: parsed, fanns: true }
+}
+
 /** 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. */
@@ -461,6 +562,16 @@ const SCORE_STOP = [
   'ESKALERA',
 ]
 
+/** `stopp`-kommandots utfall och källor. Kandidatmarkören i spec.md
+ *  (KONCEPT/DIAGNOS, ADR-0105), motsägelse-etiketten i impact.md
+ *  (TILLBAKA_TILL_SPEC, ADR-0106) och raden Prisavgörande öppet val i
+ *  granskarblock.md (TILLBAKA_TILL_SPEC eller ESKALERA, ADR-0118) är de tre
+ *  källor som kan bära ett stopp UTAN scorer. DELA_UPP, OVER_SKALAN och
+ *  INPUT_SAKNAS är scorerns utfall och når arkivet via prisfilen, aldrig via
+ *  stopp; ESKALERA når arkivet på båda vägarna. */
+const STOPP_UTFALL = ['KONCEPT', 'DIAGNOS', 'TILLBAKA_TILL_SPEC', 'ESKALERA']
+const STOPP_KALLOR = ['spec.md', 'impact.md', 'granskarblock.md']
+
 /** 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. */
@@ -488,6 +599,13 @@ const PROVENIENS_REFERENSER = [
  *  gett en tyst, obegriplig status i stället för ett fel. */
 const STATUSAR = ['spec_draft', 'spec_synced', 'assessed', 'priced', 'guard_run']
 
+/** Körningsstatus i experiment.json, exakt de literaler SKILL.md:s
+ *  återupptagningsregel och svep.mjs läser. */
+const EXPERIMENT_STATUSAR = ['klar', 'ofärdig', 'stopp', 'väntar på dom']
+/** En körningsnyckel är <modell>/k<N>, samma form som katalogen under
+ *  experimentkatalogen. */
+const KORNING_NYCKEL_RE = /^[^/]+\/k\d+$/
+
 /** 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
@@ -507,6 +625,53 @@ 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)))
 
+/** Första rubrikraden i ett specdokument, utan markdown-tecken; null om ingen. */
+const forstaRubrik = (text) => {
+  const rad = String(text)
+    .split('\n')
+    .map((l) => l.trim())
+    .find((l) => /^#{1,6}\s+\S/.test(l) || /^\*\*[^*]+\*\*\s*$/.test(l))
+  return rad
+    ? rad
+        .replace(/^#{1,6}\s+/, '')
+        .replace(/^\*\*|\*\*$/g, '')
+        .trim()
+    : null
+}
+
+/** Kebab-slug: gemener, åäö till aao, allt annat än [a-z0-9] blir bindestreck. */
+const slugAv = (titel) =>
+  titel
+    .toLowerCase()
+    .replace(/å/g, 'a')
+    .replace(/ä/g, 'a')
+    .replace(/ö/g, 'o')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+
+/** Skelettet ny-korning och ny-del skriver, delat på ett ställe: samma form
+ *  som SKILL.md:s state.json plus `experiment: true` (aldrig priced) och
+ *  `stopp: null`. `bundle`/`split` överstyrs bara när anroparen ger dem, så
+ *  ny-korning (ingen del) och ny-del (precis en av dem) delar exakt samma
+ *  funktion i stället för två skrivvägar som kan glida isär. */
+const skelett = (requestId, { bundle, split } = {}) => ({
+  experiment: true,
+  request_id: requestId,
+  slug: null,
+  former_slug: null,
+  title: null,
+  status: 'spec_draft',
+  bundle: bundle ?? { parent_slug: null, part: null, of: null },
+  split: split ?? { parent: null, part: null, of: null },
+  approval: null,
+  granskarutslag: [],
+  note: null,
+  stopp: null,
+  respec_varv: 0,
+  coverage_post: null,
+  runs: [],
+})
+
 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
@@ -534,30 +699,17 @@ if (cmd === 'add-run') {
     '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)
-  }
+  avvisaOkandaFlaggor('add-run', ADD_RUN_VARDEFLAGGOR, ADD_RUN_BOOLFLAGGOR)
 
   const file = flag('file')
   const skill = flag('skill')
   const agent = flag('agent')
-  const model = flag('model')
+  // --model förblir obligatorisk (plan requestmotor-14001, align: modellfallback
+  // struken; under utvärdera körs agenterna med override, så definitionens
+  // modell är per konstruktion inte den som kördes). Värdet kanoniseras:
+  // ett kontextsuffix som `[1m]` är samma modell (ADR-0099).
+  const modelRaw = flag('model')
+  const model = modelRaw === null ? null : canonicalModel(modelRaw)
   if (!file || !skill || !agent || !model) {
     console.error('add-run kräver --file, --skill, --agent, --model')
     process.exit(2)
@@ -580,7 +732,10 @@ if (cmd === 'add-run') {
     }
     referens[kv.slice(0, eq)] = kv.slice(eq + 1)
   }
-  const effort = flag('effort')
+  // Effort ÄR agentdefinitionens (till skillnad från modellen, se ovan): en
+  // utelämnad --effort läses ur <claudeDir>/agents/<agent>.md. Explicit flagga
+  // vinner alltid.
+  const effort = flag('effort') ?? effortFranAgent(agent)
   const note = flag('note')
   const doubleRun = flag('double-run')
   // Samma vitlista som lässidan (`sparrSkal`, `DOUBLE_RUN_VALUES`) delar,
@@ -651,9 +806,37 @@ if (cmd === 'add-run') {
         // hoppa över den, arkivera aldrig en påhittad hash.
       }
     }
-    state.runs = [...(state.runs ?? []), row]
-    writeStateOrThrow(state)
-    rowCount = state.runs.length
+    // #497: en ny spec.md/impact.md ersätter den förra läggningen av samma fil.
+    // Den föregående raden pekas ut, i stället för att två likadana rader
+    // står olänkade och läsaren måste gissa vilken som är på disk. Exakt
+    // filnamn med flit, inte SPEC_RE/IMPACT_RE: de mönstren matchar även
+    // t.ex. spec-avvisad-v1.md, som aldrig ska plockas in i supersede-kedjan.
+    const ersattbar = file === 'spec.md' || file === 'impact.md'
+    const runs = (state.runs ?? []).map((r) =>
+      ersattbar && r.file === file && (r.superseded_by ?? null) === null
+        ? { ...r, superseded_by: file }
+        : r,
+    )
+    // #495: titeln följer det dokument som faktiskt ligger på disk.
+    let titelFalt = {}
+    if (file === 'spec.md' && existsSync(path.join(katalog, 'spec.md'))) {
+      const rubrik = forstaRubrik(readFileSync(path.join(katalog, 'spec.md'), 'utf8'))
+      if (rubrik) titelFalt = { title: rubrik, slug: slugAv(rubrik) }
+    }
+    // Täckningspost (ADR-0119, #508): senaste pricing-filen som bär fältet
+    // vinner, precis som titeln följer spec.md på disk. En pricing-fil som
+    // (ännu) inte finns är inte add-runs jobb att fälla, den stämplas ofta
+    // innan agenten skrivit filen. Finns den redan är trasig JSON eller ett
+    // icke-objekt ett arkivfel som andra anropare i den här filen, fångas
+    // inte här: readPricingFileOrThrow kastar oskyddad.
+    if (PRICING_RE.test(file) && existsSync(path.join(katalog, file))) {
+      const data = readPricingFileOrThrow(file, katalog)
+      if (data.coverage_post !== null && typeof data.coverage_post === 'object')
+        titelFalt = { ...titelFalt, coverage_post: data.coverage_post }
+    }
+    const nyState = { ...state, ...titelFalt, runs: [...runs, row] }
+    writeStateOrThrow(nyState)
+    rowCount = nyState.runs.length
   } catch (e) {
     releaseLock(lockPath)
     if (e instanceof ArkivFel) {
@@ -957,6 +1140,8 @@ if (cmd === 'add-run') {
   // 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.
+  avvisaOkandaFlaggor('ny-korning', ['request-id'])
+  const requestId = flag('request-id')
   try {
     mkdirSync(katalog, { recursive: true })
   } catch (e) {
@@ -971,16 +1156,196 @@ if (cmd === 'add-run') {
       // 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)
     }
+    // Skelettet skrivs av kommandot, inte av orkestratorn: IPC 14001 visade
+    // körningar helt utan state.json på körningsnivå, så proveniens hade
+    // ingenting att stämpla.
+    try {
+      writeStateOrThrow(skelett(requestId), p)
+    } catch (e) {
+      if (!(e instanceof ArkivFel)) throw e
+      // Katalogen finns redan när skrivningen faller, och sökvägen får INTE
+      // skrivas på stdout: anroparen skulle läsa den som en färdig körning.
+      console.error(`${e.message}; katalogen ${p} är skapad men saknar state.json`)
+      process.exit(2)
+    }
+    console.log(p)
+    process.exit(0)
   }
   console.error(`fler än ${MAX_KORNINGAR} körningar i ${katalog}, något är fel`)
   process.exit(2)
+} else if (cmd === 'ny-del') {
+  // katalog är körningskatalogen (k<N>) eller en buntdel (DELA_UPP inuti en
+  // del ger del-N/del-M). Skelettet skrivs av kommandot, aldrig av den inre
+  // processen: samma skäl som ny-korning (ADR-0107 beslut 4).
+  avvisaOkandaFlaggor('ny-del', ['typ', 'part', 'of', 'request-id'])
+  const typ = requireFlag('typ')
+  const part = Number(requireFlag('part'))
+  const of = Number(requireFlag('of'))
+  const requestId = requireFlag('request-id')
+  if (!['bundle', 'split'].includes(typ)) {
+    console.error(`--typ måste vara bundle eller split (fick "${typ}")`)
+    process.exit(2)
+  }
+  if (!Number.isInteger(part) || !Number.isInteger(of) || part < 1 || of < 1 || part > of) {
+    console.error(`--part och --of måste vara heltal >= 1 med part <= of (fick ${part}/${of})`)
+    process.exit(2)
+  }
+  const p = path.join(katalog, `del-${part}`)
+  try {
+    mkdirSync(p)
+  } catch (e) {
+    console.error(e.code === 'EEXIST' ? `${p} finns redan` : `kunde inte skapa ${p}: ${e.message}`)
+    process.exit(2)
+  }
+  const ref = { part, of }
+  const st = skelett(
+    requestId,
+    typ === 'bundle'
+      ? { bundle: { parent_slug: requestId, ...ref } }
+      : { split: { parent: requestId, ...ref } },
+  )
+  try {
+    writeStateOrThrow(st, p)
+  } catch (e) {
+    if (!(e instanceof ArkivFel)) throw e
+    console.error(`${e.message}; katalogen ${p} är skapad men saknar state.json`)
+    process.exit(2)
+  }
+  console.log(p)
+  process.exit(0)
+} else if (cmd === 'experiment') {
+  // katalog är HÄR experimentkatalogen (experiments/<slug>). experiment.json
+  // är den enda filen på experimentytan som flera samtidiga processer
+  // skriver (#493: sonnet/k4 försvann i en läs-modifiera-skriv utan lås), så
+  // den enda skrivaren är det här kommandot, under samma lås som state.json-
+  // kommandona. acquireLock låser i `katalog`, alltså i experimentkatalogen.
+  avvisaOkandaFlaggor('experiment', ['satt', 'variant', 'korning', 'status', 'orsak', 'pid'])
+  const sattPar = flags('satt').map(tolkaSatt)
+  const nyaVarianter = flags('variant')
+  const korningsflaggor = flags('korning')
+  const status = flag('status')
+  const orsak = flag('orsak')
+  // #516: startraden (`ofärdig`, "startad, inte avslutad") bär startarens pid
+  // medan körningen pågår, så ett andra svep kan skilja en körning som lever
+  // från en som dog. Slutstatusen skrivs utan --pid och ersätter raden helt,
+  // pid:n försvinner alltså av sig själv när processen är klar.
+  const pidText = flag('pid')
+  if (korningsflaggor.length > 1) {
+    console.error('experiment: högst en --korning per anrop')
+    process.exit(2)
+  }
+  const korning = korningsflaggor[0] ?? null
+  if (korning === null && (status !== null || orsak !== null || pidText !== null)) {
+    console.error('experiment: --status, --orsak och --pid kräver --korning')
+    process.exit(2)
+  }
+  if (pidText !== null && !/^\d+$/.test(pidText)) {
+    console.error(`experiment: --pid måste vara ett heltal (fick "${pidText}")`)
+    process.exit(2)
+  }
+  const pid = pidText === null ? null : Number(pidText)
+  if (korning !== null) {
+    if (!KORNING_NYCKEL_RE.test(korning)) {
+      console.error(`experiment: --korning ska ha formen <modell>/k<N>, fick "${korning}"`)
+      process.exit(2)
+    }
+    if (status === null) {
+      console.error('experiment: --korning kräver --status')
+      process.exit(2)
+    }
+    if (!EXPERIMENT_STATUSAR.includes(status)) {
+      console.error(`okänd status: ${status} (giltiga: ${EXPERIMENT_STATUSAR.join(', ')})`)
+      process.exit(2)
+    }
+    // Katalogen måste finnas: en statusrad för en körning som inte finns
+    // är ett stavfel i anroparen, inte en körning.
+    const korningsdir = path.join(katalog, korning)
+    let finns = false
+    try {
+      finns = statSync(korningsdir).isDirectory()
+    } catch {
+      // saknas
+    }
+    if (!finns) {
+      console.error(`experiment: körningskatalogen ${korningsdir} finns inte`)
+      process.exit(2)
+    }
+  }
+  // Katalogen skapas om den saknas, precis som ny-korning gör med sin: första
+  // steget i ett svep ska inte kräva ett förberedande mkdir. Låset ligger i
+  // katalogen, så den måste finnas innan acquireLock.
+  try {
+    mkdirSync(katalog, { recursive: true })
+  } catch (e) {
+    console.error(`kunde inte skapa experimentkatalogen ${katalog}: ${e.message}`)
+    process.exit(2)
+  }
+  const lockPath = acquireLock()
+  let andringar = 0
+  let fannsFil = false
+  try {
+    const { state, fanns } = readExperimentOrThrow(katalog)
+    fannsFil = fanns
+    let nasta = { ...state }
+    // --satt är append-only som proveniens: ett fält skrivs en gång, samma
+    // värde igen är en no-op, ett annat värde är ett fel. Alla fält prövas
+    // före skrivningen, så ett vägrat anrop lämnar ingenting efter sig.
+    for (const [nyckel, varde] of sattPar) {
+      if (nasta[nyckel] === undefined) {
+        nasta = { ...nasta, [nyckel]: varde }
+        andringar++
+      } else if (nasta[nyckel] !== varde) {
+        throw new ArkivFel(
+          `experiment: fältet ${nyckel} har redan värdet ${JSON.stringify(nasta[nyckel])}, ` +
+            `begärt ${JSON.stringify(varde)}; ett fält skrivs bara en gång`,
+        )
+      }
+    }
+    // UNION med bevarad ordning: befintliga först, invokationens nya efter.
+    // En headless-process med en enmodellslista rör alltså aldrig de andra.
+    const befintliga = nasta.varianter ?? []
+    const tillagda = nyaVarianter.filter(
+      (v, i, alla) => !befintliga.includes(v) && alla.indexOf(v) === i,
+    )
+    if (tillagda.length > 0) {
+      nasta = { ...nasta, varianter: [...befintliga, ...tillagda] }
+      andringar += tillagda.length
+    }
+    // Bara den egna raden skrivs; andra körningars rader kopieras orörda.
+    if (korning !== null) {
+      const rad = {
+        status,
+        ...(orsak === null ? {} : { orsak }),
+        ...(pid === null ? {} : { pid }),
+      }
+      const befintlig = nasta.korningar?.[korning]
+      if (JSON.stringify(befintlig) !== JSON.stringify(rad)) {
+        nasta = { ...nasta, korningar: { ...(nasta.korningar ?? {}), [korning]: rad } }
+        andringar++
+      }
+    }
+    if (andringar > 0 || !fanns) writeJsonAtomiskOrThrow(nasta, katalog, 'experiment.json')
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  // En nyskapad fil är en ändring även utan begärda fält, därför räknas
+  // "oförändrad" bara när filen redan fanns.
+  console.log(
+    andringar === 0 && fannsFil
+      ? 'OK: experiment oförändrad'
+      : `OK: experiment (${andringar} ändringar)`,
+  )
 } 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
@@ -1039,29 +1404,27 @@ if (cmd === 'add-run') {
   // 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}`)
+  // Filen ligger på körningsnivå medan stämplingen ibland görs per del-N
+  // (plan requestmotor-14001), så den söks uppåt från katalogen, aldrig
+  // utanför experimentytan och högst tre nivåer.
+  const korningFil = findUpward(katalog, 'korning.json')
+  if (korningFil !== null) {
+    try {
+      const korning = JSON.parse(readFileSync(korningFil, 'utf8'))
+      const nycklar = Object.keys(korning.modelUsage ?? {})
+      if (nycklar.length > 0)
+        stampel.fakturerade_modeller = [...new Set(nycklar.map(canonicalModel))].sort()
+    } catch (e) {
+      console.error(`kunde inte läsa ${korningFil} 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()
+  // låter delkolumnen ärva förälderns värden vid läsning. Rekursivt: ett
+  // DELA_UPP inuti en buntdel ger del-N/del-M (align F).
+  const delar = delKataloger(katalog)
 
   const lockPath = acquireLock()
   try {
@@ -1076,8 +1439,19 @@ if (cmd === 'add-run') {
         attSkriva.push([d, state])
         continue
       }
-      const skiljer = Object.keys(stampel).filter(
-        (k) => (befintlig === null ? undefined : befintlig[k]) !== stampel[k],
+      // Djup jämförelse per fält: `fakturerade_modeller` är en array, och en
+      // referensjämförelse hade fått varje omanrop att "skilja sig" i just
+      // det fältet.
+      // Unionen av nycklar: ett fält som fanns i den lagrade stämpeln men
+      // saknas i den nya (korning.json hittas inte längre) är också drift.
+      const nycklar = new Set([
+        ...Object.keys(stampel),
+        ...Object.keys(befintlig === null ? {} : befintlig),
+      ])
+      const skiljer = [...nycklar].filter(
+        (k) =>
+          JSON.stringify(befintlig === null ? undefined : befintlig[k]) !==
+          JSON.stringify(stampel[k]),
       )
       if (skiljer.length > 0) {
         throw new ArkivFel(
@@ -1100,13 +1474,493 @@ if (cmd === 'add-run') {
     }
     throw e
   }
+} else if (cmd === 'stopp') {
+  // Stopputfall UTAN scorer (ADR-0105/0106/0118): en kandidatspec routar direkt
+  // till KONCEPT/DIAGNOS, en analys med motsägelse direkt till
+  // TILLBAKA_TILL_SPEC, och ett prisavgörande öppet val i granskarblock.md
+  // direkt till TILLBAKA_TILL_SPEC eller ESKALERA. Kommandot litar aldrig på
+  // anroparens påstående: källan måste bära det.
+  avvisaOkandaFlaggor('stopp', ['utfall', 'kalla', 'orsak'])
+  const utfall = requireFlag('utfall')
+  const kalla = requireFlag('kalla')
+  const orsak = flag('orsak')
+  if (!STOPP_UTFALL.includes(utfall)) {
+    console.error(`okänt --utfall: ${utfall} (giltiga: ${STOPP_UTFALL.join(', ')})`)
+    process.exit(2)
+  }
+  if (!STOPP_KALLOR.includes(kalla)) {
+    console.error(`okänd --kalla: ${kalla} (giltiga: ${STOPP_KALLOR.join(', ')})`)
+    process.exit(2)
+  }
+  const kallaPath = path.join(katalog, kalla)
+  let text
+  try {
+    text = readFileSync(kallaPath, 'utf8')
+  } catch (e) {
+    console.error(`kunde inte läsa källan ${kallaPath}: ${e.message}`)
+    process.exit(2)
+  }
+  if (kalla === 'spec.md') {
+    const kandidat = kandidatIn(text)
+    if (kandidat === null) {
+      console.error(
+        `${kallaPath} bär ingen kandidatmarkör (hel rubrikrad Koncept-kandidat/Diagnos-kandidat), ` +
+          `kan inte stoppas som ${utfall}`,
+      )
+      process.exit(2)
+    }
+    if (kandidat.utfall !== utfall) {
+      console.error(
+        `${kallaPath} bär markören för ${kandidat.utfall} (rad ${kandidat.line + 1}), inte ${utfall}`,
+      )
+      process.exit(2)
+    }
+  } else if (kalla === 'granskarblock.md') {
+    // ADR-0118: bara ett ja på raden Prisavgörande öppet val är ett stopp.
+    if (prisavgorandeVal(text) === null) {
+      console.error(
+        `${kallaPath} bär inget prisavgörande öppet val (raden "Prisavgörande öppet val: ja: …"), ` +
+          'kan inte stoppas',
+      )
+      process.exit(2)
+    }
+    if (!['TILLBAKA_TILL_SPEC', 'ESKALERA'].includes(utfall)) {
+      console.error(
+        `ett prisavgörande val i ${kalla} stoppar som TILLBAKA_TILL_SPEC eller ESKALERA, inte ${utfall}`,
+      )
+      process.exit(2)
+    }
+    if (utfall === 'ESKALERA' && !orsak) {
+      console.error(
+        'ESKALERA kräver --orsak: en människa ska se varför posten inte gick tillbaka till specen en gång till',
+      )
+      process.exit(2)
+    }
+  } else {
+    const etikett = avvikelseEtikett(text)
+    if (etikett !== 'motsägelse') {
+      console.error(
+        `${kallaPath} bär ${etikett === null ? 'ingen avvikelseetikett' : `etiketten "${etikett}"`} ` +
+          'på raden "Avvikelse mot specen:", bara "motsägelse" är ett stopp',
+      )
+      process.exit(2)
+    }
+    if (utfall !== 'TILLBAKA_TILL_SPEC') {
+      console.error(`en motsägelse i ${kalla} stoppar som TILLBAKA_TILL_SPEC, inte ${utfall}`)
+      process.exit(2)
+    }
+  }
+
+  const lockPath = acquireLock()
+  let skrivet = false
+  try {
+    const state = readStateOrThrow()
+    const befintlig = state.stopp ?? null
+    if (befintlig !== null) {
+      // Write-once på utfall+kalla; datumet och orsaken ingår inte, ett
+      // identiskt omanrop en annan dag (eller med en annan orsakstext) är en
+      // no-op.
+      const begart = { utfall, kalla }
+      const skiljer = Object.keys(begart).filter((k) => befintlig[k] !== begart[k])
+      if (skiljer.length > 0) {
+        throw new ArkivFel(
+          `${statePath()} har redan ett stopp (${befintlig.utfall} ur ${befintlig.kalla}) som skiljer sig ` +
+            `från ${utfall} ur ${kalla} (${skiljer.join(', ')}); arkivet är append-only, kör respec för att nolla`,
+        )
+      }
+    } else {
+      state.stopp = { utfall, kalla, date: today(), ...(orsak ? { orsak } : {}) }
+      // impact.md: posten gick genom bedöm och är analyserad. spec.md och
+      // granskarblock.md: kandidaten/det prisavgörande valet passerade aldrig
+      // bedöms grind, posten stannar i spec_draft som förut.
+      if (kalla === 'impact.md') state.status = 'assessed'
+      writeStateOrThrow(state)
+      skrivet = true
+    }
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log(
+    skrivet ? `OK: stopp ${utfall} ur ${kalla}` : `OK: stopp ${utfall} ur ${kalla} oförändrat`,
+  )
+} else if (cmd === 'respec') {
+  // Speca steg 5 som kommando: en ny spec över befintlig katalog invaliderar
+  // analysen, godkännandet, domarna och stoppet. runs[] rörs aldrig, arkivet
+  // är append-only; den gamla analysen döps om, raderas inte.
+  avvisaOkandaFlaggor('respec', [])
+  const lockPath = acquireLock()
+  let antal = 0
+  try {
+    const state = readStateOrThrow()
+    const impact = path.join(katalog, 'impact.md')
+    if (existsSync(impact)) {
+      const bas = path.join(katalog, `impact-superseded-${today()}`)
+      let mal = `${bas}.md`
+      for (let n = 2; existsSync(mal); n++) mal = `${bas}-${n}.md`
+      try {
+        renameSync(impact, mal)
+      } catch (e) {
+        throw new ArkivFel(`kunde inte döpa om ${impact} till ${mal}: ${e.message}`)
+      }
+      antal++
+    }
+    const nytt = { ...state }
+    if (nytt.status !== 'spec_draft') {
+      nytt.status = 'spec_draft'
+      antal++
+    }
+    if (nytt.approval !== null) {
+      nytt.approval = null
+      antal++
+    }
+    if (!Array.isArray(nytt.granskarutslag) || nytt.granskarutslag.length > 0) {
+      nytt.granskarutslag = []
+      antal++
+    }
+    if (nytt.stopp !== null) {
+      nytt.stopp = null
+      antal++
+    }
+    // Monoton räknare (#505): varje respec-anrop är ett nytt varv oavsett om
+    // övriga fält redan var normaliserade, till skillnad från fälten ovan
+    // finns inget "redan rätt värde" att jämföra mot, så det här villkoret
+    // är alltid sant.
+    nytt.respec_varv = (state.respec_varv ?? 0) + 1
+    antal++
+    if (antal > 0) writeStateOrThrow(nytt)
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log(`OK: respec (${antal} ändringar)`)
+} else if (cmd === 'bluf') {
+  // Läs-enbart tabellvy över katalogen och dess delar. Poängen tas ur
+  // prisfilerna och stoppet ur state.json, aldrig ur `note` eller prosa: den
+  // handskrivna BLUF:en i IPC 14001 felrapporterade.
+  avvisaOkandaFlaggor('bluf', [])
+  const SAKNAS = '–'
+  const cell = (v) => String(v ?? SAKNAS).replace(/\|/g, '\\|')
+  const radFor = (d, post) => {
+    const state = readStateOrThrow(d)
+    const runs = state.runs ?? []
+    const direktaDelar = delKataloger(d).filter((p) => path.dirname(p) === d)
+    let poang = SAKNAS
+    let utfall = SAKNAS
+    let konfidens = SAKNAS
+    let anm = SAKNAS
+    const nScore = maxN(runs, 'score')
+    if (nScore > 0) {
+      const fil = gallandeDokumentFil(state, 'score', nScore)
+      const data = readPricingFileOrThrow(fil, d)
+      poang = data.score ?? SAKNAS
+      utfall = data.outcome ?? SAKNAS
+      konfidens = data.confidence ?? SAKNAS
+      const rad = [...runs].reverse().find((r) => r.file === fil)
+      // En OLIKA som en dom redan lyft (liftingUtslag pekade ut gällande fil
+      // ovan) väntar inte längre på någon; bara en olyft OLIKA får raden.
+      if (rad?.double_run === 'olika' && !liftedByUtslag(state, 'score', nScore)) {
+        anm = 'OLIKA, väntar på dom'
+        const run2 = fil.replace(/\.json$/, '-run2.json')
+        if (existsSync(path.join(d, run2))) {
+          const b = readPricingFileOrThrow(run2, d)
+          poang = `${poang} / ${b.score ?? SAKNAS}`
+        }
+      } else if (rad?.double_run === 'tolerans') {
+        anm = 'tolerans'
+      }
+    } else if (!existsSync(path.join(d, 'spec.md')) && direktaDelar.length > 0) {
+      poang = `bunt (${direktaDelar.length} delar)`
+      utfall = poang
+    } else if (state.stopp == null) {
+      poang = 'ofärdig'
+    }
+    // Täckningspost (ADR-0119, #508): synlig i anm så granskaren ser att en
+    // egen post väntar, utan att leta i pricing-filen. Beräknas separat och
+    // läggs till sist (final-review M6) så att den varken tystas av
+    // OLIKA/tolerans-texten ovan eller av ett stopp nedan.
+    const taeckning = state.coverage_post?.yta ? `täckningspost: ${state.coverage_post.yta}` : null
+    // Stopp trumfar OLIKA och tolerans: posten är stoppad oavsett vad
+    // prisfilen säger, det tidigare anm-innehållet (OLIKA/tolerans) faller
+    // bort. Täckningsposten är inte OLIKA/tolerans-text och överlever detta.
+    if (state.stopp != null) {
+      utfall = state.stopp.utfall
+      anm =
+        state.stopp.kalla === 'spec.md'
+          ? 'kandidat (spec.md)'
+          : state.stopp.kalla === 'granskarblock.md'
+            ? 'prisavgörande val (granskarblock.md)'
+            : 'motsägelse (impact.md)'
+    }
+    if (taeckning) anm = anm === SAKNAS ? taeckning : `${anm}; ${taeckning}`
+    return `| ${[post, poang, utfall, konfidens, anm].map(cell).join(' | ')} |`
+  }
+  const rot = path.resolve(katalog)
+  const rader = ['| post | poäng | utfall | konfidens | anm |', '| --- | --- | --- | --- | --- |']
+  try {
+    rader.push(radFor(rot, path.basename(rot)))
+    for (const d of delKataloger(rot)) rader.push(radFor(d, path.relative(rot, d)))
+  } catch (e) {
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  console.log(rader.join('\n'))
+} else if (cmd === 'nasta-steg') {
+  // #530: läs-enbart tabell över var posten står, vad en människa väntas
+  // göra och vilket /request-kommando som kör vidare. Samma regler som
+  // SKILL.md:s grindar, härledda i `nastaStegFor` nedan, aldrig handskrivna:
+  // en handskriven avslutning tappade exakt den raden i skarp körning.
+  avvisaOkandaFlaggor('nasta-steg', [])
+  const cell = (v) => String(v).replace(/\|/g, '\\|')
+  const radFor = (d, post) => {
+    const state = readStateOrThrow(d)
+    const direktaDelar = delKataloger(d).filter((p) => path.dirname(p) === d)
+    const arBuntRot = !existsSync(path.join(d, 'spec.md')) && direktaDelar.length > 0
+    const { star, vantar, nasta } = nastaStegFor(state, {
+      post,
+      antalDelar: arBuntRot ? direktaDelar.length : 0,
+      scorerUtfall: gallandeScorerUtfall(state, d),
+    })
+    return `| ${[post, star, vantar, nasta].map(cell).join(' | ')} |`
+  }
+  const rot = path.resolve(katalog)
+  const rader = ['| post | står | väntar på | nästa |', '| --- | --- | --- | --- |']
+  try {
+    rader.push(radFor(rot, path.basename(rot)))
+    for (const d of delKataloger(rot)) rader.push(radFor(d, path.relative(rot, d)))
+  } catch (e) {
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  console.log(rader.join('\n'))
 } else {
   console.error(
-    'okänt kommando (add-run, next-n, ny-korning, proveniens, sparr, utslag, set-status, kalibrering)',
+    'okänt kommando (add-run, next-n, ny-korning, ny-del, proveniens, sparr, utslag, set-status, stopp, respec, bluf, nasta-steg, kalibrering, experiment)',
   )
   process.exit(2)
 }
 
+/** Tolkar ett --satt-par "nyckel=värde". Första "=" delar; `eskalerad` är
+ *  det enda booleska fältet och tar bara true/false, allt annat är en sträng.
+ *  `varianter` och `korningar` har egna flaggor med egen semantik (union,
+ *  egen rad) och får inte skrivas rakt av här. */
+function tolkaSatt(par) {
+  const i = par.indexOf('=')
+  if (i < 1) {
+    console.error(`experiment: --satt ska ha formen nyckel=värde, fick "${par}"`)
+    process.exit(2)
+  }
+  const nyckel = par.slice(0, i)
+  const ra = par.slice(i + 1)
+  if (nyckel === 'varianter' || nyckel === 'korningar') {
+    console.error(`experiment: ${nyckel} skrivs med --variant respektive --korning, inte --satt`)
+    process.exit(2)
+  }
+  if (nyckel === 'eskalerad') {
+    if (ra !== 'true' && ra !== 'false') {
+      console.error(`experiment: eskalerad tar bara true eller false, fick "${ra}"`)
+      process.exit(2)
+    }
+    return [nyckel, ra === 'true']
+  }
+  return [nyckel, ra]
+}
+
+/** Effort ur agentdefinitionens frontmatter: raden `effort: <värde>` mellan
+ *  de inledande `---`-raderna, markörrader (haus_managed:) tål den. Saknas
+ *  filen eller raden blir det null och en VARNING på stderr: IPC 14001 hade
+ *  effort null på alla rader utan att någon såg det. Läser aldrig brödtexten. */
+function effortFranAgent(agent) {
+  const p = path.join(claudeDir(), 'agents', `${agent}.md`)
+  let text
+  try {
+    text = stripHausMarker(readFileSync(p, 'utf8'))
+  } catch (e) {
+    console.error(`VARNING: kunde inte läsa ${p} för effort (${e.message}), effort blir null`)
+    return null
+  }
+  const lines = text.split('\n')
+  if (lines[0]?.trim() === '---') {
+    for (let i = 1; i < lines.length && lines[i].trim() !== '---'; i++) {
+      const m = /^effort:\s*(\S+)$/.exec(lines[i])
+      if (m) return m[1]
+    }
+  }
+  console.error(`VARNING: ${p} saknar en effort-rad i sin frontmatter, effort blir null`)
+  return null
+}
+
+/** Delkataloger under `dir`, REKURSIVT och i numerisk ordning: del-N som har
+ *  en state.json, djupet först (del-1, del-1/del-1, del-1/del-2, del-2, del-10).
+ *  En del utan state.json är inte en körning ännu och hoppas över, liksom
+ *  allt under den. Delad av proveniens och bluf så de två aldrig kan se
+ *  olika delar. */
+function delKataloger(dir) {
+  let entries
+  try {
+    entries = readdirSync(dir, { withFileTypes: true })
+  } catch (e) {
+    throw new ArkivFel(`kunde inte lista ${dir}: ${e.message}`)
+  }
+  return entries
+    .filter((e) => e.isDirectory() && /^del-\d+$/.test(e.name))
+    .sort((a, b) => Number(a.name.slice(4)) - Number(b.name.slice(4)))
+    .map((e) => path.join(dir, e.name))
+    .filter((d) => existsSync(path.join(d, 'state.json')))
+    .flatMap((d) => [d, ...delKataloger(d)])
+}
+
+/** Scorerns gällande utfall ur prisfilen, eller null när inget poängvarv
+ *  finns. Läses bara för att `nasta-steg` inte ska säga "sync till brädan"
+ *  om en post vars gällande varv är DELA_UPP eller OVER_SKALAN: de utfallen
+ *  når arkivet via prisfilen, aldrig via `stopp` (se STOPP_UTFALL). Samma
+ *  fil som `bluf` och `pricedBlockers` läser, via samma hjälpare. */
+function gallandeScorerUtfall(state, d) {
+  const n = maxN(state.runs ?? [], 'score')
+  if (n === 0) return null
+  const fil = gallandeDokumentFil(state, 'score', n)
+  return { fil, outcome: readPricingFileOrThrow(fil, d).outcome ?? null }
+}
+
+/** Regeltabellen bakom `nasta-steg` (#530). Varje regel är en avläsning av
+ *  en grind som redan står i SKILL.md; kolumnen "väntar på" är det en
+ *  MÄNNISKA måste göra, "nästa" det /request-kommando som kör vidare.
+ *  Första träff vinner, uppifrån:
+ *
+ *  | läge                                  | källa i SKILL.md                                              |
+ *  | ------------------------------------- | ------------------------------------------------------------- |
+ *  | bunt-rot (ingen spec.md, del-N finns) | Experimentytan, buntregeln; bluf:s `bunt (N delar)`           |
+ *  | spärr står (sparrSkal)                | bedöm steg 6 OLIKA "Hänvisa sedan till `döm <post>`"; `döm`   |
+ *  | stopp KONCEPT/DIAGNOS                 | speca steg 6 "Kandidatens katalog kan fortfarande läggas på   |
+ *  |                                       | brädan … men `bedöm` hoppar över den"; stopputfall → kunddialog |
+ *  | stopp TILLBAKA_TILL_SPEC              | speca steg 6 (ADR-0118) "När valet avgjorts skrivs svaret     |
+ *  |                                       | under `## Avgjorda val` …, sedan `respec` och ny dispatch"     |
+ *  | stopp ESKALERA                        | speca steg 6 "en människa dömer, posten går aldrig en tredje  |
+ *  |                                       | specrunda"; stopputfall ESKALERA → visa skälet och stanna     |
+ *  | experiment                            | Experimentytan: "kan inte förväxlas med en prispost";         |
+ *  |                                       | Hårda regler "Experimentdata når aldrig Asana"                |
+ *  | spec_draft utan approval              | speca steg 7 "Erbjud att lägga specarna på brädan (🔍)";       |
+ *  |                                       | godkänn/underkänn verkar från 🔍                              |
+ *  | spec_synced utan approval             | godkänn/underkänn-lägesgrinden: 🔍 → ✅ Spec ok               |
+ *  | spec_draft/spec_synced med approval   | bedöm-grinden: "Endast `✅ Spec ok` … släpper igenom",         |
+ *  |                                       | "Post utan bräda: `godkänn` antecknar approval manual"        |
+ *  | assessed utan poängvarv               | bedöm steg 3–7: analysen finns, poängen saknas                |
+ *  | assessed, scorerns DELA_UPP           | stopputfall → "ny analysrunda per del … `split` satt"         |
+ *  | assessed, scorerns OVER_SKALAN        | stopputfall → "offereras separat; delas aldrig vidare"        |
+ *  | assessed, scorerns övriga stopp       | stopputfall → kunddialog / spec-steget / visa skälet, stanna  |
+ *  | assessed (poäng)                      | bedöm steg 8: sync via request-sync tar ✅ → ⚖️, sedan          |
+ *  |                                       | godkänn/underkänn från ⚖️                                     |
+ *  | priced                                | godkänn-grinden: ⚖️ → 📤 Klar – till kund                     |
+ *  | guard_run                             | `guard_run` reserveras för guard-kommandot: inget väntar      |
+ *  | allt annat                            | `okänt läge: <status>`, aldrig en gissning                    |
+ *
+ *  `står` är statusen plus det som avviker från grundläget: stoppet,
+ *  scorerns stopputfall, olyft OLIKA, `respec_varv` > 0, manuell approval
+ *  och experimentmarkören. Funktionen är ren (ingen I/O) så tabellen går
+ *  att testa rad för rad. */
+function nastaStegFor(state, { post, antalDelar, scorerUtfall }) {
+  const status = state.status
+  const gid = state.request_id ?? '<gid>'
+  const adress = state.request_id ?? post
+  const stopp = state.stopp ?? null
+  const runs = state.runs ?? []
+  const nScore = maxN(runs, 'score')
+  const gallandeRad =
+    nScore > 0 ? [...runs].reverse().find((r) => r.file === `score-pricing-v${nScore}.json`) : null
+  const olikaOlyft = gallandeRad?.double_run === 'olika' && !liftedByUtslag(state, 'score', nScore)
+  const vantarDom = sparrSkal(state).length > 0
+  const scorerStopp =
+    scorerUtfall !== null && SCORE_STOP.includes(scorerUtfall.outcome) ? scorerUtfall : null
+  const star = [
+    status,
+    stopp ? `stopp ${stopp.utfall} (${stopp.kalla})` : null,
+    !stopp && scorerStopp ? `${scorerStopp.outcome} (${scorerStopp.fil})` : null,
+    olikaOlyft ? 'OLIKA olyft' : vantarDom ? 'omkörning olyft' : null,
+    (state.respec_varv ?? 0) > 0 ? `respec_varv ${state.respec_varv}` : null,
+    state.approval?.source === 'manual' ? 'approval manual' : null,
+    state.experiment === true ? 'experiment' : null,
+  ]
+    .filter((v) => v !== null)
+    .join(', ')
+  const rad = (vantar, nasta, egenStar = star) => ({ star: egenStar, vantar, nasta })
+  const godkannEller = `godkänn ${gid} eller underkänn ${gid} <skäl>`
+  const kunddialog = () =>
+    rad(
+      'kunddialog',
+      'kunddialog; lägg posten på brädan via request-sync (🔍) om den saknas där, bedöm hoppar över den',
+    )
+  const tillbakaTillSpec = (val) =>
+    rad(
+      `avgör valet: ${val}`,
+      `avgör valet, skriv det under ## Avgjorda val i kallmanifest.md, sedan archive.mjs respec och speca ${adress} om`,
+    )
+
+  if (antalDelar > 0) return rad('se delarna', 'se delarna', `bunt (${antalDelar} delar)`)
+  if (vantarDom) return rad('dom (döm)', `döm ${post}`)
+  if (stopp) {
+    const val = stopp.orsak ?? stopp.kalla
+    if (stopp.utfall === 'KONCEPT' || stopp.utfall === 'DIAGNOS') return kunddialog()
+    if (stopp.utfall === 'TILLBAKA_TILL_SPEC') return tillbakaTillSpec(val)
+    if (stopp.utfall === 'ESKALERA')
+      return rad(`avgör valet: ${val}`, 'människa dömer, ingen ny specrunda')
+  }
+  if (state.experiment === true)
+    return rad('inget (experiment, når aldrig Asana)', 'utvärdera rapport')
+  const godkand = state.approval !== null && state.approval !== undefined
+  if (status === 'spec_draft' || status === 'spec_synced') {
+    if (godkand) return rad('körning av bedöm', `bedöm ${adress}`)
+    return status === 'spec_draft'
+      ? rad(
+          'godkännande av spec på brädan',
+          `sync till brädan (request-sync 🔍), sedan ${godkannEller}`,
+        )
+      : rad('godkännande av spec på brädan', godkannEller)
+  }
+  if (status === 'assessed') {
+    if (nScore === 0) return rad('körning av bedöm', `bedöm ${adress} (poängsättning saknas)`)
+    if (scorerStopp) {
+      const o = scorerStopp.outcome
+      if (o === 'DELA_UPP')
+        return rad('ny analysrunda per del', 'dela posten (split), sedan bedöm per del')
+      if (o === 'OVER_SKALAN')
+        return rad('manuell offert', 'offereras separat, delas aldrig vidare')
+      if (o === 'KONCEPT' || o === 'DIAGNOS') return kunddialog()
+      if (o === 'TILLBAKA_TILL_SPEC') return tillbakaTillSpec(scorerStopp.fil)
+      return rad(
+        `människa: ${o} ur ${scorerStopp.fil}`,
+        `visa skälet och stanna (detaljer ${adress} poäng)`,
+      )
+    }
+    return rad(
+      'granskning av poäng på brädan',
+      `sync till brädan (request-sync ⚖️), sedan ${godkannEller}`,
+    )
+  }
+  if (status === 'priced')
+    return rad(
+      'granskning av poäng på brädan',
+      `sync till brädan (request-sync ⚖️) om inte gjort, sedan godkänn ${gid} (📤 Klar – till kund) eller underkänn ${gid} <skäl>`,
+    )
+  if (status === 'guard_run') return rad('inget', 'inget')
+  return rad('–', '–', `okänt läge: ${status}`)
+}
+
 /** 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`.
@@ -1250,8 +2104,8 @@ function gallandeDokumentFil(state, typ, n) {
  *  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)
+function readPricingFileOrThrow(fil, d = katalog) {
+  const p = path.join(d, fil)
   let raw
   try {
     raw = readFileSync(p, 'utf8')
@@ -1345,6 +2199,13 @@ function pricedBlockers(state) {
   if (state.experiment === true) {
     skal.push('experimentvariant blir aldrig priced')
   }
+  // Ett stopputfall skrivet av `stopp` (kandidat ur spec.md, motsägelse ur
+  // impact.md) gäller tills `respec` nollar det. Bara HÄR, aldrig i
+  // `sparrSkal`: sparr betyder "väntar på dom" och styr utvärderas
+  // återupptagning; ett stopp där hade låst posten för alltid.
+  if (state.stopp !== null && typeof state.stopp === 'object') {
+    skal.push(`stopputfall ${state.stopp.utfall} ur ${state.stopp.kalla}`)
+  }
   const runs = state.runs ?? []
   const nClass = maxN(runs, 'classification')
   if (nClass > 0) {