@haus-tech/haus-workflow 5.12.1 → 6.1.0

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

@@ -19,26 +19,38 @@
  * väntas göra och vilket /request-kommando som kör vidare, ur SKILL.md:s
  * egna grindar (regeltabellen står ovanför `nastaStegFor`). Del 6 (designa,
  * spec 2026-09-24): add-design, som verifierar, lägger undan, kopierar in
- * och bokför designdokumentet i state.design utan runs-rad.
+ * och bokför designdokumentet i state.design utan runs-rad. Del 7 (ADR-0156
+ * beslut 3 och 5): add-design-review, som kopierar in granskarens svar som
+ * design-review.md och bokför kvittot i state.design.review (utan runs-rad,
+ * kostnaden står i korning.json), och antaganden, läs-enbart lista över
+ * utkastets antaganden, granskningens utslag och spec conflicts.
  *
  * 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> [--request-id G]
  *   node archive.mjs ny-del <körningskatalog> --typ bundle|split --part N --of M --request-id G
+ *   node archive.mjs ny-del <postkatalog> --typ split --part N --of M   (produktionsdel, #599)
  *   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|design-avvisad-<datum>.md [--orsak <text>]
+ *   node archive.mjs stopp <katalog> --utfall KONCEPT|DIAGNOS|TILLBAKA_TILL_SPEC|ESKALERA --kalla spec.md|impact.md|granskarblock.md|design-avvisad-<datum>.md|design-intervju-kravs-<datum>.md [--orsak <text>]
  *   node archive.mjs respec <katalog>
  *   node archive.mjs add-design <katalog> --file <absolut sökväg till designdokumentet>
+ *   node archive.mjs add-design-review <katalog> --file <abs> --verdict fortsätt|stopp --model <m>
+ *   node archive.mjs antaganden <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]]
  *   node archive.mjs set-split-gid <del-katalog> --gid <gid>
+ *   node archive.mjs approve <katalog> --source asana --status "<Offer status>" | --source manual --by <namn>
+ *   node archive.mjs synced <katalog> --offer-status "<Offer status>"
  *   node archive.mjs paraply <katalog> --file <spec>
