@haus-tech/haus-workflow 5.9.1 → 5.10.1

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

@@ -17,7 +17,9 @@
  * 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`).
+ * 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.
  *
  * Användning:
  *   node archive.mjs add-run <katalog> --file F --skill S --agent A --model M [flaggor]
@@ -28,12 +30,15 @@
  *   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 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 respec <katalog>
+ *   node archive.mjs add-design <katalog> --file <absolut sökväg till designdokumentet>
  *   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 paraply <katalog> --file <spec>
  * Exit 0 = ok, 1 = spärrad (sparr/set-status priced), 2 = användnings-/tillståndsfel.
  */
 import {
@@ -48,6 +53,8 @@ import {
   readdirSync,
   existsSync,
   mkdirSync,
+  realpathSync,
+  copyFileSync,
 } from 'node:fs'
 import path from 'node:path'
 import { createHash } from 'node:crypto'
@@ -62,13 +69,18 @@ import {
   findUpward,
   CLASS_UTFALL,
   SCORE_OUTCOMES,
+  designFrontmatter,
+  specConflicts,
+  katalogId,
+  specForm,
+  SPEC_HEADINGS,
 } from './lib.mjs'
 
 const [cmd, katalog, ...rest] = process.argv.slice(2)
 
 if (!cmd || !katalog) {
   console.error(
-    'användning: archive.mjs <add-run|next-n|ny-korning|ny-del|proveniens|sparr|utslag|set-status|stopp|respec|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|set-split-gid|paraply|bluf|nasta-steg|kalibrering|experiment> <katalog> [flaggor]',
   )
   process.exit(2)
 }
@@ -188,6 +200,11 @@ const assertRowArrayField = (parsed, field, d = katalog) => {
   }
 }
 
+/** Ett Asana-gid: bara siffror (ADR-0144, split.gid). Delat av
+ *  readStateOrThrow och set-split-gid så läs- och skrivsidan aldrig kan
+ *  godkänna olika former. */
+const GID_RE = /^\d+$/
+
 const readStateOrThrow = (d = katalog) => {
   let raw
   try {
@@ -217,6 +234,40 @@ const readStateOrThrow = (d = katalog) => {
   ) {
     throw new ArkivFel(`${statePath(d)} har ett stopp-fält som varken är null eller ett objekt`)
   }
+  // `design` är null, saknat (äldre arkiv) eller ett objekt { path, file,
+  // sha256, spec_sha256, date } skrivet av add-design. Allt annat är trasigt:
+  // nasta-steg och precheck --design läser fältet, och en sträng där hade
+  // tyst lästs som "designad".
+  if (
+    parsed.design !== undefined &&
+    parsed.design !== null &&
+    (typeof parsed.design !== 'object' || Array.isArray(parsed.design))
+  ) {
+    throw new ArkivFel(`${statePath(d)} har ett design-fält som varken är null eller ett objekt`)
+  }
+  // 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
+  // sträng med bokstäver där hade tyst lästs som "synkad".
+  if (
+    parsed.split !== null &&
+    typeof parsed.split === 'object' &&
+    parsed.split.gid !== undefined &&
+    parsed.split.gid !== null &&
+    (typeof parsed.split.gid !== 'string' || !GID_RE.test(parsed.split.gid))
+  ) {
+    throw new ArkivFel(`${statePath(d)} har ett split.gid som inte är ett Asana-gid (bara siffror)`)
+  }
+  // ADR-0144 beslut 5: `umbrella` är saknat eller ett objekt { date, sha256 }
+  // skrivet av paraply. Allt annat är trasigt, samma regel som för stopp och
+  // design.
+  if (
+    parsed.umbrella !== undefined &&
+    parsed.umbrella !== null &&
+    (typeof parsed.umbrella !== 'object' || Array.isArray(parsed.umbrella))
+  ) {
+    throw new ArkivFel(`${statePath(d)} har ett umbrella-fält som varken är null eller ett objekt`)
+  }
   return parsed
 }
 
@@ -529,9 +580,10 @@ const isKnownFile = (file) => FILE_PATTERNS.some((re) => re.test(file))
  * spec-v1-avvisad.md-raden) bär tomt underlag_sha256, en
  * impact(-superseded)-rad bär bara spec.md, en pricing-rad bär båda.
  */
-const underlagFor = (file) => {
+const underlagFor = (file, d = katalog) => {
   if (SPEC_RE.test(file)) return []
-  if (IMPACT_RE.test(file)) return ['spec.md']
+  if (IMPACT_RE.test(file))
+    return existsSync(path.join(d, 'design.md')) ? ['spec.md', 'design.md'] : ['spec.md']
   return ['spec.md', 'impact.md']
 }
 
@@ -566,11 +618,27 @@ const SCORE_STOP = [
  *  (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. */
+ *  literala källor som kan bära ett stopp UTAN scorer. Den fjärde är ett
+ *  mönster: ett designdokument som add-design vägrade på "## Spec conflicts"
+ *  kopieras in som kvitto (design-avvisad-<datum>.md, `-2` vid kollision) och
+ *  stoppar som TILLBAKA_TILL_SPEC eller ESKALERA (designa steg 5,
+ *  slutgranskning I1). 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']
+const DESIGN_AVVISAD_RE = /^design-avvisad-\d{4}-\d{2}-\d{2}(-\d+)?\.md$/
+
+/** Ett designkonfliktstopp (slutgranskning I2): assessorn fann designen
+ *  obyggbar, motsägelseraden i impact.md börjar med `design conflict:` och
+ *  bedöm bokförde den texten som `orsak`. En omdesign besvarar det, inte en
+ *  respec: nasta-steg routar till designa och add-design nollar stoppet.
+ *  Delad av de två så de aldrig kan läsa samma stopp olika. */
+const arDesignkonflikt = (stopp) =>
+  stopp?.kalla === 'impact.md' &&
+  stopp.utfall === 'TILLBAKA_TILL_SPEC' &&
+  typeof stopp.orsak === 'string' &&
+  /^design conflict:/i.test(stopp.orsak.trim())
 
 /** 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
@@ -592,12 +660,14 @@ const PROVENIENS_REFERENSER = [
   'skills/request/SKILL.md',
 ]
 
-/** Kända statusvärden (SKILL.md: "spec_draft | spec_synced | assessed |
- *  priced | guard_run"). `set-status` skrev tidigare VILKEN STRÄNG SOM HELST
- *  rakt in i state.json — inklusive en flaggformad sträng om anroparen råkat
- *  glömma statusvärdet (`set-status <katalog> --nagot-annat`), vilket hade
- *  gett en tyst, obegriplig status i stället för ett fel. */
-const STATUSAR = ['spec_draft', 'spec_synced', 'assessed', 'priced', 'guard_run']
+/** Kända statusvärden (SKILL.md: "spec_draft | spec_synced | designed |
+ *  assessed | priced | guard_run"). `designed` (designa, spec 2026-09-24)
+ *  ligger mellan godkännandet och analysen: add-design sätter det. `set-status` skrev
+ *  tidigare VILKEN STRÄNG SOM HELST rakt in i state.json — inklusive en
+ *  flaggformad sträng om anroparen råkat glömma statusvärdet (`set-status
+ *  <katalog> --nagot-annat`), vilket hade gett en tyst, obegriplig status i
+ *  stället för ett fel. */
+const STATUSAR = ['spec_draft', 'spec_synced', 'designed', 'assessed', 'priced', 'guard_run']
 
 /** Körningsstatus i experiment.json, exakt de literaler SKILL.md:s
  *  återupptagningsregel och svep.mjs läser. */
@@ -669,6 +739,7 @@ const skelett = (requestId, { bundle, split } = {}) => ({
   stopp: null,
   respec_varv: 0,
   coverage_post: null,
+  design: null,
   runs: [],
 })
 
@@ -1478,6 +1549,7 @@ if (cmd === 'add-run') {
   // 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
+  // eller ett vägrat designdokuments kvitto (design-avvisad-<datum>.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'])
@@ -1488,8 +1560,11 @@ if (cmd === 'add-run') {
     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(', ')})`)
