@haus-tech/haus-workflow 5.12.1 → 6.1.0

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

@@ -19,19 +19,41 @@
  *                    --request-id <gid eller slug> --modell <modell|default>
  *                    [--claude <kommando>] [--delar-parallellt 2]
  *                    [--steg-timeout 1800000] [--effort <low|medium|high|xhigh|max|default>]
+ *                    [--sprak <svenska|engelska>] [--design-mode <draft|intervju>]
+ *   node korning.mjs --katalog <abs körningskatalog> --post <abs postkatalog> --repo-rot <abs>
+ *                    --modell <modell|default> [--startare <pid>] [samma valfria flaggor]
  *
- * Läser `<exp>/experiment.json` (`sprak` OBLIGATORISK, ADR-0114: språket
- * gissas aldrig), `<exp>/onskemal.md`, `<exp>/kallmanifest.md` och `<exp>/design.md`
- * (valfri). Skriver `steg/*.json`, spec/impact/prisfiler i körningskatalogen
- * och `korning.json`;
+ * Experimentläget (`--exp`) läser `<exp>/experiment.json` (`sprak` OBLIGATORISK,
+ * ADR-0114: språket gissas aldrig), `<exp>/onskemal.md`, `<exp>/kallmanifest.md`
+ * och `<exp>/design.md` (valfri). Skriver `steg/*.json`, spec/impact/prisfiler i
+ * körningskatalogen och `korning.json`;
  * `experiment.json` och `state.json` rörs BARA via `archive.mjs`.
  *
- * stdout används inte (svep sparar stderr som `stderr.log`). Exit 0 = körningen
+ * Produktionsläget (`--post`, ADR-0155) prissätter en godkänd, designad post ur
+ * dess egen arkivkatalog: `spec.md`, `granskarblock.md`, `kallmanifest.md`
+ * (`SPRÅK:` obligatorisk, eller `--sprak`), `design.md` och `state.json` med
+ * `approval`. Ingen specifier körs; analysen körs bara när den saknas eller
+ * gjordes mot en annan spec eller design. `--katalog` är körningskatalogen
+ * (`<post>/korningar/<stämpel>/`) med `steg/` och `korning.json`; id:t kommer
+ * ur postens state.json, så `--request-id` ges aldrig med `--post`.
+ *
+ * Draft-läget (ADR-0156, `--design-mode draft` eller `experiment.json`
+ * `design_mode: draft`; utan båda `intervju`): saknas designen skriver
+ * request-designer ett utkast och request-design-reviewer läser det före
+ * assessorn, i båda kanalerna. Produktionen bokför utkastet via
+ * `archive.mjs add-design` och granskningen via `add-design-review`;
+ * experimentkanalen skriver `design.md` och `design-review.md` i delen.
+ *
+ * stdout används inte i experimentläget (svep sparar stderr som `stderr.log`);
+ * produktionsläget skriver en enda rad `STATUS: <…>` för en människa. Exit 0 = körningen
  * gick igenom (status `klar` sätts av svep), 1 = minst en del blev ofärdig,
  * 2 = användningsfel, 130 = avbruten med SIGTERM eller SIGINT.
  *
  * SIGTERM och SIGINT dödar varje pågående `claude`-process, skriver
- * `korning.json` ur stegen så långt och lämnar körningen som `ofärdig`. Varje
+ * `korning.json` ur stegen så långt och lämnar körningen som `ofärdig`.
+ * `--startare <pid>` (bara med `--post`) är bedom.mjs:s pid: var 30:e sekund
+ * prövas den, och en död startare avbryter körningen på samma sätt, så en
+ * startare dödad med SIGKILL inte lämnar en körning som ingen äger. Varje
  * agentsteg har dessutom ett väggtidstak (`--steg-timeout`, 30 minuter): ett
  * steg som hänger utan att svara kostar inga turer men blockerar körningen.
  */
@@ -43,6 +65,7 @@ import {
   renameSync,
   rmSync,
   realpathSync,
+  readdirSync,
 } from 'node:fs'
 import { spawn, spawnSync } from 'node:child_process'
 import path from 'node:path'