+ *   node archive.mjs korning-start <katalog> --pid <N> [--katalog-korning <absolut sökväg>]
+ *   node archive.mjs korning-slut <katalog>
+ *   node archive.mjs rot [<katalog>]
  * Exit 0 = ok, 1 = spärrad (sparr/set-status priced), 2 = användnings-/tillståndsfel.
  */
 import {
@@ -57,6 +69,7 @@ import {
   copyFileSync,
 } from 'node:fs'
 import path from 'node:path'
+import { spawnSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import {
   markerStrippedSha256,
@@ -65,22 +78,31 @@ import {
   canonicalModel,
   kandidatIn,
   avvikelseEtikett,
+  avvikelseText,
   prisavgorandeVal,
   findUpward,
   CLASS_UTFALL,
   SCORE_OUTCOMES,
   designFrontmatter,
   specConflicts,
+  designMode,
+  designAssumptions,
+  sectionLines,
   katalogId,
+  designForm,
+  designSymbolkontroll,
+  repoRotForFil,
   specForm,
   SPEC_HEADINGS,
+  alfabetiskKarna,
+  arkivRot,
 } from './lib.mjs'
 
 const [cmd, katalog, ...rest] = process.argv.slice(2)
 
-if (!cmd || !katalog) {
+if (!cmd || (!katalog && cmd !== 'rot')) {
   console.error(
-    'användning: archive.mjs <add-run|next-n|ny-korning|ny-del|proveniens|sparr|utslag|set-status|stopp|respec|add-design|set-split-gid|paraply|bluf|nasta-steg|kalibrering|experiment> <katalog> [flaggor]',
+    'användning: archive.mjs <add-run|next-n|ny-korning|ny-del|proveniens|sparr|utslag|set-status|stopp|respec|add-design|add-design-review|antaganden|set-split-gid|approve|synced|paraply|korning-start|korning-slut|rot|bluf|nasta-steg|kalibrering|experiment> <katalog> [flaggor]',
   )
   process.exit(2)
 }
@@ -245,6 +267,20 @@ const readStateOrThrow = (d = katalog) => {
   ) {
     throw new ArkivFel(`${statePath(d)} har ett design-fält som varken är null eller ett objekt`)
   }
+  // ADR-0156 beslut 3: design.review är saknat, null eller ett objekt med en
+  // sträng `verdict`, skrivet av add-design-review. Allt annat är trasigt:
+  // nasta-steg läser verdict, och en sträng där hade tyst lästs som "ingen
+  // granskning".
+  const review = parsed.design?.review
+  if (
+    review !== undefined &&
+    review !== null &&
+    (typeof review !== 'object' || Array.isArray(review) || typeof review.verdict !== 'string')
+  ) {
+    throw new ArkivFel(
+      `${statePath(d)} har ett design.review som varken är null eller ett objekt med en sträng verdict`,
+    )
+  }
   // ADR-0144 beslut 6: split.gid är saknat, null eller ett Asana-gid som
   // sträng, skrivet av set-split-gid. Allt annat är trasigt: nasta-steg läser
   // fältet för att avgöra om delens deluppgift finns, och ett tal eller en
@@ -268,6 +304,23 @@ const readStateOrThrow = (d = katalog) => {
   ) {
     throw new ArkivFel(`${statePath(d)} har ett umbrella-fält som varken är null eller ett objekt`)
   }
+  // ADR-0155 beslut 3: `korning` är null, saknat eller ett objekt { pid,
+  // started, katalog } skrivet av korning-start. pid måste vara ett heltal:
+  // isAlive(pid) och nasta-steg läser det, och en sträng där hade tyst lästs
+  // som "ingen körning pågår". pid 0 är ingen process: kill(0, 0) prövar
+  // processgruppen och svarar alltid levande.
+  if (
+    parsed.korning !== undefined &&
+    parsed.korning !== null &&
+    (typeof parsed.korning !== 'object' ||
+      Array.isArray(parsed.korning) ||
+      !Number.isInteger(parsed.korning.pid) ||
+      parsed.korning.pid <= 0)
+  ) {
+    throw new ArkivFel(
+      `${statePath(d)} har ett korning-fält som varken är null eller ett objekt med ett heltals-pid > 0`,
+    )
+  }
   return parsed
 }
 
@@ -462,8 +515,8 @@ const isAlive = (pid) => {
  * (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 acquireLock = (d = katalog) => {
+  const lockPath = path.join(d, '.archive.lock')
   const start = Date.now()
   let warned = false
   const maybeWarn = (info) => {
@@ -542,6 +595,35 @@ const releaseLock = (lockPath) => {
   }
 }
 
+/** #693: en ny runda på en delningsdel (respec, eller add-run på en rundas
+ *  huvudfil) gör förälderns ⚖️-kvitto inaktuellt: föräldern stod på ⚖️ för
+ *  delarnas förra priser. Roten är katalogen ovanför del-N/ och nollas under
+ *  sitt eget lås, efter att delens lås släppts (ingen nästlad låsning).
+ *  Delens skrivning är då redan gjord, så ett arkivfel på roten (t.ex.
+ *  trasig state.json) är en VARNING och aldrig exit 2: en omkörning av
+ *  add-run hade vägrats som dubblett. Arkivet är en cache; Asana är
+ *  sanningen. De två skrivningarna är inte atomära: dör processen mellan
+ *  dem står rotens kvitto kvar till nästa respec eller add-run på en del.
+ *  Returnerar ett suffix till OK-raden. */
+const nollaRotensKvitto = (delState, d = katalog) => {
+  if (delState?.split?.parent == null) return ''
+  const rotDir = path.dirname(d)
+  if (!existsSync(path.join(rotDir, 'state.json'))) return ''
+  const lockPath = acquireLock(rotDir)
+  try {
+    const rotState = readStateOrThrow(rotDir)
+    if (rotState.board === null || rotState.board === undefined) return ''
+    writeStateOrThrow({ ...rotState, board: null }, rotDir)
+    return ', förälderns brädkvitto nollat'
+  } catch (e) {
+    if (!(e instanceof ArkivFel)) throw e
+    console.error(`VARNING: förälderns brädkvitto kunde inte nollas: ${e.message}`)
+    return ', förälderns brädkvitto INTE nollat (se VARNING)'
+  } finally {
+    releaseLock(lockPath)
+  }
+}
+
 /**
  * Kända arkivfilnamn — allt annat är ett formfel i `--file` (t.ex. ett
  * saknat "v" i "classification-pricing-1.json") som annars tyst arkiverar
@@ -564,6 +646,9 @@ const releaseLock = (lockPath) => {
 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$/
+/** En rundas huvudfil: PRICING_RE utan suffixsvans. -run2 och -avvisad är
+ *  aldrig huvudfil (bedöm steg 6: "-run2 files are NEVER counted"). */
+const HUVUDFIL_RE = /^(classification|score)-(pricing|guard)-v\d+\.json$/
 const FILE_PATTERNS = [SPEC_RE, IMPACT_RE, PRICING_RE]
 const isKnownFile = (file) => FILE_PATTERNS.some((re) => re.test(file))
 
@@ -628,6 +713,12 @@ const SCORE_STOP = [
 const STOPP_UTFALL = ['KONCEPT', 'DIAGNOS', 'TILLBAKA_TILL_SPEC', 'ESKALERA']
 const STOPP_KALLOR = ['spec.md', 'impact.md', 'granskarblock.md']
 const DESIGN_AVVISAD_RE = /^design-avvisad-\d{4}-\d{2}-\d{2}(-\d+)?\.md$/
+/** Designerns INTERVJU KRÄVS (P4-24): korning.mjs skriver svaret som kvittot
+ *  design-intervju-kravs-<datum>.md (`-2` vid kollision) och stoppar posten
+ *  som ESKALERA på det, så nästa batch inte betalar designern igen. Ett
+ *  designa löser det: add-design nollar stoppet. */
+const DESIGN_INTERVJU_RE = /^design-intervju-kravs-\d{4}-\d{2}-\d{2}(-\d+)?\.md$/
+const arIntervjuStopp = (stopp) => DESIGN_INTERVJU_RE.test(stopp?.kalla ?? '')
 
 /** Ett designkonfliktstopp (slutgranskning I2): assessorn fann designen
  *  obyggbar, motsägelseraden i impact.md börjar med `design conflict:` och
@@ -654,6 +745,8 @@ const MAX_KORNINGAR = 999
  *  är inte samma kontrakt. */
 const PROVENIENS_REFERENSER = [
   'agents/request-assessor.md',
+  'agents/request-design-reviewer.md',
+  'agents/request-designer.md',
   'agents/request-scorer.md',
   'agents/request-specifier-eskalerad.md',
   'agents/request-specifier.md',
@@ -724,8 +817,8 @@ const slugAv = (titel) =>
  *  `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,
+const skelett = (requestId, { bundle, split, experiment = true } = {}) => ({
+  ...(experiment ? { experiment: true } : {}),
   request_id: requestId,
   slug: null,
   former_slug: null,
@@ -740,6 +833,7 @@ const skelett = (requestId, { bundle, split } = {}) => ({
   respec_varv: 0,
   coverage_post: null,
   design: null,
+  board: null,
   runs: [],
 })
 
@@ -768,6 +862,8 @@ if (cmd === 'add-run') {
     'double-run',
     'superseded-by',
     'pairs-with',
+    // ADR-0155 beslut 6: HEAD-sha som en analys lästes mot (korning.mjs).
+    'repo-sha',
   ]
   const ADD_RUN_BOOLFLAGGOR = ['partial-rerun']
   avvisaOkandaFlaggor('add-run', ADD_RUN_VARDEFLAGGOR, ADD_RUN_BOOLFLAGGOR)
@@ -822,11 +918,17 @@ if (cmd === 'add-run') {
   const supersededBy = flag('superseded-by')
   const partialRerun = has('partial-rerun')
   const pairsWith = flag('pairs-with')
+  const repoSha = flag('repo-sha')
+  if (repoSha !== null && !/^[0-9a-f]{40}$/.test(repoSha)) {
+    console.error('--repo-sha kräver 40 hexsiffror')
+    process.exit(2)
+  }
 
   // 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
+  let delStateForRot = null
   try {
     const state = readStateOrThrow()
     // Dubblettvakt: en PRICING-/GUARD-fil (klass- eller poängaxelns
@@ -866,6 +968,8 @@ if (cmd === 'add-run') {
       pairs_with: pairsWith,
     }
     if (note) row.note = note
+    // Frånvarande, inte null, när flaggan utelämnas (ADR-0155 beslut 6).
+    if (repoSha !== null) row.repo_sha = repoSha
     for (const u of underlagFor(file)) {
       const p = path.join(katalog, u)
       try {
@@ -894,20 +998,32 @@ if (cmd === 'add-run') {
       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 }
-    }
+    // Täckningspost (ADR-0159, ändrar ADR-0119 beslut 4; #763, #687): fältet
+    // härleds ur den poängfil som GÄLLER efter den här raden, aldrig ur filen
+    // som råkar stämplas. Bara en poängprisfil (huvudfil, -run2 eller
+    // -avvisad) räknar om: en guardfil har en egen N-sekvens och synkas
+    // aldrig (SKILL.md, arkivträdet), och spec.md/impact.md får inte väcka en
+    // post som respec redan rensat. En -run2 eller -avvisad från en NYARE
+    // runda än den gällande (huvudfilen är inte stämplad än) räknar inte om
+    // heller: den rundan pågår och dess gällande fil finns inte än, så fältet
+    // behåller sitt värde (null efter en respec) tills rundans huvudfil
+    // stämplas. Se gallandeTackning för regeln.
+    const poangfil = /^score-pricing-v(\d+)(-[a-z0-9-]+)?\.json$/.exec(file)
+    if (poangfil) {
+      const efter = { ...state, runs: [...runs, row] }
+      if (Number(poangfil[1]) <= maxN(efter.runs, 'score'))
+        titelFalt = { ...titelFalt, coverage_post: gallandeTackning(efter) }
+    }
+    // ADR-0153 beslut 3: brädkvittot betyder att den gällande prisrundan
+    // ligger på brädan. En ny rundas huvudfil gör ett tidigare kvitto
+    // inaktuellt, så nasta-steg säger "om inte gjort" igen. -run2, -avvisad,
+    // spec.md och impact.md rör aldrig kvittot.
+    if (HUVUDFIL_RE.test(file) && state.board !== null && state.board !== undefined)
+      titelFalt = { ...titelFalt, board: null }
     const nyState = { ...state, ...titelFalt, runs: [...runs, row] }
     writeStateOrThrow(nyState)
     rowCount = nyState.runs.length
+    if (HUVUDFIL_RE.test(file)) delStateForRot = state
   } catch (e) {
     releaseLock(lockPath)
     if (e instanceof ArkivFel) {
@@ -917,7 +1033,8 @@ if (cmd === 'add-run') {
     throw e
   }
   releaseLock(lockPath)
-  console.log(`OK: runs-rad för ${file} (${rowCount} rader)`)
+  const rotSuffix = nollaRotensKvitto(delStateForRot)
+  console.log(`OK: runs-rad för ${file} (${rowCount} rader)${rotSuffix}`)
 } 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
@@ -1120,6 +1237,13 @@ if (cmd === 'add-run') {
       }
     }
     state.granskarutslag = [...(state.granskarutslag ?? []), row]
+    // ADR-0159: en dom på poängaxeln kan byta den gällande filen, så
+    // täckningsposten räknas om ur den. En trasig gällande fil fäller domen
+    // (exit 2) innan något skrivs.
+    // En dom om ett äldre varv byter aldrig den gällande filen (liftingUtslag
+    // kräver n === maxN) och räknar därför inte om.
+    if (row.typ === 'viktning' && row.axel === 'score' && row.n === maxN(state.runs ?? [], 'score'))
+      state.coverage_post = gallandeTackning(state)
     writeStateOrThrow(state)
     rowCount = state.granskarutslag.length
   } catch (e) {
@@ -1154,6 +1278,10 @@ if (cmd === 'add-run') {
     }
     if (stopp.length === 0) {
       state.status = status
+      // ADR-0159: priced är steget före synken, så täckningsposten räknas om
+      // här också. En huvudfil som stämplades innan den skrevs får då sin
+      // post även när ingen senare stämpling kom.
+      if (status === 'priced') state.coverage_post = gallandeTackning(state)
       writeStateOrThrow(state)
     }
   } catch (e) {
@@ -1253,19 +1381,96 @@ if (cmd === 'add-run') {
   // 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).
+  //
+  // #599: under en produktionspost (state.json finns och saknar
+  // experiment: true) skriver `--typ split` en produktionsdel i stället:
+  // ingen experimentmarkör (set-status priced vägrar den annars), split.parent
+  // är förälderns gid (katalognamnet när gid saknas), förälderns approval
+  // ärvs (delen ärver den godkända specen, ADR-0144), och split valideras som
+  // heltal vid skrivning, så ett handskrivet "of": "2" aldrig fäller
+  // delningslage för hela trädet efteråt. --request-id är då valfri och måste
+  // vara förälderns id.
   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')
+  const partRa = requireFlag('part')
+  const ofRa = requireFlag('of')
+  const heltal = (v) => (/^[1-9]\d{0,2}$/.test(v) ? Number(v) : NaN)
+  const part = heltal(partRa)
+  const of = heltal(ofRa)
   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})`)
+  if (!Number.isInteger(part) || !Number.isInteger(of) || part > of) {
+    console.error(
+      `--part och --of måste vara heltal 1-999 med part <= of (fick "${partRa}"/"${ofRa}")`,
+    )
     process.exit(2)
   }
+  let foralder = null
+  if (existsSync(path.join(katalog, 'state.json'))) {
+    // Förälderns lås hålls från läsningen till delens state.json är skriven:
+    // två samtidiga ny-del med olika --of kan annars båda passera
+    // syskonkontrollen. Varje utgång nedan är process.exit, så låset släpps
+    // i exit-hooken.
+    const lockPath = acquireLock(katalog)
+    process.on('exit', () => releaseLock(lockPath))
+    try {
+      foralder = readStateOrThrow(katalog)
+    } catch (e) {
+      if (!(e instanceof ArkivFel)) throw e
+      console.error(e.message)
+      process.exit(2)
+    }
+  }
+  const produktion = foralder !== null && foralder.experiment !== true
+  let requestId
+  let arvtGodkannande = null
+  if (produktion) {
+    const vagra = (msg) => {
+      console.error(`ny-del vägrar: ${msg}`)
+      process.exit(2)
+    }
+    if (typ !== 'split')
+      vagra('--typ bundle under en produktionspost (produktionsbuntar skrivs av speca)')
+    if (foralder.split?.parent != null)
+      vagra('föräldern är själv en delningsdel (en del delas aldrig vidare, den blir OVER_SKALAN)')
+    if (foralder.approval === null || foralder.approval === undefined)
+      vagra('föräldern saknar godkännande (delning följer bedöm, som kräver ett godkännande)')
+    // Delningen följer scorerns DELA_UPP (bedöm-routningen, ADR-0144): samma
+    // avläsning som nasta-steg gör, aldrig en handdelning av en annan post.
+    let utfall
+    try {
+      utfall = gallandeScorerUtfall(foralder, katalog)?.outcome ?? null
+    } catch (e) {
+      if (!(e instanceof ArkivFel)) throw e
+      vagra(e.message)
+    }
+    if (foralder.status !== 'assessed' || utfall !== 'DELA_UPP')
+      vagra(
+        `föräldern står inte på scorerns DELA_UPP (status ${foralder.status}, utfall ${utfall ?? 'inget'})`,
+      )
+    if (of < 2) vagra(`en delning har minst två delar (fick --of ${of})`)
+    const foralderId = foralder.request_id ?? path.basename(path.resolve(katalog))
+    const givet = flag('request-id')
+    if (givet !== null && givet !== foralderId)
+      vagra(`--request-id ${givet} är inte förälderns id ${foralderId}`)
+    for (const syskon of delKataloger(katalog).filter((d) => path.dirname(d) === katalog)) {
+      let st
+      try {
+        st = readStateOrThrow(syskon)
+      } catch (e) {
+        if (!(e instanceof ArkivFel)) throw e
+        vagra(e.message)
+      }
+      if (st.split?.parent != null && st.split.of !== of)
+        vagra(`${path.basename(syskon)} har split.of ${st.split.of}, inte ${of}`)
+    }
+    requestId = foralderId
+    arvtGodkannande = foralder.approval
+  } else {
+    requestId = requireFlag('request-id')
+  }
   const p = path.join(katalog, `del-${part}`)
   try {
     mkdirSync(p)
@@ -1274,12 +1479,17 @@ if (cmd === 'add-run') {
     process.exit(2)
   }
   const ref = { part, of }
-  const st = skelett(
-    requestId,
-    typ === 'bundle'
-      ? { bundle: { parent_slug: requestId, ...ref } }
-      : { split: { parent: requestId, ...ref } },
-  )
+  const st = produktion
+    ? {
+        ...skelett(null, { split: { parent: requestId, ...ref }, experiment: false }),
+        approval: arvtGodkannande,
+      }
+    : skelett(
+        requestId,
+        typ === 'bundle'
+          ? { bundle: { parent_slug: requestId, ...ref } }
+          : { split: { parent: requestId, ...ref } },
+      )
   try {
     writeStateOrThrow(st, p)
   } catch (e) {
@@ -1555,15 +1765,16 @@ if (cmd === 'add-run') {
   avvisaOkandaFlaggor('stopp', ['utfall', 'kalla', 'orsak'])
   const utfall = requireFlag('utfall')
   const kalla = requireFlag('kalla')
-  const orsak = flag('orsak')
+  let orsak = flag('orsak')
   if (!STOPP_UTFALL.includes(utfall)) {
     console.error(`okänt --utfall: ${utfall} (giltiga: ${STOPP_UTFALL.join(', ')})`)
     process.exit(2)
   }
   const arDesignKvitto = DESIGN_AVVISAD_RE.test(kalla)
-  if (!STOPP_KALLOR.includes(kalla) && !arDesignKvitto) {
+  const arIntervjuKvitto = DESIGN_INTERVJU_RE.test(kalla)
+  if (!STOPP_KALLOR.includes(kalla) && !arDesignKvitto && !arIntervjuKvitto) {
     console.error(
-      `okänd --kalla: ${kalla} (giltiga: ${STOPP_KALLOR.join(', ')}, design-avvisad-<datum>.md)`,
+      `okänd --kalla: ${kalla} (giltiga: ${STOPP_KALLOR.join(', ')}, design-avvisad-<datum>.md, design-intervju-kravs-<datum>.md)`,
     )
     process.exit(2)
   }
@@ -1611,6 +1822,23 @@ if (cmd === 'add-run') {
       )
       process.exit(2)
     }
+  } else if (arIntervjuKvitto) {
+    // P4-24: kvittot är designerns svar, och bara en första rad
+    // `INTERVJU KRÄVS: <skäl>` är ett stopp. Det går till en människa
+    // (designa, intervjun), aldrig tillbaka till specen.
+    const forsta = text.replace(/\r\n/g, '\n').trimStart().split('\n')[0].trim()
+    if (!/^INTERVJU KRÄVS:\s*\S/u.test(forsta)) {
+      console.error(`${kallaPath} börjar inte med "INTERVJU KRÄVS: <skäl>", kan inte stoppas`)
+      process.exit(2)
+    }
+    if (utfall !== 'ESKALERA') {
+      console.error(`ett intervjukrav i ${kalla} stoppar som ESKALERA, inte ${utfall}`)
+      process.exit(2)
+    }
+    if (!orsak) {
+      console.error('ESKALERA kräver --orsak: en människa ska se varför designern inte skrev något')
+      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) {
@@ -1645,6 +1873,26 @@ if (cmd === 'add-run') {
       console.error(`en motsägelse i ${kalla} stoppar som TILLBAKA_TILL_SPEC, inte ${utfall}`)
       process.exit(2)
     }
+    // #595: designkonflikten (texten efter etiketten börjar med `design
+    // conflict:`) avgör routningen till designa (arDesignkonflikt), så den
+    // läses ur filen, aldrig bara ur flaggan. Utan --orsak blir filens text
+    // orsaken; en --orsak som motsäger filen (en annan konflikttext, en
+    // specorsak mot en designkonflikt, eller en designkonflikt filen inte
+    // bär) vägras. En vanlig motsägelse behåller anroparens fria orsak.
+    const filText = avvikelseText(text)
+    const filKonflikt = filText !== null && /^design conflict:/i.test(filText) ? filText : null
+    const givenKonflikt = orsak !== null && /^design conflict:/i.test(orsak.trim())
+    const motsager =
+      orsak !== null && (filKonflikt !== null ? orsak.trim() !== filKonflikt : givenKonflikt)
+    if (motsager) {
+      console.error(
+        `--orsak motsäger impact.md: filen säger ${
+          filKonflikt === null ? 'ingen designkonflikt' : `"${filKonflikt}"`
+        }, flaggan "${orsak}"`,
+      )
+      process.exit(2)
+    }
+    if (filKonflikt !== null) orsak = filKonflikt
   }
 
   const lockPath = acquireLock()
@@ -1703,18 +1951,28 @@ if (cmd === 'add-run') {
   )
 } else if (cmd === 'respec') {
   // Speca steg 5 som kommando: en ny spec över befintlig katalog invaliderar
-  // analysen, designen, godkännandet, domarna och stoppet. runs[] rörs
+  // analysen, designen, godkännandet, domarna, stoppet och brädkvittot
+  // (ADR-0153 beslut 3: kvittot gällde en prisrunda som inte längre gäller). runs[] rörs
   // aldrig, arkivet är append-only; den gamla analysen och designen döps
   // om, raderas inte.
   avvisaOkandaFlaggor('respec', [])
   const lockPath = acquireLock()
   let antal = 0
+  let delState = null
   try {
     const state = readStateOrThrow()
+    // ADR-0155 beslut 3: en levande produktionskörning skriver mot samma
+    // katalog; vägra innan något läggs undan. Ett dött pid rensas nedan.
+    if (state.korning && isAlive(state.korning.pid))
+      throw new ArkivFel(`respec vägrar: pågår (pid ${state.korning.pid})`)
+    delState = state
     if (laggUndan(katalog, 'impact')) antal++
     // Designa (spec 2026-09-24): en ny spec gör den gamla designen inaktuell
     // av samma skäl som den gör analysen inaktuell. Läggs undan, raderas inte.
     if (laggUndan(katalog, 'design')) antal++
+    // ADR-0156 beslut 3: granskningen gällde den gamla designen och följer
+    // den, undanlagd; state.design.review nollas med state.design nedan.
+    if (laggUndan(katalog, 'design-review')) antal++
     const nytt = { ...state }
     if (nytt.status !== 'spec_draft') {
       nytt.status = 'spec_draft'
@@ -1736,6 +1994,22 @@ if (cmd === 'add-run') {
       nytt.design = null
       antal++
     }
+    if (nytt.board !== null && nytt.board !== undefined) {
+      nytt.board = null
+      antal++
+    }
+    // ADR-0159: täckningsposten hörde till en prisrunda som inte längre
+    // gäller; nästa poängrunda räknar fram den på nytt.
+    if (nytt.coverage_post !== null && nytt.coverage_post !== undefined) {
+      nytt.coverage_post = null
+      antal++
+    }
+    // Ett dött kvitto (levande vägrades ovan) hör till en körning som inte
+    // finns; en ny spec nollar det.
+    if (nytt.korning !== null && nytt.korning !== undefined) {
+      nytt.korning = 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
@@ -1752,7 +2026,7 @@ if (cmd === 'add-run') {
     throw e
   }
   releaseLock(lockPath)
-  console.log(`OK: respec (${antal} ändringar)`)
+  console.log(`OK: respec (${antal} ändringar${nollaRotensKvitto(delState)})`)
 } else if (cmd === 'add-design') {
   // Designa steg 5 (spec 2026-09-24): designdokumentet verifieras, kopieras
   // byteidentiskt in som design.md, bokförs i state.design och sätter status
@@ -1775,8 +2049,113 @@ if (cmd === 'add-run') {
     throw e
   }
   releaseLock(lockPath)
+  // ADR-0156 beslut 4: intervjudokumentets saknade utkastsektioner och en
+  // symbolkontroll som inte kunde köras vägrar inte; de syns på stderr.
+  for (const v of kvitto.varningar) console.error(`VARNING: ${v}`)
   console.log(`OK: design ${kvitto.design.path} (${kvitto.design.sha256})`)
   if (kvitto.impactUndanlagd) console.log('OK: impact.md undanlagd (designkonfliktstoppet löst)')
+} else if (cmd === 'add-design-review') {
+  // ADR-0156 beslut 3: designgranskarens svar kopieras byteidentiskt in som
+  // design-review.md och bokförs i state.design.review. Ingen runs-rad:
+  // granskningen är intern som designen, kostnaden står i korning.json. En
+  // tidigare granskning läggs undan som design-review-superseded-<datum>.md.
+  // --model lagras som det ges (korning.mjs skickar MODELL:-svansraden).
+  avvisaOkandaFlaggor('add-design-review', ['file', 'verdict', 'model'])
+  const fil = requireFlag('file')
+  const verdict = requireFlag('verdict')
+  const model = requireFlag('model')
+  if (verdict !== 'fortsätt' && verdict !== 'stopp') {
+    console.error(
+      `add-design-review vägrar: --verdict måste vara fortsätt eller stopp, fick "${verdict}"`,
+    )
+    process.exit(2)
+  }
+  const lockPath = acquireLock()
+  let sha256
+  try {
+    const state = readStateOrThrow()
+    if (state.experiment === true) throw new ArkivFel('add-design-review vägrar: experimentkatalog')
+    if (state.design === null || state.design === undefined)
+      throw new ArkivFel('add-design-review vägrar: ingen design att granska')
+    // Bytes läses före undanläggningen, så även katalogens egen
+    // design-review.md går att peka ut utan att kopian faller på en flyttad fil.
+    let bytes
+    try {
+      bytes = readFileSync(path.resolve(fil))
+    } catch (e) {
+      throw new ArkivFel(`add-design-review vägrar: kan inte läsa ${fil}: ${e.message}`)
+    }
+    laggUndan(katalog, 'design-review')
+    const mal = path.join(katalog, 'design-review.md')
+    try {
+      writeFileSync(mal, bytes)
+    } catch (e) {
+      throw new ArkivFel(`kunde inte skriva ${mal}: ${e.message}`)
+    }
+    sha256 = markerStrippedSha256(mal)
+    writeStateOrThrow({
+      ...state,
+      design: { ...state.design, review: { verdict, sha256, date: today(), model } },
+    })
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log(`OK: design-review ${verdict} (${sha256})`)
+} else if (cmd === 'antaganden') {
+  // ADR-0156 beslut 5: läs-enbart lista inför "synka" över varje antagande
+  // utkastet gjorde själv (fråga, valt, ej valt, skäl), granskningens utslag
+  // med antal fynd och spec conflicts, ur design.md och state.json, aldrig
+  // handskriven. Inget lås, ingen skrivning.
+  avvisaOkandaFlaggor('antaganden', [])
+  const ut = []
+  try {
+    let text
+    try {
+      text = readFileSync(path.join(katalog, 'design.md'), 'utf8')
+    } catch {
+      throw new ArkivFel('antaganden vägrar: ingen design')
+    }
+    const state = readStateOrThrow()
+    ut.push(`Designläge: ${designMode(text)}`)
+    const antaganden = designAssumptions(text)
+    if (antaganden === null) ut.push('Antaganden: avsnitt saknas')
+    else if (!Array.isArray(antaganden)) ut.push(`Antaganden: felformade (${antaganden.fel})`)
+    else if (antaganden.length === 0) ut.push('Antaganden: inga')
+    else {
+      ut.push(`Antaganden (${antaganden.length}):`)
+      antaganden.forEach((a, i) => {
+        ut.push(
+          `${i + 1}. ${a.fraga}`,
+          `   vald: ${a.vald}`,
+          `   ej valda: ${a.ejValda.length > 0 ? a.ejValda.join('; ') : 'inga'}`,
+          `   skäl: ${a.skal}`,
+        )
+      })
+    }
+    const review = state.design?.review ?? null
+    ut.push(
+      review === null
+        ? 'Granskning: ingen'
+        : `Granskning: ${review.verdict} (${antalFynd(path.join(katalog, 'design-review.md'))})`,
+    )
+    const konflikter = specConflicts(text)
+    if (konflikter === null) ut.push('Spec conflicts: avsnitt saknas')
+    else if (konflikter.length === 0) ut.push('Spec conflicts: none')
+    else ut.push(`Spec conflicts: ${konflikter.length}`, ...konflikter.map((k) => `  ${k}`))
+  } catch (e) {
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  console.log(ut.join('\n'))
 } else if (cmd === 'set-split-gid') {
   // ADR-0144 beslut 6: delens Asana-deluppgift bokförs i split.gid när
   // request-sync har skapat den, så en omsynk uppdaterar deluppgiften i
@@ -1813,6 +2192,186 @@ if (cmd === 'add-run') {
   }
   releaseLock(lockPath)
   console.log(oforandrat ? `OK: split-gid ${gid} oförändrat` : `OK: split-gid ${gid}`)
+} else if (cmd === 'approve') {
+  // ADR-0153 beslut 2: approval skrivs bara här. Grinden (designa eller
+  // bedöm) läser brädan och skickar Offer status som den lästes; allt annat
+  // än kärnan specok vägras, så en grind som inte lästs kan inte noteras.
+  // En tidigare notering skrivs över: grinden läses om varje gång.
+  avvisaOkandaFlaggor('approve', ['source', 'status', 'by'])
+  const source = requireFlag('source')
+  if (source !== 'asana' && source !== 'manual') {
+    console.error(`--source måste vara asana eller manual, fick "${source}"`)
+    process.exit(2)
+  }
+  // En flagga som hör till den andra källan tappas aldrig tyst: den vägras.
+  if (source === 'asana' && has('by')) {
+    console.error('--by hör inte till --source asana')
+    process.exit(2)
+  }
+  if (source === 'manual' && has('status')) {
+    console.error('--status hör inte till --source manual')
+    process.exit(2)
+  }
+  let approval
+  if (source === 'asana') {
+    const status = requireFlag('status')
+    if (alfabetiskKarna(status) !== 'specok') {
+      console.error(`approve vägrar: Offer status "${status}" är inte ✅ Spec ok`)
+      process.exit(2)
+    }
+    approval = { source, status_read: status, date: today() }
+  } else {
+    const by = requireFlag('by')
+    if (by.trim() === '') {
+      console.error('--by får inte vara tom')
+      process.exit(2)
+    }
+    approval = { source, by, date: today() }
+  }
+  const lockPath = acquireLock()
+  try {
+    const state = readStateOrThrow()
+    if (state.experiment === true) throw new ArkivFel('approve vägrar: experimentkatalog')
+    writeStateOrThrow({ ...state, approval })
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log(source === 'asana' ? 'OK: approval asana' : `OK: approval manual by ${approval.by}`)
+} else if (cmd === 'korning-start') {
+  // ADR-0155 beslut 3: bedom.mjs bokför sin process här innan den spawnar
+  // prisningen, så nasta-steg kan säga "pågår" och en andra start vägras.
+  // Ett dött pid övertas med en varning; EPERM räknas som levande (isAlive).
+  avvisaOkandaFlaggor('korning-start', ['pid', 'katalog-korning'])
+  const pidTxt = flag('pid')
+  if (pidTxt === null || !/^\d+$/.test(pidTxt) || Number(pidTxt) <= 0) {
+    console.error('korning-start kräver --pid <heltal>')
+    process.exit(2)
+  }
+  const pid = Number(pidTxt)
+  const katalogKorning = flag('katalog-korning')
+  const lockPath = acquireLock()
+  let varning = null
+  try {
+    const state = readStateOrThrow()
+    if (state.experiment === true) throw new ArkivFel('korning-start vägrar: experimentkatalog')
+    if (state.korning) {
+      if (isAlive(state.korning.pid))
+        throw new ArkivFel(`korning-start vägrar: pågår (pid ${state.korning.pid})`)
+      varning = `VARNING: tog över död körning (pid ${state.korning.pid})`
+    }
+    // `started` är en full ISO-tidsstämpel, den enda i state.json (övriga
+    // datum är today()): en körning behöver klockslag för att kunna läsas.
+    writeStateOrThrow({
+      ...state,
+      korning: { pid, started: new Date().toISOString(), katalog: katalogKorning },
+    })
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  if (varning) console.error(varning)
+  console.log(`OK: korning-start pid ${pid}`)
+} else if (cmd === 'korning-slut') {
+  // ADR-0155 beslut 3: kvittot rensas när bedom.mjs är klar. Utan kvitto är
+  // det ett no-op, aldrig ett fel: slutet ska kunna köras i en finally.
+  avvisaOkandaFlaggor('korning-slut', [])
+  const lockPath = acquireLock()
+  try {
+    const state = readStateOrThrow()
+    if (state.experiment === true) throw new ArkivFel('korning-slut vägrar: experimentkatalog')
+    if (state.korning !== null) writeStateOrThrow({ ...state, korning: null })
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log('OK: korning-slut')
+} else if (cmd === 'rot') {
+  // ADR-0154: arkivets enda hem, löst från katalogen (default cwd). `katalog`
+  // är här cwd att lösa från, inte en post; en flagga i första läget är ingen
+  // katalog. Läs-enbart, ingen lås.
+  const flaggaForst = katalog !== undefined && katalog.startsWith('-')
+  const tokens = flaggaForst ? [katalog, ...rest] : rest
+  if (tokens.length > 0) {
+    console.error(
+      `rot: okänd eller ej konsumerad flagga/argument (${tokens.join(' ')}), kommandot tar inga flaggor`,
+    )
+    process.exit(2)
+  }
+  const fran = path.resolve(katalog ?? process.cwd())
+  const r = arkivRot(fran)
+  if (!r) {
+    console.error(`rot vägrar: ingen git-katalog (${fran})`)
+    process.exit(2)
+  }
+  if (r.arkivRot === null) {
+    console.error(
+      `rot vägrar: git-common-dir heter inte .git (${r.commonDir}); kör från superprojektets egen utcheckning`,
+    )
+    process.exit(2)
+  }
+  console.log(`ARKIVROT: ${r.arkivRot}`)
+  console.log(`IGNORERAD: ${r.ignorerad ? 'ja' : 'nej'}`)
+  // Ett herrelöst arkiv i cwd:ns egen utcheckning (en worktree med eget
+  // requests/, Convendums läge mellan släppet och flytten) får en VARNING på
+  // stdout som precheck.mjs, exit fortfarande 0.
+  const topp = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: fran,
+    encoding: 'utf8',
+    timeout: 5000,
+  })
+  const toppDir = topp.status === 0 ? String(topp.stdout ?? '').trim() : ''
+  if (toppDir) {
+    const strat = path.join(path.resolve(toppDir), '.haus-workflow', 'requests')
+    if (strat !== path.resolve(r.arkivRot) && existsSync(strat))
+      console.log(`VARNING: arkiv i worktree: ${strat} (flytta per ADR-0154)`)
+  }
+} else if (cmd === 'synced') {
+  // ADR-0153 beslut 3: brädskrivningen i speca steg 7 och bedöm steg 8 följs
+  // av det här kvittot i state.board, Offer status ordagrant som request-sync
+  // satte den. Varje sync är ett nytt kvitto och skriver över det förra.
+  // Arkivet är fortfarande en cache: Closing-radens brädläge läses ur Asana.
+  avvisaOkandaFlaggor('synced', ['offer-status'])
+  const offerStatus = requireFlag('offer-status')
+  if (offerStatus.trim() === '') {
+    console.error('--offer-status får inte vara tom')
+    process.exit(2)
+  }
+  const board = { offer_status: offerStatus, date: today() }
+  const lockPath = acquireLock()
+  try {
+    const state = readStateOrThrow()
+    if (state.experiment === true) throw new ArkivFel('synced vägrar: experimentkatalog')
+    if (state.split?.parent != null)
+      throw new ArkivFel(
+        'synced vägrar: en delningsdel har ingen egen Offer status (split.gid är kvittot)',
+      )
+    writeStateOrThrow({ ...state, board })
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log(`OK: synced ${offerStatus}`)
 } else if (cmd === 'paraply') {
   // ADR-0144 beslut 5: förälderns spec skrivs om som en paraplyspec efter ett
   // ja. Den gamla spec.md läggs undan (spec-superseded-<datum>.md),
@@ -1898,7 +2457,9 @@ if (cmd === 'add-run') {
             ? 'prisavgörande val (granskarblock.md)'
             : DESIGN_AVVISAD_RE.test(state.stopp.kalla ?? '')
               ? `designkonflikt (${state.stopp.kalla})`
-              : 'motsägelse (impact.md)'
+              : arIntervjuStopp(state.stopp)
+                ? `intervju krävs (${state.stopp.kalla})`
+                : 'motsägelse (impact.md)'
     }
     // ADR-0144 beslut 6: delningsroten visar hur många delar som är klara,
     // samma räkning som nasta-steg (delningslage), före täckningsposten.
@@ -1957,7 +2518,7 @@ if (cmd === 'add-run') {
   console.log(rader.join('\n'))
 } else {
   console.error(
-    'okänt kommando (add-run, next-n, ny-korning, ny-del, proveniens, sparr, utslag, set-status, stopp, respec, add-design, set-split-gid, paraply, bluf, nasta-steg, kalibrering, experiment)',
+    'okänt kommando (add-run, next-n, ny-korning, ny-del, proveniens, sparr, utslag, set-status, stopp, respec, add-design, add-design-review, antaganden, set-split-gid, approve, synced, rot, paraply, bluf, nasta-steg, kalibrering, experiment)',
   )
   process.exit(2)
 }
@@ -1985,6 +2546,10 @@ function tolkaSatt(par) {
     }
     return [nyckel, ra === 'true']
   }
+  if (nyckel === 'design_mode' && ra !== 'draft' && ra !== 'intervju') {
+    console.error(`experiment: design_mode tar bara draft eller intervju, fick "${ra}"`)
+    process.exit(2)
+  }
   return [nyckel, ra]
 }
 
@@ -2034,7 +2599,9 @@ function delKataloger(dir) {
 
 /** Lägger undan <bas>.md som <bas>-superseded-<datum>.md, numrerad svans vid
  *  kollision (-2, -3 …), aldrig en överskrivning: arkivet raderar inget.
- *  Delad av respec (impact.md och design.md) och add-design (design.md).
+ *  Delad av respec (impact.md, design.md och design-review.md), add-design
+ *  (design.md och design-review.md), add-design-review (design-review.md),
+ *  paraply (spec.md) och add-design:s designkonfliktstopp (impact.md).
  *  Returnerar true när en fil flyttades. */
 function laggUndan(d, bas) {
   const fil = path.join(d, `${bas}.md`)
@@ -2050,6 +2617,28 @@ function laggUndan(d, bas) {
   return true
 }
 
+/** antaganden (ADR-0156 beslut 5): fyndräkningen i design-review.md som text
+ *  för Granskning-raden. Ett fynd är en listpunkt (`- ` eller `* `) under
+ *  `## Findings` på den första punktens indrag; en djupare indragen
+ *  underpunkt hör till fyndet ovanför och räknas inte. Den enda punkten
+ *  `none` är 0. En saknad fil eller sektion säger det, aldrig en gissad
+ *  nolla. */
+function antalFynd(fil) {
+  let text
+  try {
+    text = readFileSync(fil, 'utf8')
+  } catch {
+    return 'fynd okända, design-review.md saknas'
+  }
+  const rader = sectionLines(text.replace(/\r\n/g, '\n'), 'Findings')
+  if (rader === null) return 'fynd okända, ## Findings saknas'
+  const listpunkter = rader.map((r) => /^([ \t]*)[-*] (.*)$/.exec(r)).filter((m) => m !== null)
+  const indrag = listpunkter[0]?.[1] ?? ''
+  const punkter = listpunkter.filter((m) => m[1] === indrag).map((m) => m[2].trim())
+  const antal = punkter.length === 1 && punkter[0].toLowerCase() === 'none' ? 0 : punkter.length
+  return `${antal} fynd`
+}
+
 /** Repo-roten för en arkivkatalog: föräldern till närmaste `.haus-workflow`
  *  uppåt i sökvägen (arkivet bor i <rot>/.haus-workflow/requests/). null när
  *  katalogen inte ligger under någon; add-design vägrar då i stället för att
@@ -2065,14 +2654,17 @@ function repoRotFor(d) {
 }
 
 /** add-design: vägransreglerna i ordning (rot, fil, inneslutning, arkivet,
- *  frontmatter, spec-hash, konflikter, status, stopp), sedan undanläggning,
+ *  frontmatter, spec-hash, konflikter, status, stopp, utkastsektioner,
+ *  symboler), sedan undanläggning,
  *  kopia och state. Inneslutningen prövas på realpath (ADR-0082: en länk
  *  matchas på målet), och sökvägen som bokförs är realpath så precheck
  *  --design hittar samma fil oavsett länkar. Ett designkonfliktstopp ur
  *  impact.md nollas (en omdesign besvarar det, slutgranskning I2) och
  *  impact.md läggs undan med det; varje annat stopp vägras. Kastar
- *  ArkivFel, skriver inget före sista steget. Returnerar designkvittot och
- *  om en analys lades undan. */
+ *  ArkivFel, skriver inget före sista steget. Returnerar designkvittot, om
+ *  en analys lades undan och varningarna (ADR-0156 beslut 4: utkastsektioner
+ *  på ett intervjudokument, en symbolkontroll som inte kunde köras), som
+ *  anroparen skriver på stderr. */
 function laggTillDesign(state, fil) {
   const rot = repoRotFor(katalog)
   if (rot === null)
@@ -2131,17 +2723,44 @@ function laggTillDesign(state, fil) {
       `${statePath()} har status ${state.status}, en prissatt post designas inte om utan respec`,
     )
   const stopp = state.stopp ?? null
-  if (stopp !== null && !arDesignkonflikt(stopp))
+  // P4-24: ett intervjukrav (design-intervju-kravs-<datum>.md) besvaras av
+  // designa, så designen nollar det som designkonfliktstoppet.
+  if (stopp !== null && !arDesignkonflikt(stopp) && !arIntervjuStopp(stopp))
     throw new ArkivFel(
       `${statePath()} har ett stopp (${stopp.utfall} ur ${stopp.kalla}) som en design inte löser, kör respec eller avgör stoppet först`,
     )
+  // ADR-0156 beslut 4, efter de billiga statusvägrarna så en vägrad post
+  // aldrig startar git: ett utkast (mode: draft) bär Assumptions, Removed or
+  // renamed och Files touched, samma rader som precheck --design (på ett
+  // intervjudokument varningar). Varje borttagen eller omdöpt symbol greppas
+  // i repot där dokumentet bor, utanför filerna designen rör: en träff
+  // vägrar, en kontroll som inte kunde köras är en varning.
+  const designRot = repoRotForFil(real)
+  const form = designForm(text, { repoRot: designRot })
+  if (form.brister.length > 0) throw new ArkivFel(form.brister.join('\n'))
+  const { traffar, varning } = designSymbolkontroll(text, designRot)
+  if (traffar.length > 0)
+    throw new ArkivFel(
+      traffar
+        .map(
+          (t) =>
+            `add-design vägrar: symbolen \`${t.symbol}\` används fortfarande: ${t.fil}:${t.rad}`,
+        )
+        .join('\n'),
+    )
+  const varningar = [...form.varningar, ...(varning ? [varning] : [])]
   laggUndan(katalog, 'design')
+  // Granskningen gällde den ersatta designen och följer den, undanlagd som i
+  // respec; state.design.review följer aldrig med (nytt objekt nedan).
+  laggUndan(katalog, 'design-review')
   const mal = path.join(katalog, 'design.md')
   try {
     copyFileSync(real, mal)
   } catch (e) {
     throw new ArkivFel(`kunde inte kopiera ${real} till ${mal}: ${e.message}`)
   }
+  // Ett nytt objekt: en ny designversion har ingen granskning än, så en
+  // tidigare state.design.review följer aldrig med (ADR-0156 beslut 3).
   const design = {
     path: real,
     file: 'design.md',
@@ -2155,14 +2774,14 @@ function laggTillDesign(state, fil) {
   // en ny analys är skyldig oavsett omdesignens bytes, och en byteidentisk
   // omdesign hade annars lämnat motsägelseanalysen proveniensgiltig. runs[]
   // rörs inte, som i respec.
-  const impactUndanlagd = stopp !== null ? laggUndan(katalog, 'impact') : false
+  const impactUndanlagd = arDesignkonflikt(stopp) ? laggUndan(katalog, 'impact') : false
   writeStateOrThrow({
     ...state,
     design,
     status: 'designed',
     ...(stopp !== null ? { stopp: null } : {}),
   })
-  return { design, impactUndanlagd }
+  return { design, impactUndanlagd, varningar }
 }
 
 /** paraply (ADR-0144 beslut 5): vägransreglerna i ordning (delningsdel,
@@ -2280,6 +2899,9 @@ function delKlar(state, d) {
  *  | ------------------------------------- | ------------------------------------------------------------- |
  *  | bunt-rot (ingen spec.md, del-N finns) | The experiment area: `experiments/`, buntregeln;              |
  *  |                                       | bluf:s `bunt (N delar)`                                       |
+ *  | korning.pid lever                     | ADR-0155 beslut 3: bedom.mjs bokför sin process med           |
+ *  |                                       | korning-start; raden säger pågår, ett dött pid prefixar       |
+ *  |                                       | `står` med `avbruten körning, ` och raden räknas som vanligt  |
  *  | 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 |
@@ -2287,6 +2909,8 @@ function delKlar(state, d) {
  *  | med orsak `design conflict: …`        | routes it to `designa <adress>`"; add-design nollar stoppet   |
  *  |                                       | och lägger undan impact.md, ett kvitto ur designa steg 5      |
  *  |                                       | ersätter det (då gäller raden nedan)                          |
+ *  | stopp ESKALERA ur                     | designa Draft mode (P4-24): designern svarade INTERVJU        |
+ *  | design-intervju-kravs-<datum>.md      | KRÄVS; designa (intervjun) löser det, add-design nollar det   |
  *  | stopp TILLBAKA_TILL_SPEC              | speca steg 6 (ADR-0118) "När valet avgjorts skrivs svaret     |
  *  |                                       | under `## Avgjorda val` …, sedan `respec` och ny dispatch";   |
  *  |                                       | designa steg 5, ett kvitto design-avvisad-<datum>.md          |
@@ -2307,7 +2931,8 @@ function delKlar(state, d) {
  *  |                                       | Closing ISÄR-raden "`designed` ↔ ✅ Spec ok → `bedöm`"        |
  *  | assessed utan poängvarv               | bedöm steg 3–7: analysen finns, poängen saknas                |
  *  | assessed, scorerns DELA_UPP, delar    | ADR-0144 beslut 4 och 6: "se delarna (K av M delar            |
- *  | finns (delningslage)                  | prissatta)"; alla klara (delKlar) → sync föräldern (⚖️)       |
+ *  | finns (delningslage)                  | prissatta)"; alla klara (delKlar) → sync föräldern (⚖️),      |
+ *  |                                       | utom när rotens kvitto board har kärnan ⚖️ (#693)             |
  *  | assessed, scorerns DELA_UPP           | stopputfall → "ny analysrunda per del … `split` satt"         |
  *  | assessed, scorerns OVER_SKALAN, del   | ADR-0144 beslut 3: deluppgift utan Score; split.gid säger     |
  *  | (split.parent satt)                   | synkad, annars sync och set-split-gid                         |
@@ -2317,7 +2942,8 @@ function delKlar(state, d) {
  *  |                                       | godkänn/underkänn från ⚖️                                     |
  *  | priced, del (split.parent satt)       | ADR-0144 beslut 3 och 6: deluppgift med Score; split.gid      |
  *  |                                       | säger synkad, annars sync och set-split-gid                   |
- *  | priced                                | godkänn-grinden: ⚖️ → 📤 Klar – till kund                     |
+ *  | priced                                | godkänn-grinden: ⚖️ → 📤 Klar – till kund; ADR-0153 beslut 3: |
+ *  |                                       | kvittot board med kärnan ⚖️ säger synkad, annars om inte gjort |
  *  | guard_run                             | `guard_run` reserveras för guard-kommandot: inget väntar      |
  *  | allt annat                            | `okänt läge: <status>`, aldrig en gissning                    |
  *
@@ -2339,8 +2965,13 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall, delning = null })
   const vantarDom = sparrSkal(state).length > 0
   const scorerStopp =
     scorerUtfall !== null && SCORE_STOP.includes(scorerUtfall.outcome) ? scorerUtfall : null
+  // ADR-0155 beslut 3: ett kvitto vars pid lever är en pågående körning; ett
+  // dött är en avbruten (bedom.mjs hann aldrig köra korning-slut).
+  const korningPid = Number.isInteger(state.korning?.pid) ? state.korning.pid : null
+  const korningLever = korningPid !== null && isAlive(korningPid)
+  const avbruten = korningPid !== null && !korningLever ? 'avbruten körning, ' : ''
   const star = [
-    status,
+    avbruten + status,
     stopp ? `stopp ${stopp.utfall} (${stopp.kalla})` : null,
     !stopp && scorerStopp ? `${scorerStopp.outcome} (${scorerStopp.fil})` : null,
     olikaOlyft ? 'OLIKA olyft' : vantarDom ? 'omkörning olyft' : null,
@@ -2369,6 +3000,14 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall, delning = null })
       ? `synkad som deluppgift ${state.split.gid}${score}, se föräldern ${state.split.parent}${offert}`
       : `sync till brädan som deluppgift${score} under ${state.split?.parent} (request-sync) om inte gjort, sedan archive.mjs set-split-gid <del-katalog> --gid <deluppgiftens gid>${offert}`
   }
+  // ADR-0153 beslut 3: kvittot ur archive.mjs synced med kärnan ⚖️ säger att
+  // ⚖️-synken är gjord. Allt annat (null, saknat, en annan status) säger inte det.
+  const kvitto = state.board
+  const synkadVag =
+    kvitto !== null &&
+    typeof kvitto === 'object' &&
+    typeof kvitto.offer_status === 'string' &&
+    alfabetiskKarna(kvitto.offer_status) === alfabetiskKarna('⚖️ Poängsättning redo för granskning')
   const tillbakaTillSpec = (val) =>
     rad(
       `avgör valet: ${val}`,
@@ -2376,6 +3015,8 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall, delning = null })
     )
 
   if (antalDelar > 0) return rad('se delarna', 'se delarna', `bunt (${antalDelar} delar)`)
+  if (korningLever)
+    return rad('processen', 'vänta; bedöm igen när bedom.mjs är klar', `pågår (pid ${korningPid})`)
   if (vantarDom) return rad('dom (döm)', `döm ${post}`)
   if (stopp) {
     const val = stopp.orsak ?? stopp.kalla
@@ -2383,6 +3024,13 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall, delning = null })
     // Slutgranskning I2: en designkonflikt besvaras av en omdesign, inte av
     // en respec; add-design nollar stoppet.
     if (arDesignkonflikt(stopp)) return rad('omdesign (designa)', `designa ${adress}`)
+    // P4-24: designern bad om en intervju; designa löser stoppet.
+    if (arIntervjuStopp(stopp))
+      return rad(
+        'människa',
+        `designa ${adress} (intervju; se ${stopp.kalla})`,
+        `${avbruten}stopp ${stopp.utfall} ur ${stopp.kalla}`,
+      )
     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')
@@ -2410,6 +3058,14 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall, delning = null })
         )
       : rad('godkännande av spec på brädan', godkannEller)
   }
+  // ADR-0156 beslut 3: en granskning som stoppade avslutar kedjan på designed
+  // och går till det interaktiva designa; ett utslag skickas aldrig om.
+  if (status === 'designed' && state.design?.review?.verdict === 'stopp')
+    return rad(
+      'människa',
+      `designa ${adress} (intervju; se design-review.md)`,
+      'designed, granskningen stoppade',
+    )
   if (status === 'designed') return rad('körning av bedöm', `bedöm ${adress}`)
   if (status === 'assessed') {
     if (nScore === 0) return rad('körning av bedöm', `bedöm ${adress} (poängsättning saknas)`)
@@ -2421,11 +3077,15 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall, delning = null })
         // klar (delKlar) flyttar synken den till ⚖️.
         if (delning !== null && delning.klara < delning.av)
           return rad('se delarna', `se delarna (${delning.klara} av ${delning.av} delar prissatta)`)
+        // #693: synken som flyttar föräldern bokförs med synced på roten;
+        // kvittot läses som i priced-grenen (ADR-0153 beslut 3).
         if (delning !== null)
-          return rad(
-            'granskning av poäng på brädan',
-            `sync föräldern till brädan (request-sync ⚖️), sedan ${godkannEller}`,
-          )
+          return synkadVag
+            ? rad('granskning av poäng på brädan', godkannEller)
+            : rad(
+                'granskning av poäng på brädan',
+                `sync föräldern till brädan (request-sync ⚖️), sedan ${godkannEller}`,
+              )
         return rad('ny analysrunda per del', 'dela posten (split), sedan bedöm per del')
       }
       if (o === 'OVER_SKALAN')
@@ -2450,10 +3110,14 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall, delning = null })
         state.split.gid ? 'granskning av föräldern på brädan' : 'sync av deluppgiften',
         deluppgift(false),
       )
-    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>`,
-    )
+    // ADR-0153 beslut 3: synkadVag (ovan) läser kvittot; utan det "om inte gjort".
+    const godkannKlar = `godkänn ${gid} (📤 Klar – till kund) eller underkänn ${gid} <skäl>`
+    return synkadVag
+      ? rad('granskning av poäng på brädan', godkannKlar)
+      : rad(
+          'granskning av poäng på brädan',
+          `sync till brädan (request-sync ⚖️) om inte gjort, sedan ${godkannKlar}`,
+        )
   }
   if (status === 'guard_run') return rad('inget', 'inget')
   return rad('–', '–', `okänt läge: ${status}`)
@@ -2589,6 +3253,22 @@ function gallandeDokumentFil(state, typ, n) {
   return liftingUtslag(state, typ, n)?.galler_fil ?? `${typ}-pricing-v${n}.json`
 }
 
+/** Täckningsposten (ADR-0159, ändrar ADR-0119 beslut 4): `coverage_post` ur
+ *  den poängfil som gäller, `gallandeDokumentFil(state, 'score', maxN)`, så
+ *  att granskarens `galler_fil` styr på samma sätt som för poäng och utfall.
+ *  null när ingen poängrunda finns, när den gällande filen ännu inte skrivits
+ *  (den stämplas ofta före agentens fil; nästa omräkning fyller i den) och
+ *  när filen saknar ett objekt i fältet. Finns filen men är trasig kastar
+ *  readPricingFileOrThrow ArkivFel, samma arkivfel som andra läsare i filen. */
+function gallandeTackning(state, d = katalog) {
+  const n = maxN(state.runs ?? [], 'score')
+  if (n === 0) return null
+  const fil = gallandeDokumentFil(state, 'score', n)
+  if (!existsSync(path.join(d, fil))) return null
+  const cp = readPricingFileOrThrow(fil, d).coverage_post
+  return cp !== null && typeof cp === 'object' && !Array.isArray(cp) ? cp : null
+}
+
 /** 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