+  const arDesignKvitto = DESIGN_AVVISAD_RE.test(kalla)
+  if (!STOPP_KALLOR.includes(kalla) && !arDesignKvitto) {
+    console.error(
+      `okänd --kalla: ${kalla} (giltiga: ${STOPP_KALLOR.join(', ')}, design-avvisad-<datum>.md)`,
+    )
     process.exit(2)
   }
   const kallaPath = path.join(katalog, kalla)
@@ -1515,6 +1590,27 @@ if (cmd === 'add-run') {
       )
       process.exit(2)
     }
+  } else if (arDesignKvitto) {
+    // Slutgranskning I1: kvittot är det vägrade designdokumentet självt, och
+    // bara ett dokument med minst en konflikt under "## Spec conflicts" är ett
+    // stopp. Statusen rörs inte, som för spec.md: designen bokfördes aldrig.
+    const konflikter = specConflicts(text)
+    if (konflikter === null || konflikter.length === 0) {
+      console.error(`${kallaPath} bär inga konflikter under "## Spec conflicts", kan inte stoppas`)
+      process.exit(2)
+    }
+    if (!['TILLBAKA_TILL_SPEC', 'ESKALERA'].includes(utfall)) {
+      console.error(
+        `en designkonflikt 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 if (kalla === 'granskarblock.md') {
     // ADR-0118: bara ett ja på raden Prisavgörande öppet val är ett stopp.
     if (prisavgorandeVal(text) === null) {
@@ -1553,10 +1649,21 @@ if (cmd === 'add-run') {
 
   const lockPath = acquireLock()
   let skrivet = false
+  let ersatter = false
   try {
     const state = readStateOrThrow()
     const befintlig = state.stopp ?? null
-    if (befintlig !== null) {
+    if (befintlig !== null && arDesignkonflikt(befintlig) && arDesignKvitto) {
+      // Slutgranskning omgång 2 (F1): omdesignen som designkonfliktstoppet
+      // routade till vägrades på "## Spec conflicts", så specen är problemet
+      // och spec-vägen vinner. Kvittot ersätter stoppet; utan det föll stopp
+      // på write-once nedan och nasta-steg sa designa igen, en återvändsgränd.
+      // Statusen rörs inte, orsaksreglerna är kvittots egna ovan.
+      state.stopp = { utfall, kalla, date: today(), ...(orsak ? { orsak } : {}) }
+      writeStateOrThrow(state)
+      skrivet = true
+      ersatter = true
+    } else 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.
@@ -1570,9 +1677,10 @@ if (cmd === 'add-run') {
       }
     } 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.
+      // impact.md: posten gick genom bedöm och är analyserad. spec.md,
+      // granskarblock.md och ett designkvitto: kandidaten, det prisavgörande
+      // valet eller den vägrade designen passerade aldrig bedöms grind,
+      // statusen står kvar som förut.
       if (kalla === 'impact.md') state.status = 'assessed'
       writeStateOrThrow(state)
       skrivet = true
@@ -1587,29 +1695,26 @@ if (cmd === 'add-run') {
   }
   releaseLock(lockPath)
   console.log(
-    skrivet ? `OK: stopp ${utfall} ur ${kalla}` : `OK: stopp ${utfall} ur ${kalla} oförändrat`,
+    ersatter
+      ? `OK: stopp ${utfall} ur ${kalla} (ersätter designkonflikten ur impact.md)`
+      : 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.
+  // analysen, designen, godkännandet, domarna och stoppet. 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
   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++
-    }
+    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++
     const nytt = { ...state }
     if (nytt.status !== 'spec_draft') {
       nytt.status = 'spec_draft'
@@ -1623,10 +1728,14 @@ if (cmd === 'add-run') {
       nytt.granskarutslag = []
       antal++
     }
-    if (nytt.stopp !== null) {
+    if (nytt.stopp !== null && nytt.stopp !== undefined) {
       nytt.stopp = null
       antal++
     }
+    if (nytt.design !== null && nytt.design !== undefined) {
+      nytt.design = 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
@@ -1644,6 +1753,93 @@ if (cmd === 'add-run') {
   }
   releaseLock(lockPath)
   console.log(`OK: respec (${antal} ändringar)`)
+} 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
+  // designed. Ingen runs-rad: designen är ingen agentdispatch, kvittot är
+  // fältet självt, write-once per version (en ny version lägger undan den
+  // gamla som design-superseded-<datum>.md, se laggUndan).
+  avvisaOkandaFlaggor('add-design', ['file'])
+  const fil = requireFlag('file')
+  const lockPath = acquireLock()
+  let kvitto
+  try {
+    const state = readStateOrThrow()
+    kvitto = laggTillDesign(state, fil)
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  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 === '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
+  // stället för att skapa en till. Write-once: samma gid igen är en no-op,
+  // ett annat gid vägras (en del har en deluppgift, aldrig två).
+  avvisaOkandaFlaggor('set-split-gid', ['gid'])
+  const gid = requireFlag('gid')
+  if (!GID_RE.test(gid)) {
+    console.error(`--gid måste vara ett Asana-gid (bara siffror), fick "${gid}"`)
+    process.exit(2)
+  }
+  const lockPath = acquireLock()
+  let oforandrat = false
+  try {
+    const state = readStateOrThrow()
+    const split = state.split
+    if (split === null || typeof split !== 'object' || split.parent == null)
+      throw new ArkivFel(
+        `${statePath()} har ingen split (split.parent saknas), set-split-gid gäller bara en delningsdel`,
+      )
+    if (split.gid != null && split.gid !== gid)
+      throw new ArkivFel(
+        `${statePath()} har redan split.gid "${split.gid}" som skiljer sig från "${gid}"; en del har en deluppgift, aldrig två`,
+      )
+    if (split.gid === gid) oforandrat = true
+    else writeStateOrThrow({ ...state, split: { ...split, gid } })
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  console.log(oforandrat ? `OK: split-gid ${gid} oförändrat` : `OK: split-gid ${gid}`)
+} 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),
+  // paraplyet kopieras in byteidentiskt, titeln följer dess rubrik och
+  // state.umbrella bokför datum och hash. Godkännande, design, runs, stopp och
+  // delarna rörs inte: delarna bär sina ärvda kopior av den godkända specen,
+  // den som deras assessorer körde mot.
+  avvisaOkandaFlaggor('paraply', ['file'])
+  const fil = requireFlag('file')
+  const lockPath = acquireLock()
+  let resultat
+  try {
+    const state = readStateOrThrow()
+    resultat = laggInParaply(state, fil)
+  } catch (e) {
+    releaseLock(lockPath)
+    if (e instanceof ArkivFel) {
+      console.error(e.message)
+      process.exit(2)
+    }
+    throw e
+  }
+  releaseLock(lockPath)
+  // F9: specForms varningar (samma form som precheck.mjs) skrivs ut före
+  // OK-raden i stället för att tystas.
+  for (const w of resultat.varningar) console.log(`VARNING: ${w}`)
+  console.log(`OK: paraply ${resultat.umbrella.sha256}`)
 } 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
@@ -1700,7 +1896,16 @@ if (cmd === 'add-run') {
           ? 'kandidat (spec.md)'
           : state.stopp.kalla === 'granskarblock.md'
             ? 'prisavgörande val (granskarblock.md)'
-            : 'motsägelse (impact.md)'
+            : DESIGN_AVVISAD_RE.test(state.stopp.kalla ?? '')
+              ? `designkonflikt (${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.
+    const delning = delningslage(d)
+    if (delning !== null) {
+      const text = `${delning.klara} av ${delning.av} delar prissatta`
+      anm = anm === SAKNAS ? text : `${anm}; ${text}`
     }
     if (taeckning) anm = anm === SAKNAS ? taeckning : `${anm}; ${taeckning}`
     return `| ${[post, poang, utfall, konfidens, anm].map(cell).join(' | ')} |`
@@ -1733,6 +1938,7 @@ if (cmd === 'add-run') {
       post,
       antalDelar: arBuntRot ? direktaDelar.length : 0,
       scorerUtfall: gallandeScorerUtfall(state, d),
+      delning: delningslage(d),
     })
     return `| ${[post, star, vantar, nasta].map(cell).join(' | ')} |`
   }
@@ -1751,7 +1957,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, 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, set-split-gid, paraply, bluf, nasta-steg, kalibrering, experiment)',
   )
   process.exit(2)
 }