@@ -53,10 +76,15 @@ import {
   delaSpecifierSvar,
   matcharModell,
   avgorDeps,
+  katalogId,
+  sprakUrManifest,
   schemalagg,
   markerStrippedSha256,
   claudeDir,
   canonicalModel,
+  designMode as designModeFor,
+  specConflicts,
+  sectionLines,
   SPEC_HEADINGS,
   IMPACT_HEADINGS,
   SCORE_OUTCOMES,
@@ -67,7 +95,13 @@ const ARCHIVE = path.join(HAR, 'archive.mjs')
 
 /** Turtak per agent. Taken är generösa men ändliga: en agent som snurrar
  *  kostar pengar tills den dör, och en körning utan tak har inget slut. */
-export const MAX_TURER = { specifier: 120, assessor: 200, scorer: 80 }
+export const MAX_TURER = {
+  specifier: 120,
+  assessor: 200,
+  scorer: 80,
+  designer: 200,
+  designgranskare: 120,
+}
 
 /** Modellen som skriver om kundtextfält i kontrollkedjan (kontroll.mjs
  *  --fixa-kundtext). Pinnad där, upprepad här bara som stegets modell_begard. */
@@ -98,13 +132,29 @@ const VARDEFLAGGOR = [
   'delar-parallellt',
   'steg-timeout',
   'effort',
+  'post',
+  'sprak',
+  'startare',
+  'design-mode',
 ]
+const SPRAKEN = ['svenska', 'engelska']
+/** Designlägena (ADR-0156): `draft` låter designern skriva ett saknat
+ *  designdokument, `intervju` kräver ett ur designa som förut. */
+const DESIGNLAGEN = ['draft', 'intervju']
+const STANDARD_DESIGNLAGE = 'intervju'
 
 export const ANVANDNING = [
   'användning: korning.mjs --katalog <abs k<N>> --exp <abs experimentkatalog> --repo-rot <abs>',
   '                        --request-id <gid eller slug> --modell <modell|default>',
   `                        [--claude <kommando>] [--delar-parallellt ${STANDARD_DELAR_PARALLELLT}]`,
   `                        [--steg-timeout ${STANDARD_STEG_TIMEOUT}] [--effort <${EFFORTNIVAER.join('|')}>]`,
+  `                        [--sprak <${SPRAKEN.join('|')}>]`,
+  '       korning.mjs --katalog <abs körningskatalog> --post <abs postkatalog> --repo-rot <abs>',
+  '                        --modell <modell|default> [--startare <pid>] [samma valfria flaggor] (produktion, ADR-0155)',
+  '(--startare ges bara med --post: startarens pid, en död startare avbryter körningen inom 30 s)',
+  '(--request-id hör till --exp och ges aldrig med --post, id:t kommer ur postens state.json)',
+  '--sprak skriver över språket ur experiment.json eller kallmanifest.md.',
+  `[--design-mode <${DESIGNLAGEN.join('|')}>] skriver över design_mode ur experiment.json; utan båda ${STANDARD_DESIGNLAGE} (ADR-0156).`,
 ].join('\n')
 
 // ---------------------------------------------------------------------------
@@ -132,6 +182,17 @@ export const ANVANDNING = [
  * `Bash(echo:*)`: ett fritt echo är ett skrivkommando i förklädnad.
  */
 const ASSESSOR_GIT = ['ls-files', 'check-ignore', 'log', 'grep', 'status', 'rev-parse']
+const DESIGN_VERKTYG = [
+  'Read',
+  'Grep',
+  'Glob',
+  ...ASSESSOR_GIT.map((sub) => `Bash(git ${sub}:*)`),
+  ...ASSESSOR_GIT.map((sub) => `Bash(rtk git ${sub}:*)`),
+  'Bash(head:*)',
+  'Bash(grep:*)',
+  'Bash(wc:*)',
+  'Bash(ls:*)',
+]
 export const AGENT_VERKTYG = {
   'request-scorer': ['Read', 'Skill'],
   'request-specifier': ['Read', 'Grep', 'Glob', 'Skill'],
@@ -148,6 +209,9 @@ export const AGENT_VERKTYG = {
     'Bash(wc:*)',
     'Bash(ls:*)',
   ],
+  // ADR-0156: assessorns läsande Bash, utan Skill (ingen av dem laddar en skill).
+  'request-designer': DESIGN_VERKTYG,
+  'request-design-reviewer': DESIGN_VERKTYG,
 }
 
 /** Den pinnade headless-invokationen per agentsteg: agentdefinitionen ur
@@ -286,6 +350,88 @@ export function scorerPrompt({ requestId, delpost, sprak, specPath, impactPath }
   ].join('\n')
 }
 
+/** Designerns prompt (ADR-0156), etiketterna i exakt den ordning
+ *  request-designer.md listar dem. Den ursprungliga förfrågan finns inte
+ *  alltid i arkivet; då står det så, och designern läser aldrig tavlan.
+ *  KONFIG är sökvägen även när filen saknas: agenten läser den om den finns. */
+export function designerPrompt({
+  requestId,
+  specSha,
+  datum,
+  onskemal,
+  spec,
+  granskarblock,
+  manifest,
+  repoRot,
+  deps,
+  sprak,
+  konfigPath,
+}) {
+  const sprakRad = kravSprak(sprak)
+  return [
+    'SPEC:',
+    spec.trim(),
+    '',
+    'GRANSKARBLOCK:',
+    granskarblock.trim(),
+    '',
+    'URSPRUNGLIG FÖRFRÅGAN:',
+    onskemal == null || onskemal.trim() === '' ? '(saknas i arkivet)' : onskemal.trim(),
+    '',
+    `REPO-ROT: ${repoRot}`,
+    `DEPS: ${deps}`,
+    sprakRad,
+    'KÄLLOR:',
+    manifest.trim(),
+    '',
+    `KONFIG: ${konfigPath}`,
+    `ID: ${requestId}`,
+    `SPEC-SHA256: ${specSha}`,
+    `DATUM: ${datum}`,
+    '',
+  ].join('\n')
+}
+
+/** Designgranskarens prompt (ADR-0156 beslut 3), etiketterna i
+ *  request-design-reviewer.md:s ordning. */
+export function designReviewerPrompt({ spec, granskarblock, design, repoRot, deps, sprak }) {
+  const sprakRad = kravSprak(sprak)
+  return [
+    'SPEC:',
+    spec.trim(),
+    '',
+    'GRANSKARBLOCK:',
+    granskarblock.trim(),
+    '',
+    'DESIGN:',
+    design.trim(),
+    '',
+    `REPO-ROT: ${repoRot}`,
+    `DEPS: ${deps}`,
+    sprakRad,
+    '',
+  ].join('\n')
+}
+
+/** En kebab av en rubrik: diakriter strippade (å blir a), gemener, allt som
+ *  inte är a-z eller 0-9 blir ett bindestreck, ihopslaget och trimmat, högst
+ *  60 tecken. En rubrik utan ett enda tecken kvar blir `design`. */
+export const slugAv = (titel) => {
+  const slug = String(titel)
+    .normalize('NFD')
+    .replace(/\p{M}+/gu, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60)
+    .replace(/-+$/, '')
+  return slug === '' ? 'design' : slug
+}
+
+/** Designdokumentets sökväg relativt repo-roten, samma som designa steg 4. */
+export const designFilnamn = ({ datum, requestId, titel }) =>
+  `docs/superpowers/specs/${datum}-${requestId}-${slugAv(titel)}-design.md`
+
 /** Omdispatchen: HELA ursprungsprompten oförändrad plus felraderna ordagrant.
  *  En ny subagent minns inget, enbart felrader utan underlag är obrukbart. */
 export const omdispatchPrompt = (original, felrader, { endastSpec = null } = {}) =>
@@ -320,8 +466,8 @@ const raderEfter = (stdout, rubrikRe) => {
   return i === -1 ? [] : bulletRader(rader.slice(i + 1).join('\n'))
 }
 
-/** precheck.mjs stdout: KANDIDAT, AVVIKELSE, VARNING, sedan OK eller
- *  BRISTER (n) + "- "-rader. */
+/** precheck.mjs stdout: KANDIDAT, AVVIKELSE (+ AVVIKELSE-TEXT), DESIGN,
+ *  VARNING, sedan OK eller BRISTER (n) + "- "-rader. */
 export function tolkaPrecheck(stdout, status) {
   const kandidater = raderMed(stdout, 'KANDIDAT: ')
   const avvikelser = raderMed(stdout, 'AVVIKELSE: ')
@@ -329,6 +475,8 @@ export function tolkaPrecheck(stdout, status) {
     ok: status === 0,
     kandidat: kandidater[0] ?? null,
     avvikelse: avvikelser[0] ?? null,
+    avvikelseText: raderMed(stdout, 'AVVIKELSE-TEXT: ')[0] ?? null,
+    design: raderMed(stdout, 'DESIGN: ')[0] ?? null,
     brister: raderEfter(stdout, /^BRISTER \(\d+\):/),
     varningar: raderMed(stdout, 'VARNING: '),
     prisavgorande: raderMed(stdout, 'PRISAVGORANDE: ')[0] ?? null,
@@ -538,13 +686,24 @@ export const behoverDubbelkorning = (doc) =>
 const logg = (rad) =>
   process.stderr.write(`[korning] ${new Date().toISOString().slice(11, 19)} ${rad}\n`)
 
-const arkiv = (args, ctx) =>
+const arkivSpawn = (args, ctx) =>
   spawnSync(process.execPath, [ARCHIVE, ...args], { encoding: 'utf8', cwd: ctx.repoRot })
-const script = (namn, args, ctx) =>
+const scriptSpawn = (namn, args, ctx) =>
   spawnSync(process.execPath, [path.join(HAR, namn), ...args], {
     encoding: 'utf8',
     cwd: ctx.repoRot,
   })
+/** Varje archive.mjs- och scriptanrop går genom de här två, så ett test kan
+ *  byta ut körningen på ett ställe (`ctx.arkivKor`, `ctx.scriptKor`); main
+ *  sätter dem aldrig. */
+const arkiv = (args, ctx) => {
+  const kor = ctx.arkivKor ?? arkivSpawn
+  return kor(args, ctx)
+}
+const script = (namn, args, ctx) => {
+  const kor = ctx.scriptKor ?? scriptSpawn
+  return kor(namn, args, ctx)
+}
 const felText = (r) => (r.stderr || r.stdout || '').trim() || `exit ${r.status}`
 const idag = () => new Date().toISOString().slice(0, 10)
 const lasFil = (p) => {
@@ -570,10 +729,21 @@ export function tolkaArgv(argv) {
     i++
     enkla[namn] = v
   }
-  const obligatoriska = ['katalog', 'exp', 'repo-rot', 'request-id', 'modell']
+  // Läget (ADR-0155): exakt en av --post (produktion) och --exp (experiment).
+  // Med --post kommer id:t ur postens state.json, så --request-id vore ett
+  // andra svar på samma fråga och vägras i stället för att tyst vinna.
+  const produktion = enkla.post !== undefined
+  if (produktion && enkla.exp !== undefined) return { fel: '--post och --exp utesluter varandra' }
+  if (!produktion && enkla.exp === undefined) return { fel: 'kräver --post eller --exp' }
+  if (produktion && enkla['request-id'] !== undefined)
+    return { fel: '--request-id ges bara med --exp, med --post kommer id:t ur state.json' }
+  if (!produktion && enkla.startare !== undefined) return { fel: '--startare ges bara med --post' }
+  const obligatoriska = ['katalog', 'repo-rot', 'modell', ...(produktion ? [] : ['request-id'])]
   const saknas = obligatoriska.filter((n) => enkla[n] === undefined)
   if (saknas.length > 0) return { fel: `saknar ${saknas.map((n) => `--${n}`).join(', ')}` }
-  const relativa = ['katalog', 'exp', 'repo-rot'].filter((n) => !path.isAbsolute(enkla[n]))
+  const relativa = ['katalog', produktion ? 'post' : 'exp', 'repo-rot'].filter(
+    (n) => !path.isAbsolute(enkla[n]),
+  )
   if (relativa.length > 0)
     return { fel: `${relativa.map((n) => `--${n}`).join(', ')} måste vara absoluta sökvägar` }
   const takText = enkla['delar-parallellt'] ?? String(STANDARD_DELAR_PARALLELLT)
@@ -585,16 +755,33 @@ export function tolkaArgv(argv) {
   const effort = enkla.effort ?? STANDARD_EFFORT
   if (!EFFORTNIVAER.includes(effort))
     return { fel: `--effort måste vara en av ${EFFORTNIVAER.join(', ')} (fick "${effort}")` }
+  if (enkla.sprak !== undefined && !SPRAKEN.includes(enkla.sprak))
+    return { fel: `--sprak måste vara ${SPRAKEN.join(' eller ')} (fick "${enkla.sprak}")` }
+  if (enkla['design-mode'] !== undefined && !DESIGNLAGEN.includes(enkla['design-mode']))
+    return {
+      fel: `--design-mode måste vara ${DESIGNLAGEN.join(' eller ')} (fick "${enkla['design-mode']}")`,
+    }
+  if (
+    enkla.startare !== undefined &&
+    (!/^\d+$/.test(enkla.startare) || Number(enkla.startare) <= 0)
+  )
+    return { fel: `--startare måste vara ett heltal > 0 (fick "${enkla.startare}")` }
   return {
     katalog: enkla.katalog,
-    exp: enkla.exp,
+    exp: enkla.exp ?? null,
+    post: enkla.post ?? null,
     repoRot: enkla['repo-rot'],
-    requestId: enkla['request-id'],
+    requestId: enkla['request-id'] ?? null,
     modell: enkla.modell,
+    sprak: enkla.sprak ?? null,
+    // null betyder "ingen flagga": källans eget värde gäller (experiment.json
+    // design_mode), annars intervju. Samma regel som --sprak.
+    designMode: enkla['design-mode'] ?? null,
     claude: enkla.claude ?? 'claude',
     delarParallellt: Number(takText),
     stegTimeout: Number(timeoutText),
     effort,
+    startare: enkla.startare === undefined ? null : Number(enkla.startare),
   }
 }
 
@@ -607,11 +794,16 @@ export function lasUnderlag(val) {
   } catch (e) {
     return { fel: `kunde inte läsa ${path.join(val.exp, 'experiment.json')}: ${e.message}` }
   }
-  const sprak = experiment?.sprak
+  const sprak = val.sprak ?? experiment?.sprak
   if (sprak !== 'svenska' && sprak !== 'engelska')
     return {
       fel: 'sprak saknas i experiment.json, sätt med archive.mjs experiment --satt sprak=svenska|engelska',
     }
+  const designMode = val.designMode ?? experiment?.design_mode ?? STANDARD_DESIGNLAGE
+  if (!DESIGNLAGEN.includes(designMode))
+    return {
+      fel: `design_mode i experiment.json måste vara ${DESIGNLAGEN.join(' eller ')} (fick "${designMode}")`,
+    }
   const onskemal = lasFil(path.join(val.exp, 'onskemal.md'))
   const manifest = lasFil(path.join(val.exp, 'kallmanifest.md'))
   // Designen är ett valfritt pinnat underlag som manifestet (designa, spec
@@ -632,6 +824,7 @@ export function lasUnderlag(val) {
     manifest,
     design,
     sprak,
+    designMode,
     eskalerad: experiment.eskalerad === true,
     eskaleringsorsak:
       typeof experiment.eskaleringsorsak === 'string' ? experiment.eskaleringsorsak : null,
@@ -639,6 +832,52 @@ export function lasUnderlag(val) {
   }
 }
 
+/** Underlaget i produktionsläget (ADR-0155 beslut 2), ur postens egen
+ *  katalog och aldrig ur experiment.json. Posten måste vara godkänd
+ *  (`approval` satt av bedöm-grinden) och får inte vara en experimentkatalog.
+ *  Språket kommer ur `--sprak` eller manifestets `SPRÅK:`-rad och gissas
+ *  aldrig (ADR-0114, #521). `granskarblock.md`, `kallmanifest.md` och
+ *  `design.md` är valfria; `spec.md` krävs. Designläget är `--design-mode`
+ *  eller intervju (ADR-0156). Den ursprungliga förfrågan till designern
+ *  läses bara ur `onskemal.md` i posten, annars null (prompten säger då att
+ *  den saknas i arkivet). */
+export function lasUnderlagProduktion({ post, repoRot, sprak = null, designMode = null }) {
+  const statefil = path.join(post, 'state.json')
+  let state
+  try {
+    state = JSON.parse(readFileSync(statefil, 'utf8'))
+  } catch (e) {
+    return { fel: `kunde inte läsa ${statefil}: ${e.message}` }
+  }
+  if (state === null || typeof state !== 'object' || Array.isArray(state))
+    return { fel: `${statefil} är inget objekt` }
+  if (state.experiment === true) return { fel: 'experimentkatalog: kör utvärdera' }
+  if (
+    state.approval === null ||
+    typeof state.approval !== 'object' ||
+    Array.isArray(state.approval)
+  )
+    return { fel: 'approval saknas: bedöm-grinden har inte körts (archive.mjs approve)' }
+  const spec = lasFil(path.join(post, 'spec.md'))
+  if (spec === null) return { fel: `${post} saknar spec.md` }
+  const manifest = lasFil(path.join(post, 'kallmanifest.md'))
+  const sprakVald = sprak ?? (manifest === null ? null : sprakUrManifest(manifest))
+  if (sprakVald === null)
+    return { fel: 'SPRÅK saknas i kallmanifest.md: sätt raden eller ge --sprak' }
+  return {
+    state,
+    spec,
+    granskarblock: lasFil(path.join(post, 'granskarblock.md')) ?? '',
+    manifest: manifest ?? 'inga',
+    design: lasFil(path.join(post, 'design.md')),
+    onskemal: lasFil(path.join(post, 'onskemal.md')),
+    designMode: designMode ?? STANDARD_DESIGNLAGE,
+    sprak: sprakVald,
+    deps: avgorDeps(repoRot),
+    requestId: katalogId(state, post),
+  }
+}
+
 /** Orsaken till att ett agentsteg räknas som fallet, eller null. Ordningen är
  *  från grövst till finast: en process som inte startade säger inget om
  *  modellen, en tom text säger inget om innehållet. `tidsgransMs` sätts när
@@ -701,7 +940,13 @@ export function raknaSamtidiga(kor = spawnSync) {
  *  så signalhanteraren kan döda det: en dödad korning.mjs får aldrig lämna
  *  betalda `claude`-processer efter sig. Väggtidstaket (`--steg-timeout`)
  *  dödar ett steg som hänger utan att svara. Anroparen avgör vad ett fallet
- *  steg betyder. */
+ *  steg betyder.
+ *
+ *  `ctx.korAgent` är testsömmen (ADR-0111 beslut 4: inget fejkat `claude`):
+ *  den ersätter BARA processen, får stegets argument och returnerar (eller
+ *  löser) `{ stdout, exitCode }`, processens råa utskrift. Allt efter
+ *  processen är detsamma som i en riktig körning: steg/-filen, tolkningen,
+ *  modellverifieringen och stegposten via `ctx.samla`. main sätter den aldrig. */
 export function korAgent({ agent, modell, prompt, fil, maxTurer, ctx }) {
   return new Promise((los) => {
     const start = Date.now()
@@ -740,6 +985,18 @@ export function korAgent({ agent, modell, prompt, fil, maxTurer, ctx }) {
       if (nekade > 0) logg(`STEG ${fil} ${nekade} nekade verktygsanrop`)
       los({ ...t, exitCode, wall_ms, ok: t.orsak === null })
     }
+    if (ctx.korAgent) {
+      Promise.resolve()
+        .then(() => ctx.korAgent({ agent, modell, prompt, fil, maxTurer, ctx }))
+        .then(
+          (r) => {
+            stdout = String(r?.stdout ?? '')
+            avsluta({ exitCode: r?.exitCode ?? 0 })
+          },
+          (e) => avsluta({ exitCode: null, spawnfel: e?.message ?? String(e) }),
+        )
+      return
+    }
     let barn
     try {
       barn = spawn(ctx.claude, agentArgs({ agent, modell, effort: ctx.effort, maxTurer }), {
@@ -824,11 +1081,13 @@ export const addRunArgs = (dir, rad, effort = STANDARD_EFFORT) => [
   ...(rad.note ? ['--note', rad.note] : []),
   ...(rad.doubleRun ? ['--double-run', rad.doubleRun] : []),
   ...(rad.supersededBy ? ['--superseded-by', rad.supersededBy] : []),
+  ...(rad.repoSha ? ['--repo-sha', rad.repoSha] : []),
 ]
 
 /** En runs-rad. Arkivet är append-only och äger sina egna vägransregler; en
  *  vägrad stämpling loggas men fäller aldrig körningen, kvittot på vad som
- *  hände ligger kvar i steg/. */
+ *  hände ligger kvar i steg/. Anropet går genom `arkiv`, alltså genom
+ *  testsömmen `ctx.arkivKor`. */
 function addRun(dir, rad, ctx) {
   const r = arkiv(addRunArgs(dir, rad, ctx.effort), ctx)
   if (r.status !== 0) logg(`VARNING add-run ${rad.fil}: ${felText(r)}`)
@@ -994,17 +1253,26 @@ function skrivSpec(del, spec, granskarblock, meta, ctx) {
 }
 
 /** Delens namn i loggen och delraderna: sökvägen relativt körningskatalogen,
- *  eller katalognamnet när delen ÄR körningsroten. */
-const delNamn = (ctx, dir) => path.relative(ctx.katalog, dir) || path.basename(dir)
+ *  eller katalognamnet när delen ÄR körningsroten eller ligger utanför den
+ *  (produktionsläget: posten är körningskatalogens förälder, ADR-0155). */
+const delNamn = (ctx, dir) => {
+  const rel = path.relative(ctx.katalog, dir)
+  return rel && !rel.startsWith('..') ? rel : path.basename(dir)
+}
 
 /** Ett precheck-anrop: varningarna loggas, brister och kandidat tolkas, och en
  *  exitkod skild från 0 UTAN tolkbart BRISTER-block är ett fel, aldrig ett
  *  godkänt steg. En grind som failar öppet när den själv kraschar är ingen
  *  grind. */
-function korPrecheck(del, ctx, { impact = false } = {}) {
-  const r = script('precheck.mjs', [del.dir, ...(impact ? ['--impact'] : [])], ctx)
+function korPrecheck(del, ctx, { impact = false, design = false, utkast = null } = {}) {
+  const flaggor = [
+    ...(impact ? ['--impact'] : []),
+    ...(design ? ['--design'] : []),
+    ...(utkast ? ['--design-utkast', utkast, '--repo-rot', ctx.repoRot] : []),
+  ]
+  const r = script('precheck.mjs', [del.dir, ...flaggor], ctx)
   const tolkad = tolkaPrecheck(r.stdout, r.status)
-  const etikett = `precheck${impact ? ' --impact' : ''}`
+  const etikett = ['precheck', ...flaggor].join(' ')
   for (const v of tolkad.varningar) logg(`VARNING ${etikett} ${delNamn(ctx, del.dir)}: ${v}`)
   if (tolkad.ok || tolkad.brister.length > 0) return { ...tolkad, fel: null }
   const svans = (r.stderr || r.stdout || '').trim().split('\n').slice(-3).join(' | ').slice(0, 200)
@@ -1113,13 +1381,323 @@ async function specOmdispatch(del, spec, brister, ctx) {
 /** Designen in i delens katalog som design.md före assessorsteget, så att
  *  add-run hashar den i impact-radens underlag_sha256 och precheck --impact
  *  prövar proveniensen (designa, spec 2026-09-24). Byteidentisk kopia av
- *  ctx.design; utan design skrivs inget och false returneras. */
+ *  ctx.design; utan design skrivs inget och false returneras. I
+ *  produktionsläget ÄR ctx.design postens egen design.md, så en fil som
+ *  redan bär exakt de bytena skrivs aldrig om. */
 export function laggDesignIDel(del, ctx) {
   if (ctx.design == null) return false
-  writeFileSync(path.join(del.dir, 'design.md'), ctx.design)
+  const mal = path.join(del.dir, 'design.md')
+  if (lasFil(mal) !== ctx.design) writeFileSync(mal, ctx.design)
   return true
 }
 
+// ---------------------------------------------------------------------------
+// Draft-läget (ADR-0156): designern skriver, granskaren läser, före assessorn
+// ---------------------------------------------------------------------------
+
+/** En splitdel i produktionen ärver förälderns design och designas aldrig. */
+const arSplitdel = (ctx) => Boolean(ctx.post) && (ctx.state?.split?.parent ?? null) !== null
+
+/** Designern körs bara i draft-läget, på en del som saknar design: ingen
+ *  design i ctx (experimentets pinnade design.md eller postens egen), ingen
+ *  design.md i delen och ingen splitdel. Annars är steget en no-op. */
+const designernGaller = (del, ctx) =>
+  ctx.designMode === 'draft' &&
+  ctx.design == null &&
+  !existsSync(path.join(del.dir, 'design.md')) &&
+  !arSplitdel(ctx)
+
+/** Specens första rubrik, utan #-tecknen; slugen i designa-sökvägen. */
+const forstaRubrikI = (text) => {
+  const m = /^#{1,6}\s+(.+?)\s*#*\s*$/mu.exec(String(text))
+  return m ? m[1] : 'design'
+}
+
+const INTERVJU_RE = /^INTERVJU KRÄVS:\s*(.*)$/u
+
+/** Designern (ADR-0156 beslut 1 och 6): ett agentsteg som skriver ett utkast
+ *  eller svarar `INTERVJU KRÄVS:`. Returnerar `{ status: null }` när ett
+ *  utkast bokfördes (eller steget inte gäller), `stopp` på INTERVJU KRÄVS
+ *  (inget i repot; produktionen skriver kvittot och ESKALERA-stoppet, se
+ *  stoppaIntervju, experimentet bara raden) och på designkonflikter
+ *  (kvittot och stoppet som designa steg 5), `ofärdig` på allt annat. */
+export async function korDesigner(del, ctx) {
+  if (!designernGaller(del, ctx)) return { status: null }
+  const specFil = path.join(del.dir, 'spec.md')
+  const spec = lasFil(specFil)
+  if (spec === null) return { status: 'ofärdig', orsak: 'design: spec.md saknas' }
+  const datum = idag()
+  const prompt = designerPrompt({
+    requestId: ctx.requestId,
+    specSha: markerStrippedSha256(specFil),
+    datum,
+    onskemal: ctx.onskemal ?? null,
+    spec,
+    granskarblock: lasFil(path.join(del.dir, 'granskarblock.md')) ?? 'inget granskarblock',
+    manifest: ctx.manifest,
+    repoRot: ctx.repoRot,
+    deps: ctx.deps,
+    sprak: ctx.sprak,
+    konfigPath: path.join(ctx.repoRot, '.haus-workflow', 'workflow-config.md'),
+  })
+  const res = await korAgent({
+    agent: 'request-designer',
+    modell: ctx.modell,
+    prompt,
+    fil: `steg/1${del.nr}-designer.json`,
+    maxTurer: MAX_TURER.designer,
+    ctx,
+  })
+  if (!res.ok) return { status: 'ofärdig', orsak: `design: ${res.orsak}` }
+  const svar = utanYttreStaket(res.text)
+  const intervju = INTERVJU_RE.exec(svar.trim().split('\n')[0].trim())
+  if (intervju) {
+    const orsak = `intervju krävs: ${intervju[1].trim()}`
+    logg(`STOPP ${delNamn(ctx, del.dir)} ${orsak}`)
+    if (ctx.post) return stoppaIntervju(del, intervju[1].trim(), parseSvansrader(svar).modell, ctx)
+    return { status: 'stopp', orsak }
+  }
+  const dok = parseSvansrader(svar).body.trim() + '\n'
+  return ctx.post ? bokforUtkast(del, dok, datum, spec, ctx) : skrivUtkastIDel(del, dok, ctx)
+}
+
+/** Ett yttre kodstaket runt hela svaret (en första rad med tre eller fler
+ *  backticks och en valfri språktagg, en sista rad med samma staket) tas
+ *  bort, ETT lager; annat lämnas orört. Utan det fick frontmattern null och
+ *  add-design vägrade ett annars giltigt utkast. */
+export const utanYttreStaket = (text) => {
+  const rader = String(text).replace(/\r\n/g, '\n').trim().split('\n')
+  const forsta = /^(`{3,})[\w-]*\s*$/.exec(rader[0] ?? '')
+  if (!forsta || rader.length < 2) return String(text)
+  // Svansraderna (MODELL: m.fl.) kan stå efter staketet; de följer med ut.
+  let slut = rader.length - 1
+  const svans = []
+  while (slut > 0 && /^(MODELL|LÄSTA|AVVIKELSE):|^\s*$/u.test(rader[slut]))
+    svans.unshift(rader[slut--])
+  if (rader[slut].trim() !== forsta[1]) return String(text)
+  return [...rader.slice(1, slut), ...svans].join('\n') + '\n'
+}
+
+/** INTERVJU KRÄVS i produktionen (P4-24): svaret skrivs som kvittot
+ *  design-intervju-kravs-<datum>.md (-2 vid kollision, som
+ *  design-avvisad-<datum>.md) och posten stoppas som ESKALERA på det via
+ *  archive.mjs stopp, så nästa batch inte betalar designern igen. Inget
+ *  skrivs i repot och state.design rörs inte; designa löser stoppet. */
+function stoppaIntervju(del, skal, modell, ctx) {
+  const orsak = `intervju krävs: ${skal}`
+  const kvitto = ledigtNamn(del.dir, `design-intervju-kravs-${idag()}`, '.md')
+  const rader = [`INTERVJU KRÄVS: ${skal}`, ...(modell ? [`MODELL: ${modell}`] : [])]
+  writeFileSync(path.join(del.dir, kvitto), rader.join('\n') + '\n')
+  const s = arkiv(
+    ['stopp', del.dir, '--utfall', 'ESKALERA', '--kalla', kvitto, '--orsak', orsak],
+    ctx,
+  )
+  if (s.status !== 0) return { status: 'ofärdig', orsak: `stopp: ${felText(s)}` }
+  logg(`STOPP ${delNamn(ctx, del.dir)} ESKALERA ur ${kvitto}`)
+  return { status: 'stopp', orsak }
+}
+
+/** Repots formatter före bokföringen (designa steg 5): en format-on-commit
+ *  får aldrig ändra bytes efter add-design. Bara när repot har prettier; ett
+ *  fel är en varning, add-design och precheck --design prövar sedan bytes. */
+function formatera(abs, ctx) {
+  const bin = path.join(ctx.repoRot, 'node_modules', '.bin', 'prettier')
+  if (!existsSync(bin)) return
+  const r = spawnSync(bin, ['--write', abs], { cwd: ctx.repoRot, encoding: 'utf8', timeout: 60000 })
+  if (r.error || r.status !== 0) logg(`VARNING prettier ${abs}: ${r.error?.message ?? felText(r)}`)
+}
+
+/** Produktionen: dokumentet i repot på designa-sökvägen (ett ledigt namn,
+ *  aldrig en överskrivning), formaterat, bokfört med add-design och prövat
+ *  med precheck --design. När add-design vägrar (utom konfliktstoppet) tas
+ *  exakt den fil körningen skrev bort (och de kataloger den skapade, när de
+ *  är tomma), så arbetskopian står som före körningen; det råa svaret under
+ *  steg/ är kvittot. Konfliktstoppet behåller filen, som designa steg 5. Ett
+ *  bokfört utkast tas aldrig bort: state.design pekar då på filen, och en
+ *  BRIST i precheck --design efteråt är ofärdig med filen kvar. */
+function bokforUtkast(del, dok, datum, spec, ctx) {
+  const rel = designFilnamn({ datum, requestId: ctx.requestId, titel: forstaRubrikI(spec) })
+  const katalog = path.dirname(path.join(ctx.repoRot, rel))
+  const skapad = mkdirSync(katalog, { recursive: true }) ?? null
+  const abs = path.join(katalog, ledigtNamn(katalog, path.basename(rel, '.md'), '.md'))
+  writeFileSync(abs, dok)
+  const ofardig = (orsak) => {
+    stadaUtkast(abs, skapad)
+    return { status: 'ofärdig', orsak }
+  }
+  formatera(abs, ctx)
+  const r = arkiv(['add-design', del.dir, '--file', abs], ctx)
+  for (const v of raderMed(r.stderr ?? '', 'VARNING: '))
+    logg(`VARNING add-design ${delNamn(ctx, del.dir)}: ${v}`)
+  if (r.status !== 0) {
+    const text = lasFil(abs) ?? dok
+    const konflikter = specConflicts(text) ?? []
+    if (konflikter.length > 0 && /"## Spec conflicts" är inte none/u.test(r.stderr ?? ''))
+      return stoppaDesignkonflikt(del, text, konflikter, ctx)
+    return ofardig(`add-design: ${felText(r)}`)
+  }
+  logg(`DESIGN ${delNamn(ctx, del.dir)} utkast bokfört: ${path.relative(ctx.repoRot, abs)}`)
+  const p = korPrecheck(del, ctx, { design: true })
+  if (p.fel) return { status: 'ofärdig', orsak: p.fel }
+  if (p.brister.length > 0) return { status: 'ofärdig', orsak: `design: ${bristText(p.brister)}` }
+  return { status: null }
+}
+
+/** Tar bort ett vägrat utkast: filen på sin exakta sökväg, sedan uppåt varje
+ *  katalog som den här körningen skapade (`skapad` är mkdirSync:s första
+ *  skapade katalog, null när alla fanns) så länge den är tom. Ett fel loggas,
+ *  det fäller aldrig körningen. */
+function stadaUtkast(abs, skapad) {
+  try {
+    rmSync(abs, { force: true })
+    if (skapad === null) return
+    for (let d = path.dirname(abs); ; d = path.dirname(d)) {
+      if (readdirSync(d).length > 0) break
+      rmSync(d, { recursive: true, force: true })
+      if (d === skapad) break
+    }
+  } catch (e) {
+    logg(`VARNING kunde inte ta bort det vägrade utkastet ${abs}: ${e.message}`)
+  }
+}
+
+/** Experimentkanalen: utkastet som design.md i delen, prövat med precheck
+ *  --design-utkast (sektionerna och symbolerna, symbolerna i målrepot via
+ *  --repo-rot: delen ligger i arkivets repo). Ett fallet utkast läggs undan
+ *  som design-utkast-avvisad-<datum>.md, så assessorn aldrig läser det. */
+function skrivUtkastIDel(del, dok, ctx) {
+  const konflikter = specConflicts(dok) ?? []
+  if (konflikter.length > 0) return stoppaDesignkonflikt(del, dok, konflikter, ctx)
+  const fil = path.join(del.dir, 'design.md')
+  writeFileSync(fil, dok)
+  const p = korPrecheck(del, ctx, { utkast: fil })
+  if (!p.fel && p.brister.length === 0) {
+    logg(`DESIGN ${delNamn(ctx, del.dir)} utkast skrivet`)
+    return { status: null }
+  }
+  try {
+    renameSync(
+      fil,
+      path.join(del.dir, ledigtNamn(del.dir, `design-utkast-avvisad-${idag()}`, '.md')),
+    )
+  } catch (e) {
+    logg(`VARNING kunde inte lägga undan design.md: ${e.message}`)
+  }
+  return { status: 'ofärdig', orsak: p.fel ?? `design: ${bristText(p.brister)}` }
+}
+
+/** Designkonflikter (designa steg 5): dokumentet kopieras in som kvittot
+ *  design-avvisad-<datum>.md (-2 vid kollision) och posten stoppas på det,
+ *  TILLBAKA_TILL_SPEC eller ESKALERA efter en respec, med konfliktraderna som
+ *  orsak. Dokumentet i repot ligger kvar under sitt eget namn. */
+function stoppaDesignkonflikt(del, text, konflikter, ctx) {
+  const kvitto = ledigtNamn(del.dir, `design-avvisad-${idag()}`, '.md')
+  writeFileSync(path.join(del.dir, kvitto), text)
+  const state = lasJson(path.join(del.dir, 'state.json'))
+  const utfall = (state?.respec_varv ?? 0) >= 1 ? 'ESKALERA' : 'TILLBAKA_TILL_SPEC'
+  const rader = konflikter.map((k) => k.replace(/^[-*]\s+/, ''))
+  const orsak = rader.join('; ')
+  const s = arkiv(['stopp', del.dir, '--utfall', utfall, '--kalla', kvitto, '--orsak', orsak], ctx)
+  if (s.status !== 0) return { status: 'ofärdig', orsak: `stopp: ${felText(s)}` }
+  logg(`STOPP ${delNamn(ctx, del.dir)} ${utfall} ur ${kvitto}`)
+  return { status: 'stopp', orsak: `designkonflikter (${rader.length}): ${orsak}` }
+}
+
+/** Granskarens första rad, `fortsätt`, `stopp` eller null (ett brott). */
+export const tolkaVerdict = (text) => {
+  const forsta = String(text).replace(/\r\n/g, '\n').trimStart().split('\n')[0].trim()
+  return /^VERDICT: (fortsätt|stopp)$/u.exec(forsta)?.[1] ?? null
+}
+const verdictFel = (text) =>
+  `- första raden måste vara "VERDICT: fortsätt" eller "VERDICT: stopp" (fick "${String(text).trimStart().split('\n')[0].trim().slice(0, 80)}")`
+
+/** Första fyndet under `## Findings`, utan listmarkör. */
+const forstaFynd = (text) => {
+  const punkt = (sectionLines(text, 'Findings') ?? [])
+    .map((r) => r.trim())
+    .find((r) => r.startsWith('- ') || r.startsWith('* '))
+  return punkt ? punkt.slice(2).trim() : 'inga fynd angivna'
+}
+
+/** Granskaren körs bara efter ett bokfört utkast: draft-läget, ingen
+ *  splitdel, design.md i delen med `mode: draft`, och ingen granskning än
+ *  (produktionen: state.design satt utan review; experimentet: ingen
+ *  design-review.md i delen). Ett intervjudokument granskas aldrig, och ett
+ *  dokument med ett kvitto (granskarens eller människans godkännande via
+ *  add-design-review) granskas aldrig igen: ett utslag omdispatchas inte
+ *  (P4-23). */
+const granskarenGaller = (del, ctx) => {
+  if (ctx.designMode !== 'draft' || arSplitdel(ctx)) return false
+  const design = lasFil(path.join(del.dir, 'design.md'))
+  if (design === null || designModeFor(design) !== 'draft') return false
+  if (!ctx.post) return !existsSync(path.join(del.dir, 'design-review.md'))
+  const state = lasJson(path.join(del.dir, 'state.json'))
+  return state?.design != null && state.design.review == null
+}
+
+/** Designgranskaren (ADR-0156 beslut 3): ett agentsteg vars första rad är
+ *  `VERDICT: fortsätt|stopp`. Annat är ett scriptbevisat brott: EN
+ *  omdispatch med felraden, sedan ofärdig. Svaret utan svansraden skrivs som
+ *  design-review.md: produktionen i körningskatalogen och via
+ *  add-design-review (MODELL-svansen som --model), experimentet i delen.
+ *  `stopp` stoppar raden med det första fyndet. */
+export async function korDesignReviewer(del, ctx) {
+  if (!granskarenGaller(del, ctx)) return { status: null }
+  const prompt = designReviewerPrompt({
+    spec: lasFil(path.join(del.dir, 'spec.md')) ?? '',
+    granskarblock: lasFil(path.join(del.dir, 'granskarblock.md')) ?? 'inget granskarblock',
+    design: lasFil(path.join(del.dir, 'design.md')),
+    repoRot: ctx.repoRot,
+    deps: ctx.deps,
+    sprak: ctx.sprak,
+  })
+  const bas = `steg/1${del.nr}-design-reviewer`
+  const steg = (p, fil) =>
+    korAgent({
+      agent: 'request-design-reviewer',
+      modell: ctx.modell,
+      prompt: p,
+      fil,
+      maxTurer: MAX_TURER.designgranskare,
+      ctx,
+    })
+  let res = await steg(prompt, `${bas}.json`)
+  if (!res.ok) return { status: 'ofärdig', orsak: `designgranskning: ${res.orsak}` }
+  let verdict = tolkaVerdict(res.text)
+  if (verdict === null) {
+    const felrad = verdictFel(res.text)
+    logg(`OMDISPATCH ${delNamn(ctx, del.dir)} designgranskning: ${felrad.slice(2)}`)
+    res = await steg(omdispatchPrompt(prompt, [felrad]), `${bas}-omdispatch.json`)
+    if (!res.ok) return { status: 'ofärdig', orsak: `designgranskning: ${res.orsak}` }
+    verdict = tolkaVerdict(res.text)
+    if (verdict === null)
+      return { status: 'ofärdig', orsak: `designgranskning: ${verdictFel(res.text).slice(2)}` }
+  }
+  const { body, modell } = parseSvansrader(res.text)
+  const dok = body.trim() + '\n'
+  const mal = path.join(ctx.post ? ctx.katalog : del.dir, 'design-review.md')
+  writeFileSync(mal, dok)
+  if (ctx.post) {
+    const r = arkiv(
+      [
+        'add-design-review',
+        del.dir,
+        '--file',
+        mal,
+        '--verdict',
+        verdict,
+        '--model',
+        modell ?? fakturerad(res.svar, ctx.modell) ?? 'okänd',
+      ],
+      ctx,
+    )
+    if (r.status !== 0) return { status: 'ofärdig', orsak: `add-design-review: ${felText(r)}` }
+  }
+  logg(`DESIGNGRANSKNING ${delNamn(ctx, del.dir)} ${verdict}`)
+  if (verdict === 'stopp') return { status: 'stopp', orsak: `designgranskning: ${forstaFynd(dok)}` }
+  return { status: null }
+}
+
 /** Analysen: ett agentsteg, impact.md med runs-rad, formkontroll med EN
  *  omdispatch, och motsägelse mot specen som stopputfall (ADR-0106). */
 async function korAssessor(del, ctx) {
@@ -1133,7 +1711,9 @@ async function korAssessor(del, ctx) {
     spec,
     granskarblock: lasFil(path.join(del.dir, 'granskarblock.md')) ?? 'inget granskarblock',
     manifest: ctx.manifest,
-    design: ctx.design,
+    // Ett utkast från korDesigner ligger i delen men aldrig i ctx.design (ctx
+    // delas av en bunts delar): det läses ur delens egen design.md.
+    design: ctx.design ?? lasFil(path.join(del.dir, 'design.md')),
   })
   const fil = `steg/1${del.nr}-assessor.json`
   const res = await korAgent({
@@ -1161,17 +1741,37 @@ async function korAssessor(del, ctx) {
       }
     }
   }
-  if (p.avvikelse === 'motsägelse') {
-    const s = arkiv(
-      ['stopp', del.dir, '--utfall', 'TILLBAKA_TILL_SPEC', '--kalla', 'impact.md'],
-      ctx,
-    )
-    if (s.status !== 0) return { status: 'ofärdig', orsak: `stopp: ${felText(s)}` }
-    return { status: 'stopp', orsak: 'TILLBAKA_TILL_SPEC' }
-  }
+  if (p.avvikelse === 'motsägelse') return stoppaMotsagelse(del, p, ctx)
   return { status: null }
 }
 
+/** En analys med etiketten motsägelse stoppar som TILLBAKA_TILL_SPEC ur
+ *  impact.md (ADR-0106). Börjar texten efter etiketten med `design conflict:`
+ *  bär stoppet den texten som `--orsak` (#596): posten går tillbaka till
+ *  designen, inte till specen. Texten läses ur precheck-raden
+ *  `AVVIKELSE-TEXT:`, aldrig ur filen. */
+function stoppaMotsagelse(del, p, ctx) {
+  const orsak =
+    typeof p.avvikelseText === 'string' && /^design conflict:/i.test(p.avvikelseText)
+      ? p.avvikelseText
+      : null
+  const s = arkiv(
+    [
+      'stopp',
+      del.dir,
+      '--utfall',
+      'TILLBAKA_TILL_SPEC',
+      '--kalla',
+      'impact.md',
+      ...(orsak ? ['--orsak', orsak] : []),
+    ],
+    ctx,
+  )
+  if (s.status !== 0) return { status: 'ofärdig', orsak: `stopp: ${felText(s)}` }
+  logg(`STOPP ${delNamn(ctx, del.dir)} TILLBAKA_TILL_SPEC${orsak ? `: ${orsak}` : ''}`)
+  return { status: 'stopp', orsak: orsak ? `TILLBAKA_TILL_SPEC: ${orsak}` : 'TILLBAKA_TILL_SPEC' }
+}
+
 const impactRad = (svansModell, fakt) => ({
   skill: 'request-assess-impact',
   agent: 'request-assessor',
@@ -1180,15 +1780,35 @@ const impactRad = (svansModell, fakt) => ({
 })
 
 /** Analysens kropp (svansraderna strippade) som impact.md, med runs-rad.
- *  Ingen --ref: analysen har ingen referensfil att pinna. */
-function skrivImpact(del, res, ctx) {
+ *  Ingen --ref: analysen har ingen referensfil att pinna. Raden bär
+ *  `--repo-sha`, checkoutens HEAD som assessorn läste, när den är känd
+ *  (ADR-0155). */
+export function skrivImpact(del, res, ctx) {
   const { body, modell: svansModell } = parseSvansrader(res.text)
   writeFileSync(path.join(del.dir, 'impact.md'), body.trim() + '\n')
   const fakt = fakturerad(res.svar, ctx.modell)
-  addRun(del.dir, { ...impactRad(svansModell, fakt), fil: 'impact.md' }, ctx)
+  const repoSha = typeof ctx.repoSha === 'string' ? ctx.repoSha : null
+  addRun(del.dir, { ...impactRad(svansModell, fakt), fil: 'impact.md', repoSha }, ctx)
   return { svansModell, fakt }
 }
 
+/** HEAD för checkouten assessorn läser, 40 hex, eller null vid varje fel:
+ *  ingen repo, git saknas, en utskrift som inte är en sha. Kastar aldrig. */
+export function repoSha(repoRot, { kor = spawnSync } = {}) {
+  try {
+    const r = kor('git', ['rev-parse', 'HEAD'], {
+      cwd: repoRot,
+      encoding: 'utf8',
+      timeout: 5000,
+    })
+    if (r?.status !== 0) return null
+    const sha = String(r.stdout ?? '').trim()
+    return /^[0-9a-f]{40}$/.test(sha) ? sha : null
+  } catch {
+    return null
+  }
+}
+
 /** EN omdispatch av assessorn. Den avvisade analysen bokförs före omtaget. */
 async function impactOmdispatch(del, prompt, brister, meta, ctx) {
   avvisaDokument(del.dir, 'impact', brister, impactRad(meta.svansModell, meta.fakt), ctx)
@@ -1278,8 +1898,7 @@ function samlaFixsteg(fil, fixPath, ctx) {
  *  BROTT, kedjan igen. Kvarstående brott gör körningen avvisad (aldrig hela
  *  delen: den andra körningen kan vara giltig). Exit 2 är dispatcherfel. */
 async function kontrolleraScorer(del, k, res, prompt, ctx) {
-  const txt = path.join(del.dir, `tmp-scorer-run${k}.txt`)
-  const ren = path.join(del.dir, `tmp-scorer-run${k}.json`)
+  const { txt, ren } = tmpFiler(del, k, ctx)
   const bas = `steg/2${del.nr}-scorer-run${k}`
   const svarsrad = (kontroll, sista) => {
     const doc = lasJson(ren)
@@ -1364,13 +1983,7 @@ async function korScorers(del, ctx) {
   for (const [i, res] of svar.entries()) {
     const kr = await kontrolleraScorer(del, i + 1, res, prompt, ctx)
     if (kr.exit2) {
-      stadaTmp([
-        ...korningar,
-        {
-          txt: path.join(del.dir, `tmp-scorer-run${i + 1}.txt`),
-          ren: path.join(del.dir, `tmp-scorer-run${i + 1}.json`),
-        },
-      ])
+      stadaTmp([...korningar, tmpFiler(del, i + 1, ctx)])
       return { status: 'ofärdig', orsak: `poäng: ${kr.orsak}` }
     }
     korningar.push(kr)
@@ -1378,6 +1991,18 @@ async function korScorers(del, ctx) {
   return { korningar }
 }
 
+/** Kontrollkedjans arbetsfiler för körning `k`. I experimentläget ligger de
+ *  i delens katalog, som är körningens egen; i produktionsläget i
+ *  körningskatalogen, aldrig i posten, som bara arkivfiler hör hemma i
+ *  (ADR-0155 beslut 2). */
+const tmpFiler = (del, k, ctx) => {
+  const dir = ctx.post ? ctx.katalog : del.dir
+  return {
+    txt: path.join(dir, `tmp-scorer-run${k}.txt`),
+    ren: path.join(dir, `tmp-scorer-run${k}.json`),
+  }
+}
+
 /** Kontrollkedjans arbetsyta, aldrig arkivinnehåll: tmp-filerna tas bort när
  *  varvet är arkiverat eller avbrutet. */
 const stadaTmp = (korningar) => {
@@ -1517,9 +2142,14 @@ function arkiveraVarv(del, korningar, ctx) {
   }
 }
 
-/** En del hela vägen: analys, två scorerkörningar, arkivering. */
-async function korDel(del, ctx) {
+/** En del hela vägen: utkast och granskning i draft-läget (ADR-0156), analys,
+ *  två scorerkörningar, arkivering. */
+export async function korDel(del, ctx) {
   const namn = delNamn(ctx, del.dir)
+  const utkast = await korDesigner(del, ctx)
+  if (utkast.status !== null) return { namn, ...utkast }
+  const granskning = await korDesignReviewer(del, ctx)
+  if (granskning.status !== null) return { namn, ...granskning }
   const analys = await korAssessor(del, ctx)
   if (analys.status !== null) return { namn, ...analys }
   const scorers = await korScorers(del, ctx)
@@ -1538,12 +2168,14 @@ const skrivKorningsjson = (ctx, allaSteg) =>
 
 /** Avslutet: korning.json skrivs ALLTID (kostnaden är verklig även när
  *  körningen föll), status vägs samman och sätts via archive.mjs, och sist
- *  skrivs delraderna och bluf-tabellen på stderr. */
-function avsluta(ctx, allaSteg, rader, nyckel) {
+ *  skrivs delraderna och bluf-tabellen på stderr. Produktionsläget har inget
+ *  experiment att skriva till (postens state.json är redan satt av stegen),
+ *  tar bluf-tabellen över posten och skriver en `STATUS:`-rad på stdout. */
+export function avsluta(ctx, allaSteg, rader, nyckel = null) {
   let statusfel = null
   skrivKorningsjson(ctx, allaSteg)
   const status = sammanvagdStatus(rader.map((r) => r.status ?? null))
-  if (status !== null) {
+  if (status !== null && !ctx.post) {
     const orsak = rader
       .filter((r) => r.status === status && r.orsak)
       .map((r) => `${r.namn}: ${r.orsak}`)
@@ -1569,13 +2201,30 @@ function avsluta(ctx, allaSteg, rader, nyckel) {
   }
   for (const r of rader)
     logg(`DEL ${r.namn} ${r.status ?? 'klar'}${r.orsak ? ` (${r.orsak})` : ''}`)
-  const bluf = arkiv(['bluf', ctx.katalog], ctx)
+  const bluf = arkiv(['bluf', ctx.post ?? ctx.katalog], ctx)
   process.stderr.write(
     (bluf.status === 0 ? bluf.stdout : `bluf: ${felText(bluf)}`).trimEnd() + '\n',
   )
+  if (ctx.post) process.stdout.write(`STATUS: ${postStatus(ctx, status)}\n`)
   return status === 'ofärdig' || statusfel !== null ? 1 : 0
 }
 
+/** Postens läge efter körningen, läst ur state.json, för STATUS-raden: ett
+ *  stopp först, sedan en ofärdig körning (state.json kan stå kvar på
+ *  `designed` eller `assessed` och skulle annars se färdig ut), en spärr som
+ *  väntar på dom (`archive.mjs sparr`), och sist statusen när den är
+ *  `priced` eller `assessed`. Allt annat är ofärdigt. */
+function postStatus(ctx, korStatus) {
+  const state = lasJson(path.join(ctx.post, 'state.json'))
+  if (state?.stopp !== null && typeof state?.stopp === 'object') return 'stopp'
+  if (korStatus === 'ofärdig') return 'ofärdig'
+  if (arkiv(['sparr', ctx.post], ctx).status === 1) return 'väntar på dom'
+  if (state?.status === 'priced' || state?.status === 'assessed') return state.status
+  // Ett stopp som inte står i state.json (designerns INTERVJU KRÄVS,
+  // ADR-0156: inget skrivs) är fortfarande ett stopp, aldrig ofärdigt.
+  return korStatus === 'stopp' ? 'stopp' : 'ofärdig'
+}
+
 /** Signalavbrottet: döda barnen, skriv mätningen och lämna körningen som
  *  `ofärdig` efter sig. Utan den här vägen överlever betalda `claude`-processer
  *  en dödad korning.mjs, och korning.json skrivs aldrig, så både pengarna och
@@ -1585,24 +2234,63 @@ function avbryt(ctx, allaSteg, nyckel, signal) {
   const antal = ctx.barn.size
   for (const barn of ctx.barn) barn.kill('SIGTERM')
   skrivKorningsjson(ctx, allaSteg)
-  const r = arkiv(
-    [
-      'experiment',
-      ctx.exp,
-      '--korning',
-      nyckel,
-      '--status',
-      'ofärdig',
-      '--orsak',
-      `avbruten (${signal})`,
-    ],
-    ctx,
-  )
-  if (r.status !== 0) logg(`VARNING experiment --status ofärdig: ${felText(r)}`)
+  // Produktionsläget har inget experiment; kvittot (state.korning) är
+  // startarens att släppa (ADR-0155 beslut 3).
+  if (!ctx.post) {
+    const r = arkiv(
+      [
+        'experiment',
+        ctx.exp,
+        '--korning',
+        nyckel,
+        '--status',
+        'ofärdig',
+        '--orsak',
+        `avbruten (${signal})`,
+      ],
+      ctx,
+    )
+    if (r.status !== 0) logg(`VARNING experiment --status ofärdig: ${felText(r)}`)
+  }
   logg(`AVBRUTEN ${signal}: ${antal} barnprocess(er) dödade, korning.json skriven`)
   process.exit(SIGNAL_EXIT)
 }
 
+/** Vaktens intervall: startaren prövas var 30:e sekund. */
+export const VAKT_INTERVALL_MS = 30000
+
+/** Lever processen? EPERM betyder att den finns men tillhör någon annan,
+ *  samma regel som archive.mjs isAlive. */
+const arLevande = (pid) => {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (e) {
+    return e?.code === 'EPERM'
+  }
+}
+
+/** Vakten över startaren (ADR-0155): en bedom.mjs dödad med SIGKILL rensar
+ *  inget kvitto och dödar inget barn, så körningen prövar själv startarens pid
+ *  och avbryter (`vidDod`, i main `avbryt`) när den är borta. `vidDod` anropas
+ *  högst en gång; timern är `unref()` och håller aldrig processen vid liv. */
+export function vaktaStartaren({
+  pid,
+  vidDod,
+  isAlive = arLevande,
+  intervallMs = VAKT_INTERVALL_MS,
+}) {
+  let utlost = false
+  const timer = setInterval(() => {
+    if (utlost || isAlive(pid)) return
+    utlost = true
+    clearInterval(timer)
+    vidDod(`startaren dog (pid ${pid})`)
+  }, intervallMs)
+  timer.unref()
+  return timer
+}
+
 async function main(argv) {
   const val = tolkaArgv(argv)
   if (val.fel) {
@@ -1610,7 +2298,14 @@ async function main(argv) {
     console.error(ANVANDNING)
     return 2
   }
-  const underlag = lasUnderlag(val)
+  const underlag = val.post
+    ? lasUnderlagProduktion({
+        post: val.post,
+        repoRot: val.repoRot,
+        sprak: val.sprak,
+        designMode: val.designMode,
+      })
+    : lasUnderlag(val)
   if (underlag.fel) {
     console.error(underlag.fel)
     return 2
@@ -1619,21 +2314,28 @@ async function main(argv) {
   const ctx = {
     ...val,
     ...underlag,
+    repoSha: repoSha(val.repoRot),
     barn: new Set(),
     samla: (steg) => allaSteg.push(steg),
     raknaSamtidiga,
   }
   mkdirSync(path.join(ctx.katalog, 'steg'), { recursive: true })
-  const nyckel = `${path.basename(path.dirname(ctx.katalog))}/${path.basename(ctx.katalog)}`
+  // Nyckeln är experimentkanalens `<modell>/k<N>`; i produktionsläget är den
+  // bara postens namn i loggen.
+  const nyckel = ctx.post
+    ? path.basename(ctx.post)
+    : `${path.basename(path.dirname(ctx.katalog))}/${path.basename(ctx.katalog)}`
   for (const signal of ['SIGTERM', 'SIGINT'])
     process.on(signal, () => avbryt(ctx, allaSteg, nyckel, signal))
+  if (ctx.post && ctx.startare !== null)
+    vaktaStartaren({ pid: ctx.startare, vidDod: (orsak) => avbryt(ctx, allaSteg, nyckel, orsak) })
   logg(
     `START ${nyckel} ${ctx.requestId} ${ctx.modell} (${ctx.sprak}${ctx.eskalerad ? ', eskalerad' : ''})`,
   )
 
   let rader
   try {
-    rader = await korKorningen(ctx)
+    rader = ctx.post ? await korProduktion(ctx) : await korKorningen(ctx)
   } catch (e) {
     // korning.json skrivs ÄVEN när något kastar: kostnaden är redan dragen och
     // stegen ligger på disk. Ett kast som tar mätningen med sig gör körningen
@@ -1641,7 +2343,7 @@ async function main(argv) {
     logg(`FEL oväntat: ${e?.stack ?? e}`)
     rader = [
       {
-        namn: path.basename(ctx.katalog),
+        namn: path.basename(ctx.post ?? ctx.katalog),
         status: 'ofärdig',
         orsak: `oväntat fel: ${e?.message ?? e}`,
       },
@@ -1672,6 +2374,145 @@ async function korKorningen(ctx) {
   return rader
 }
 
+// ---------------------------------------------------------------------------
+// Produktionsläget (ADR-0155): en godkänd, designad post prissätts ur sin katalog
+// ---------------------------------------------------------------------------
+
+/** Precheck-raderna som bara säger att analysen hör till en annan spec eller
+ *  design (precheck.mjs, underlags- och designproveniensen under `--impact`).
+ *  Exakt de tre formuleringarna: varje annan brist i analysen är ett formfel
+ *  som en ny analys inte självklart rättar, och den ska en människa se. */
+const PROVENIENS_RADER = [
+  'impact.md: analysen gjordes mot en annan version av spec.md',
+  'impact.md: analysen gjordes utan det designdokument som nu finns',
+  'impact.md: analysen gjordes mot en annan version av design.md',
+]
+export const arProveniensBrist = (rad) => {
+  const text = String(rad).replace(/^- /, '')
+  return PROVENIENS_RADER.some((p) => text.startsWith(p))
+}
+
+const bristText = (brister) => brister.map((b) => b.replace(/^- /, '')).join('; ')
+
+/** Delposten scorern ska veta om: en split- eller buntdel bär `part`/`of` i
+ *  state.json, allt annat är en hel post. */
+const delpostUr = (state) => {
+  for (const falt of [state?.split, state?.bundle])
+    if (Number.isInteger(falt?.part) && Number.isInteger(falt?.of))
+      return { part: falt.part, of: falt.of }
+  return null
+}
+
+/** Steg 2 och 3: analysen återanvänds när den finns och håller proveniensen,
+ *  annars körs assessorn, men först efter att designen prövats (en del av en
+ *  split ärver förälderns design och prövas inte här). */
+async function produktionsAnalys(del, ctx) {
+  let korAssessorn = !existsSync(path.join(del.dir, 'impact.md'))
+  if (!korAssessorn) {
+    const p = korPrecheck(del, ctx, { impact: true })
+    if (p.fel) return { status: 'ofärdig', orsak: p.fel }
+    if (p.brister.length > 0 && !p.brister.every(arProveniensBrist))
+      return { status: 'ofärdig', orsak: `impact: ${bristText(p.brister)}` }
+    if (p.brister.length > 0) {
+      logg(`ANALYS ${del.namn} körs om: ${bristText(p.brister)}`)
+      korAssessorn = true
+    } else {
+      logg(`ANALYS ${del.namn} återanvänds`)
+      // En återanvänd analys som redan säger motsägelse prissätts aldrig:
+      // samma stopp som efter en ny analys (idempotent i archive.mjs).
+      return p.avvikelse === 'motsägelse' ? stoppaMotsagelse(del, p, ctx) : { status: null }
+    }
+  }
+  if ((ctx.state?.split?.parent ?? null) === null) {
+    const d = korPrecheck(del, ctx, { design: true })
+    if (d.fel) return { status: 'ofärdig', orsak: d.fel }
+    if (d.design !== 'ok' || d.brister.length > 0) {
+      const rader = [
+        ...(d.design !== 'ok' ? [`DESIGN: ${d.design ?? 'saknas'}`] : []),
+        ...d.brister,
+      ]
+      return { status: 'ofärdig', orsak: `designa ${ctx.requestId}: ${bristText(rader)}` }
+    }
+  }
+  return korAssessor(del, ctx)
+}
+
+/** Steg 4, efter ett rent arkiveringsvarv: `priced` sätts bara när inget
+ *  stopp står och ingen spärr väntar på dom. archive.mjs prövar sedan själv
+ *  den gällande prisfilen (pricedBlockers); en vägran är ofärdig med dess
+ *  rader, aldrig en tyst `assessed`. */
+function sattPriced(del, ctx) {
+  const state = lasJson(path.join(del.dir, 'state.json'))
+  if (state?.stopp !== null && typeof state?.stopp === 'object')
+    return { status: 'stopp', orsak: `${state.stopp.utfall} ur ${state.stopp.kalla}` }
+  const sp = arkiv(['sparr', del.dir], ctx)
+  if (sp.status === 1)
+    return { status: 'väntar på dom', orsak: raderMed(sp.stdout, 'SPÄRRAD: ').join('; ') }
+  if (sp.status !== 0) return { status: 'ofärdig', orsak: `sparr: ${felText(sp)}` }
+  const r = arkiv(['set-status', del.dir, 'priced'], ctx)
+  if (r.status === 0) {
+    logg(`PRISSATT ${del.namn}`)
+    return { status: null }
+  }
+  const vagrar = raderMed(r.stdout, 'VÄGRAR priced: ')
+  return {
+    status: 'ofärdig',
+    orsak:
+      vagrar.length > 0
+        ? `VÄGRAR priced: ${vagrar.join('; ')}`
+        : `set-status priced: ${felText(r)}`,
+  }
+}
+
+/** Produktionsläget för EN post (ADR-0155 beslut 1): formkontroll av den
+ *  godkända specen, analys vid behov, två scorers, arkivering och `priced`.
+ *  Returnerar samma radform som korKorningen. Specen godkändes av en
+ *  människa, så en brist i den är ofärdig och omdispatchas aldrig här. */
+export async function korProduktion(ctx) {
+  const del = {
+    dir: ctx.post,
+    namn: path.basename(ctx.post),
+    nr: 1,
+    delpost: delpostUr(ctx.state),
+  }
+  const rad = (r) => ({ namn: del.namn, status: r.status ?? null, orsak: r.orsak ?? null })
+
+  const p = korPrecheck(del, ctx)
+  if (p.fel) return [rad({ status: 'ofärdig', orsak: p.fel })]
+  if (p.brister.length > 0)
+    return [rad({ status: 'ofärdig', orsak: `spec: ${bristText(p.brister)}` })]
+  if (p.kandidat) {
+    const s = arkiv(['stopp', del.dir, '--utfall', p.kandidat, '--kalla', 'spec.md'], ctx)
+    if (s.status !== 0) return [rad({ status: 'ofärdig', orsak: `stopp: ${felText(s)}` })]
+    logg(`STOPP ${del.namn} ${p.kandidat}`)
+    return [rad({ status: 'stopp', orsak: p.kandidat })]
+  }
+  // Ett stopp som redan står (TILLBAKA_TILL_SPEC eller ESKALERA ur
+  // granskarblock.md, ett designkvitto eller en tidigare analys) köper ingen
+  // analys och inga scorers: posten går till respec eller designa först.
+  const stopp = ctx.state?.stopp
+  if (stopp !== null && typeof stopp === 'object') {
+    logg(`STOPP ${del.namn} står: ${stopp.utfall} (${stopp.kalla})`)
+    return [rad({ status: 'stopp', orsak: `stopp står: ${stopp.utfall} (${stopp.kalla})` })]
+  }
+
+  // Draft-läget (ADR-0156 beslut 1 och 3): ett saknat designdokument skrivs
+  // av designern och läses av granskaren innan analysbeslutet.
+  const utkast = await korDesigner(del, ctx)
+  if (utkast.status !== null) return [rad(utkast)]
+  const granskning = await korDesignReviewer(del, ctx)
+  if (granskning.status !== null) return [rad(granskning)]
+
+  const analys = await produktionsAnalys(del, ctx)
+  if (analys.status !== null) return [rad(analys)]
+
+  const scorers = await korScorers(del, ctx)
+  if (scorers.status) return [rad(scorers)]
+  const varv = arkiveraVarv(del, scorers.korningar, ctx)
+  if (varv.status !== null) return [rad(varv)]
+  return [rad(sattPriced(del, ctx))]
+}
+
 /** Huvudloopen körs bara när scriptet startas direkt; en import (testerna)
  *  exekverar ingenting. */
 const arDirektKord = () => {