@@ -1826,6 +2032,196 @@ function delKataloger(dir) {
     .flatMap((d) => [d, ...delKataloger(d)])
 }
 
+/** 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).
+ *  Returnerar true när en fil flyttades. */
+function laggUndan(d, bas) {
+  const fil = path.join(d, `${bas}.md`)
+  if (!existsSync(fil)) return false
+  const stam = path.join(d, `${bas}-superseded-${today()}`)
+  let mal = `${stam}.md`
+  for (let n = 2; existsSync(mal); n++) mal = `${stam}-${n}.md`
+  try {
+    renameSync(fil, mal)
+  } catch (e) {
+    throw new ArkivFel(`kunde inte döpa om ${fil} till ${mal}: ${e.message}`)
+  }
+  return true
+}
+
+/** 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
+ *  gissa en rot. Inget git-anrop: scripten är node-inbyggt bara. */
+function repoRotFor(d) {
+  let cur = path.resolve(d)
+  for (;;) {
+    if (path.basename(cur) === '.haus-workflow') return path.dirname(cur)
+    const parent = path.dirname(cur)
+    if (parent === cur) return null
+    cur = parent
+  }
+}
+
+/** add-design: vägransreglerna i ordning (rot, fil, inneslutning, arkivet,
+ *  frontmatter, spec-hash, konflikter, status, stopp), 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. */
+function laggTillDesign(state, fil) {
+  const rot = repoRotFor(katalog)
+  if (rot === null)
+    throw new ArkivFel(
+      `${katalog} ligger inte under någon .haus-workflow-katalog, kan inte avgöra repo-roten`,
+    )
+  let real
+  try {
+    real = realpathSync(path.resolve(fil))
+  } catch (e) {
+    throw new ArkivFel(`kan inte läsa ${fil}: ${e.message}`)
+  }
+  const rotReal = realpathSync(rot)
+  if (!real.startsWith(rotReal + path.sep))
+    throw new ArkivFel(`${real} ligger utanför repo-roten ${rotReal}`)
+  // Slutgranskning M3: arkivet är aldrig designdokumentets hem. Arkivets egen
+  // design.md som --file hade lagts undan av laggUndan innan kopian, som då
+  // föll på en fil som inte längre fanns.
+  if (real.startsWith(path.join(rotReal, '.haus-workflow') + path.sep))
+    throw new ArkivFel(
+      `${real} ligger under .haus-workflow, designdokumentet ska ligga i repot, aldrig i arkivet`,
+    )
+  let text
+  try {
+    text = readFileSync(real, 'utf8')
+  } catch (e) {
+    throw new ArkivFel(`kan inte läsa ${real}: ${e.message}`)
+  }
+  const fm = designFrontmatter(text)
+  if (fm === null || !fm.request_id) throw new ArkivFel(`${real}: frontmattern saknar request_id`)
+  const id = katalogId(state, katalog)
+  if (fm.request_id !== id)
+    throw new ArkivFel(`${real}: request_id "${fm.request_id}" är inte katalogens id "${id}"`)
+  const specFil = path.join(katalog, 'spec.md')
+  let specHash
+  try {
+    specHash = markerStrippedSha256(specFil)
+  } catch (e) {
+    throw new ArkivFel(`kan inte hasha ${specFil}: ${e.message}`)
+  }
+  if (fm.spec_sha256 !== specHash)
+    throw new ArkivFel(
+      `${real}: spec_sha256 "${fm.spec_sha256 ?? ''}" är inte nuvarande spec.md (${specHash}), ` +
+        'designen gjordes mot en annan spec',
+    )
+  const konflikter = specConflicts(text)
+  if (konflikter === null) throw new ArkivFel(`${real}: sektionen "## Spec conflicts" saknas`)
+  if (konflikter.length > 0)
+    throw new ArkivFel(
+      `${real}: "## Spec conflicts" är inte none (${konflikter.length}): kunddialog, respec och ny speca (ADR-0118)`,
+    )
+  // Slutgranskning M4: en prissatt post designas inte om, analysen och
+  // poängen står på den bokförda designen.
+  if (state.status === 'priced' || state.status === 'guard_run')
+    throw new ArkivFel(
+      `${statePath()} har status ${state.status}, en prissatt post designas inte om utan respec`,
+    )
+  const stopp = state.stopp ?? null
+  if (stopp !== null && !arDesignkonflikt(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`,
+    )
+  laggUndan(katalog, 'design')
+  const mal = path.join(katalog, 'design.md')
+  try {
+    copyFileSync(real, mal)
+  } catch (e) {
+    throw new ArkivFel(`kunde inte kopiera ${real} till ${mal}: ${e.message}`)
+  }
+  const design = {
+    path: real,
+    file: 'design.md',
+    sha256: markerStrippedSha256(mal),
+    spec_sha256: specHash,
+    date: today(),
+  }
+  // Ett designkonfliktstopp besvaras av just den här designen (I2); det är
+  // det enda stopp som når hit, alla andra vägrades ovan. Analysen som fann
+  // designen obyggbar läggs undan med stoppet (slutgranskning omgång 2, F3):
+  // 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
+  writeStateOrThrow({
+    ...state,
+    design,
+    status: 'designed',
+    ...(stopp !== null ? { stopp: null } : {}),
+  })
+  return { design, impactUndanlagd }
+}
+
+/** paraply (ADR-0144 beslut 5): vägransreglerna i ordning (delningsdel,
+ *  delningsrot, godkännande, läsbar fil, specens form enligt specForm,
+ *  titelrad), sedan undanläggning, kopia och state. Beslutslåset (Decision)
+ *  är synkens sak, inte arkivets. Titeln läses med forstaRubrik, samma regel
+ *  som add-run använder för spec.md (#495). Filen läses som bytes före
+ *  undanläggningen, så även katalogens egen spec.md går att peka ut. Kastar
+ *  ArkivFel. Returnerar { umbrella: kvittot { date, sha256 }, varningar:
+ *  specForms varningar, tryckta av anroparen som VARNING-rader före
+ *  OK-raden (F9) }. */
+function laggInParaply(state, fil) {
+  if (state.split?.parent != null)
+    throw new ArkivFel(
+      `${statePath()} är en delningsdel (split.parent ${state.split.parent}), paraply gäller bara föräldern`,
+    )
+  // Slutgranskning F1: förälderns spec.md får inte skrivas om innan del-N/
+  // finns, annars ärver varje del (bedöm-valet 1) paraplyet i stället för
+  // specen den prissattes mot.
+  if (delningslage(katalog) === null)
+    throw new ArkivFel(
+      `${statePath()} är ingen delningsrot (inga del-N/ med split.parent), paraply gäller bara en uppdelad förälder`,
+    )
+  if (state.approval == null)
+    throw new ArkivFel(`${statePath()} saknar approval, paraply skriver bara om en godkänd spec`)
+  let bytes
+  try {
+    bytes = readFileSync(path.resolve(fil))
+  } catch (e) {
+    throw new ArkivFel(`kan inte läsa ${fil}: ${e.message}`)
+  }
+  const text = bytes.toString('utf8')
+  const namn = path.basename(fil)
+  const form = specForm(text, namn)
+  const fel = [
+    ...form.brister,
+    ...form.kandidater.map((k) => `${namn}: kandidatformen (${k}) är ingen paraplyspec`),
+  ]
+  if (fel.length > 0)
+    throw new ArkivFel(
+      `${fil} klarar inte specens formkontroll:\n${fel.map((f) => `- ${f}`).join('\n')}`,
+    )
+  const titel = forstaRubrik(text)
+  if (titel === null || SPEC_HEADINGS.some((r) => r.sv === titel || r.en === titel))
+    throw new ArkivFel(
+      `${fil} saknar titelrad före "Problem": paraplyets titel är det ändrade läget för helheten`,
+    )
+  laggUndan(katalog, 'spec')
+  const mal = path.join(katalog, 'spec.md')
+  try {
+    writeFileSync(mal, bytes)
+  } catch (e) {
+    throw new ArkivFel(`kunde inte skriva ${mal}: ${e.message}`)
+  }
+  const umbrella = { date: today(), sha256: markerStrippedSha256(mal) }
+  writeStateOrThrow({ ...state, title: titel, umbrella })
+  return { umbrella, varningar: form.varningar }
+}
+
 /** 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
@@ -1838,6 +2234,43 @@ function gallandeScorerUtfall(state, d) {
   return { fil, outcome: readPricingFileOrThrow(fil, d).outcome ?? null }
 }
 
+/** Delningsläget för en katalog (ADR-0144 beslut 4 och 6): null när ingen
+ *  direkt del-N bär split.parent (ingen delningsrot), annars { klara, av }.
+ *  `av` är delarnas split.of: arkivet vet hur många delar det finns även när
+ *  alla kataloger inte skapats än. `klara` räknar delarna som delKlar godtar.
+ *  Delar som är oeniga om split.of, ett split.of som inte är ett heltal >= 1
+ *  eller fler delkataloger än split.of är ett arkivfel, aldrig en gissning.
+ *  Delad av nasta-steg och bluf så de två aldrig räknar olika. */
+function delningslage(d) {
+  const delar = delKataloger(d)
+    .filter((p) => path.dirname(p) === d)
+    .map((p) => ({ p, state: readStateOrThrow(p) }))
+    .filter(({ state }) => state.split?.parent != null)
+  if (delar.length === 0) return null
+  const antal = [...new Set(delar.map(({ state }) => state.split.of))]
+  if (antal.length > 1)
+    throw new ArkivFel(
+      `${d}: delarna är oeniga om split.of (${antal.join(', ')}), en delning har ett antal delar`,
+    )
+  const av = antal[0]
+  if (!Number.isInteger(av) || av < 1)
+    throw new ArkivFel(`${d}: delarnas split.of är inte ett heltal >= 1 (fick ${av})`)
+  if (delar.length > av) throw new ArkivFel(`${d}: ${delar.length} delkataloger men split.of ${av}`)
+  return { klara: delar.filter(({ p, state }) => delKlar(state, p)).length, av }
+}
+
+/** En del är klar när den är priced (eller guard_run, som bara nås efter
+ *  priced), eller står på scorerns OVER_SKALAN med status assessed, utan stopp
+ *  och utan olyft spärr: exakt de delar vars egen nasta-steg-rad är
+ *  deluppgiftsraden (ADR-0144 beslut 4, en OVER_SKALAN-del får en deluppgift
+ *  utan Score och räknas som prissatt). */
+function delKlar(state, d) {
+  if (state.status === 'priced' || state.status === 'guard_run') return true
+  if (state.status !== 'assessed' || state.stopp != null) return false
+  if (sparrSkal(state).length > 0) return false
+  return gallandeScorerUtfall(state, d)?.outcome === 'OVER_SKALAN'
+}
+
 /** 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.
@@ -1850,8 +2283,13 @@ function gallandeScorerUtfall(state, d) {
  *  | 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 ur impact.md | bedöm steg 3 "starts with `design conflict:` … the Closing    |
+ *  | 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 TILLBAKA_TILL_SPEC              | speca steg 6 (ADR-0118) "När valet avgjorts skrivs svaret     |
- *  |                                       | under `## Avgjorda val` …, sedan `respec` och ny dispatch"     |
+ *  |                                       | under `## Avgjorda val` …, sedan `respec` och ny dispatch";   |
+ *  |                                       | designa steg 5, ett kvitto design-avvisad-<datum>.md          |
  *  | 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                            | The experiment area: `experiments/`: "kan inte förväxlas     |
@@ -1859,23 +2297,36 @@ function gallandeScorerUtfall(state, d) {
  *  | 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"        |
+ *  | spec_draft/spec_synced med approval,  | bedöm-grinden 1b: en del ärver förälderns design, grindas    |
+ *  | split.parent satt                     | aldrig                                                        |
+ *  | spec_draft/spec_synced med approval,  | designa steg 5: designen är bokförd, bara statusen släpar     |
+ *  | design satt                           | (t.ex. en sync efter add-design) → bedöm, aldrig designa igen |
+ *  | spec_draft/spec_synced med approval,  | designa-grinden: "Only `✅ Spec ok` … lets it through";       |
+ *  | ingen design                          | Closing ISÄR-raden "with `approval` set → `designa`"         |
+ *  | designed                              | bedöm grind 1b: "`DESIGN: saknas` or any BRIST … refuse";    |
+ *  |                                       | 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 (⚖️)       |
  *  | 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                         |
  *  | 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, 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                     |
  *  | 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 }) {
+ *  scorerns stopputfall, olyft OLIKA, `respec_varv` > 0, manuell approval,
+ *  designfältet (`design <datum>`) och experimentmarkören. `delning` är
+ *  delningslage för katalogen (null utom på en delningsrot). Funktionen är
+ *  ren (ingen I/O) så tabellen går att testa rad för rad. */
+function nastaStegFor(state, { post, antalDelar, scorerUtfall, delning = null }) {
   const status = state.status
   const gid = state.request_id ?? '<gid>'
   const adress = state.request_id ?? post
@@ -1895,6 +2346,7 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall }) {
     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.design ? `design ${state.design.date}` : null,
     state.experiment === true ? 'experiment' : null,
   ]
     .filter((v) => v !== null)
@@ -1906,6 +2358,17 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall }) {
       'kunddialog',
       'kunddialog; lägg posten på brädan via request-sync (🔍) om den saknas där, bedöm hoppar över den',
     )
+  // ADR-0144 beslut 3 och 6: en prissatt del, eller en OVER_SKALAN-del, blir
+  // en deluppgift under föräldern. Med split.gid satt är den synkad; utan
+  // säger raden sync och set-split-gid, samma "om inte gjort" som för en
+  // prissatt post.
+  const deluppgift = (utanScore) => {
+    const score = utanScore ? ' utan Score' : ''
+    const offert = utanScore ? ', offereras separat' : ''
+    return state.split?.gid
+      ? `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}`
+  }
   const tillbakaTillSpec = (val) =>
     rad(
       `avgör valet: ${val}`,
@@ -1917,6 +2380,9 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall }) {
   if (stopp) {
     const val = stopp.orsak ?? stopp.kalla
     if (stopp.utfall === 'KONCEPT' || stopp.utfall === 'DIAGNOS') return kunddialog()
+    // 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}`)
     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')
@@ -1924,8 +2390,19 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall }) {
   if (state.experiment === true)
     return rad('inget (experiment, når aldrig Asana)', 'utvärdera rapport')
   const godkand = state.approval !== null && state.approval !== undefined
+  const delAvSplit = state.split?.parent !== null && state.split?.parent !== undefined
   if (status === 'spec_draft' || status === 'spec_synced') {
-    if (godkand) return rad('körning av bedöm', `bedöm ${adress}`)
+    // Designa (spec 2026-09-24): en godkänd post går till designa, aldrig
+    // direkt till bedöm. Hashkontrollen är prechecks jobb, inte tabellens.
+    // En delningsdel (split.parent satt) ärver förälderns design (Ruling B):
+    // den grindas aldrig i designa-grinden, utan går direkt till bedöm. En
+    // post med designen bokförd men statusen kvar (slutgranskning M6) går
+    // också till bedöm: designa igen hade frågat om en design som finns.
+    if (godkand) {
+      if (delAvSplit) return rad('körning av bedöm', `bedöm ${adress}`)
+      if (state.design) return rad('körning av bedöm', `bedöm ${adress}`)
+      return rad('körning av designa', `designa ${adress}`)
+    }
     return status === 'spec_draft'
       ? rad(
           'godkännande av spec på brädan',
@@ -1933,14 +2410,28 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall }) {
         )
       : rad('godkännande av spec på brädan', godkannEller)
   }
+  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)`)
     if (scorerStopp) {
       const o = scorerStopp.outcome
-      if (o === 'DELA_UPP')
+      if (o === 'DELA_UPP') {
+        // ADR-0144 beslut 4 och 6: delningsroten räknar sina delar. Så länge
+        // någon återstår står föräldern kvar på ✅ Spec ok; när varje del är
+        // 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)`)
+        if (delning !== null)
+          return 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')
-        return rad('manuell offert', 'offereras separat, delas aldrig vidare')
+        return delAvSplit
+          ? rad('manuell offert', deluppgift(true))
+          : 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(
@@ -1953,11 +2444,17 @@ function nastaStegFor(state, { post, antalDelar, scorerUtfall }) {
       `sync till brädan (request-sync ⚖️), sedan ${godkannEller}`,
     )
   }
-  if (status === 'priced')
+  if (status === 'priced') {
+    if (delAvSplit)
+      return rad(
+        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>`,
     )
+  }
   if (status === 'guard_run') return rad('inget', 'inget')
   return rad('–', '–', `okänt läge: ${status}`)
 }