@haus-tech/haus-workflow 5.12.1 → 6.0.0

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

@@ -3,10 +3,11 @@
  * driftvakterna, dispatcher-rälsen för compare-scripten och hashningen bor här,
  * så en härdning aldrig kan landa i ena scriptet och missa det andra.
  */
-import { readFileSync, existsSync } from 'node:fs'
+import { readFileSync, existsSync, statSync } from 'node:fs'
 import { createHash } from 'node:crypto'
 import { homedir } from 'node:os'
-import { join, resolve, dirname, basename } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { join, resolve, dirname, basename, isAbsolute, relative } from 'node:path'
 
 /**
  * Claude-konfigkatalogen. Installern hedrar CLAUDE_CONFIG_DIR (#278) — det ska
@@ -116,6 +117,75 @@ export function reportDiffs(diffs) {
  *  källans fetstil- eller `kod`-markeringar är fortfarande ordagrant. */
 export const norm = (s) => s.replace(/[*`]/g, '').replace(/\s+/g, ' ').trim()
 
+/** Ett brädvärdes alfabetiska kärna (ADR-0153): NFKC först, sedan bort med
+ *  allt som inte är en bokstav, gemener. Emoji, blanktecken och skiljetecken
+ *  avgör aldrig en grind, så `✅ Spec ok` och ` Spec ok ` blir båda `specok`. */
+export const alfabetiskKarna = (s) =>
+  s
+    .normalize('NFKC')
+    .replace(/[^\p{L}]/gu, '')
+    .toLowerCase()
+
+/** Arkivets ENDA hem (ADR-0154): huvudutcheckningens `.haus-workflow/requests/`,
+ *  löst från vilken cwd som helst, även en länkad worktree, via
+ *  `git rev-parse --git-common-dir`. Speglar src/utils/git-root.ts: git < 2.31
+ *  ignorerar `--path-format=absolute` och skriver ut en relativ sökväg, som då
+ *  löses mot `--show-toplevel`. `repoRot` är `dirname(commonDir)` bara när
+ *  commonDir slutar på `.git`. Ett bart repo, en submodul (`<super>/.git/modules/<sub>`)
+ *  och en `--separate-git-dir`-klon är git-kataloger vars commonDir inte heter
+ *  `.git`: de ger `{repoRot: null, arkivRot: null, ignorerad: false, commonDir}`.
+ *  Snedstrecket sist i check-ignore gör att en katalog som ännu inte finns
+ *  räknas som katalog, så `requests/` i .gitignore träffar den.
+ *  `kor` är en injicerbar spawnSync (`{status, stdout, stderr}`) för testerna.
+ *  Varje git-anrop har `timeout: 5000` (som listTrackedArtifactPaths i
+ *  src/claude/write-gitignore.ts); ett anrop som går ut räknas som att git inte
+ *  hittade något repo. Kastar aldrig: `null` betyder att git inte hittade något
+ *  repo eller inte gick att starta.
+ *  @returns {{repoRot: string, arkivRot: string, ignorerad: boolean}
+ *    | {repoRot: null, arkivRot: null, ignorerad: false, commonDir: string}
+ *    | null} */
+export function arkivRot(cwd, { kor = spawnSync } = {}) {
+  const git = (args, dir) => {
+    try {
+      const r = kor('git', args, { cwd: dir, encoding: 'utf8', timeout: 5000 })
+      if (!r || r.status !== 0) return null
+      const ut = String(r.stdout ?? '').trim()
+      return ut || null
+    } catch {
+      return null
+    }
+  }
+  const absolut = git(['rev-parse', '--path-format=absolute', '--git-common-dir'], cwd)
+  let commonDir = absolut && isAbsolute(absolut) ? resolve(absolut) : null
+  if (!commonDir) {
+    const enkel = git(['rev-parse', '--git-common-dir'], cwd)
+    if (!enkel) return null
+    if (isAbsolute(enkel)) {
+      commonDir = resolve(enkel)
+    } else {
+      const topp = git(['rev-parse', '--show-toplevel'], cwd)
+      if (!topp) return null
+      commonDir = resolve(topp, enkel)
+    }
+  }
+  if (basename(commonDir) !== '.git')
+    return { repoRot: null, arkivRot: null, ignorerad: false, commonDir }
+  const repoRot = dirname(commonDir)
+  const ignorerad = (() => {
+    try {
+      const r = kor('git', ['check-ignore', '-q', '.haus-workflow/requests/'], {
+        cwd: repoRot,
+        encoding: 'utf8',
+        timeout: 5000,
+      })
+      return !!r && r.status === 0
+    } catch {
+      return false
+    }
+  })()
+  return { repoRot, arkivRot: join(repoRot, '.haus-workflow', 'requests'), ignorerad }
+}
+
 /** Kanoniserar ett fakturerat modell-id: kontextsuffix som `[1m]` är samma
  *  modell på en annan kontextnivå, och ett datumsuffix `-YYYYMMDD` är samma
  *  modell med utgivningsdatum utskrivet, aldrig en egen modell (ADR-0099, #510). */
@@ -552,6 +622,31 @@ export const avvikelseEtikett = (text) => {
   return Object.hasOwn(AVVIKELSE_ALIAS, ord) ? AVVIKELSE_ALIAS[ord] : null
 }
 
+/**
+ * Fritexten efter etiketten på samma rad, utan inledande skiljetecken, eller
+ * null när raden saknas eller bara bär etiketten. precheck skriver den som
+ * `AVVIKELSE-TEXT:` så orkestratorn kan se en designkonflikt (texten börjar
+ * med `design conflict:`, #596) utan att läsa filen själv.
+ */
+export const avvikelseText = (text) => {
+  const rad = granskareRadRe('Avvikelse mot specen').source
+  const m = new RegExp(`${rad}[ \\t]*\\p{L}+[ \\t.,;:!?]*(.*)$`, 'imu').exec(String(text))
+  if (!m) return null
+  const rest = m[1].trim()
+  return rest === '' ? null : rest
+}
+
+/**
+ * Språket ur källmanifestets `SPRÅK:`-rad (speca steg 2: manifestets första
+ * rad), första raden som matchar, annars null. Språket gissas aldrig
+ * (ADR-0114, #521): ett saknat eller okänt värde är null, och anroparen
+ * vägrar hellre än väljer.
+ */
+export const sprakUrManifest = (text) => {
+  const m = /^SPRÅK:\s*(svenska|engelska)\s*$/m.exec(String(text ?? ''))
+  return m ? m[1] : null
+}
+
 export const UTFALLSVAL_RAD = granskareRow('Obesvarade utfallsval')
 export const STRUKET_PREFIX = ['struket:', 'struck:']
 
@@ -873,7 +968,9 @@ export const designFrontmatter = (text) => {
   if (end === -1) return null
   const falt = {}
   for (const l of lines.slice(1, end)) {
-    const m = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(l)
+    // Ett avslutande \r strippas: `.` matchar aldrig \r, så en CRLF-rad
+    // föll annars helt och frontmattern blev tom.
+    const m = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(l.replace(/\r$/, ''))
     if (m) falt[m[1]] = m[2].trim()
   }
   return falt
@@ -900,6 +997,228 @@ export const specConflicts = (text) => {
   return ickeTomma
 }
 
+/** Designdokumentets läge (ADR-0156 beslut 4): `draft` när frontmattern bär
+ *  `mode: draft` (ociterat), annars `intervju`, även utan frontmatter. */
+export const designMode = (text) =>
+  designFrontmatter(text)?.mode === 'draft' ? 'draft' : 'intervju'
+
+/** De icke-tomma raderna i sektionen `rubrik` (ett avslutande \r strippat,
+ *  så ett CRLF-dokument tolkas likadant), null när den saknas, och om
+ *  sektionen är exakt `none`. En sektion utan en enda icke-tom rad är `tom`:
+ *  tolkarna gör den till { fel: 'tom sektion' }, aldrig till none. Delad av
+ *  utkastsektionernas tolkare. */
+const designSektion = (text, rubrik) => {
+  const rader = sectionLines(String(text), rubrik)
+  if (rader === null) return null
+  const ickeTomma = rader.map((r) => r.replace(/\r$/, '')).filter((r) => r.trim() !== '')
+  const none = ickeTomma.length === 1 && ickeTomma[0].trim().toLowerCase() === 'none'
+  return { rader: ickeTomma, none, tom: ickeTomma.length === 0 }
+}
+const tomSektion = () => ({ fel: 'tom sektion' })
+
+const ANTAGANDE_ETIKETTER = [
+  ['Question', 'fraga'],
+  ['Taken', 'vald'],
+  ['Not taken', 'ejValda'],
+  ['Why', 'skal'],
+]
+
+/** `## Assumptions` (ADR-0156 beslut 4): null när sektionen saknas, [] för
+ *  `none`, annars en post { fraga, vald, ejValda, skal } per numrerad punkt.
+ *  Punkten börjar på kolumn 0 med `N. Question: …`, de tre andra etiketterna
+ *  står på egna, indragna rader. `Not taken: none` ger ejValda []. En punkt
+ *  utan någon av etiketterna, en etikett två gånger eller en rad som inte hör
+ *  till någon punkt ger { fel }, aldrig ett kast. */
+export const designAssumptions = (text) => {
+  const s = designSektion(text, 'Assumptions')
+  if (s === null) return null
+  if (s.tom) return tomSektion()
+  if (s.none) return []
+  const punkter = []
+  for (const rad of s.rader) {
+    const start = /^\d+\.\s+(.*)$/.exec(rad)
+    const indragen = /^\s+(\S.*)$/.exec(rad)
+    const innehall = start ? start[1] : indragen && punkter.length > 0 ? indragen[1] : null
+    if (innehall === null) return { fel: `raden "${rad.trim()}" hör inte till någon punkt` }
+    if (start) punkter.push({})
+    const n = punkter.length
+    const punkt = punkter[n - 1]
+    const m = /^(Question|Taken|Not taken|Why):\s*(.*)$/.exec(innehall)
+    if (!m) return { fel: `punkt ${n}: raden "${innehall}" har ingen etikett` }
+    if (m[1] in punkt) return { fel: `punkt ${n}: "${m[1]}:" står två gånger` }
+    if (start && m[1] !== 'Question') return { fel: `punkt ${n}: ska börja med "Question:"` }
+    punkt[m[1]] = m[2].trim()
+  }
+  return punkter.reduce((ut, punkt, i) => {
+    if (!Array.isArray(ut)) return ut
+    const saknad = ANTAGANDE_ETIKETTER.find(([etikett]) => !punkt[etikett])
+    if (saknad) return { fel: `punkt ${i + 1}: "${saknad[0]}:" saknas` }
+    const ejValda =
+      punkt['Not taken'].toLowerCase() === 'none'
+        ? []
+        : punkt['Not taken']
+            .split(';')
+            .map((v) => v.trim())
+            .filter(Boolean)
+    return [...ut, { fraga: punkt.Question, vald: punkt.Taken, ejValda, skal: punkt.Why }]
+  }, [])
+}
+
+/** Första backtickade token per listpunkt (`- …` eller `* …` på kolumn 0) i
+ *  sektionens rader; indragna rader fortsätter föregående punkt. En punkt utan
+ *  backticks, en tom token eller en rad utanför alla punkter ger { fel }; en
+ *  symbol är aldrig "". */
+const forstaTokenPerPunkt = (rader) => {
+  const tokens = []
+  for (const rad of rader) {
+    const punkt = /^[-*]\s+(.*)$/.exec(rad)
+    if (!punkt) {
+      if (/^\s/.test(rad) && tokens.length > 0) continue
+      return { fel: `raden "${rad.trim()}" är ingen listpunkt` }
+    }
+    const token = /`([^`]+)`/.exec(punkt[1])
+    if (!token) return { fel: `punkt ${tokens.length + 1}: ingen symbol i backticks` }
+    if (token[1].trim() === '') return { fel: `punkt ${tokens.length + 1}: tom token i backticks` }
+    tokens.push(token[1].trim())
+  }
+  return tokens
+}
+
+/** `## Removed or renamed` (ADR-0156 beslut 4): null när sektionen saknas,
+ *  [] för `none`, annars symbolen per punkt (``- `gammalt` → `nytt`: skäl``
+ *  eller ``- `gammalt`: skäl``, den första backtickade token). En punkt utan
+ *  backticks ger { fel }. */
+export const designRemovedSymbols = (text) => {
+  const s = designSektion(text, 'Removed or renamed')
+  if (s === null) return null
+  if (s.tom) return tomSektion()
+  if (s.none) return []
+  return forstaTokenPerPunkt(s.rader)
+}
+
+/** `## Files touched` (ADR-0156 beslut 4): null när sektionen saknas, annars
+ *  den första backtickade token per punkt, relativa sökvägar som skrivna.
+ *  `none` är ingen listpunkt och ger { fel }, som en punkt utan backticks. */
+export const designFilesTouched = (text) => {
+  const s = designSektion(text, 'Files touched')
+  if (s === null) return null
+  if (s.tom) return tomSektion()
+  return forstaTokenPerPunkt(s.rader)
+}
+
+/** En post under "## Files touched" som är en befintlig katalog under
+ *  `repoRot` (`src/`, `.`): som undantag i symbolkontrollen hade den tystat
+ *  hela trädet. Ger felet för den första, null när ingen är en katalog. */
+const katalogIFilerna = (filer, repoRot) => {
+  const rot = resolve(repoRot)
+  for (const [i, p] of filer.entries()) {
+    const abs = resolve(rot, p)
+    const rel = relative(rot, abs)
+    if (rel.startsWith('..') || isAbsolute(rel)) continue
+    let arKatalog = false
+    try {
+      arKatalog = statSync(abs).isDirectory()
+    } catch {
+      arKatalog = false
+    }
+    if (arKatalog) return `punkt ${i + 1}: "${p}" är en katalog, inte en fil`
+  }
+  return null
+}
+
+/** Utkastsektionernas formkontroll (ADR-0156 beslut 4), delad av precheck
+ *  --design, precheck --design-utkast och add-design. En saknad eller
+ *  felformad sektion är BRIST på ett utkast och VARNING på ett
+ *  intervjudokument (de tre befintliga designerna saknar sektionerna; där
+ *  säger raden att sektionen är valfri). Med `repoRot` är en post under
+ *  "## Files touched" som är en katalog i repot felformad. `## Spec
+ *  conflicts` prövar anroparna som förut. */
+export const designForm = (text, { repoRot = null } = {}) => {
+  const lage = designMode(text)
+  const fel = (r) => (r === null ? 'saknas' : !Array.isArray(r) ? r.fel : null)
+  const filer = designFilesTouched(text)
+  const filFel =
+    Array.isArray(filer) && repoRot != null ? katalogIFilerna(filer, repoRot) : fel(filer)
+  const rader = [
+    ['Assumptions', fel(designAssumptions(text))],
+    ['Removed or renamed', fel(designRemovedSymbols(text))],
+    ['Files touched', filFel],
+  ]
+    .filter(([, f]) => f !== null)
+    .map(([namn, f]) =>
+      lage !== 'draft' && f === 'saknas'
+        ? `design.md: sektionen "## ${namn}" saknas (valfri på ett intervjudokument)`
+        : `design.md: sektionen "## ${namn}" saknas eller är felformad (${f})`,
+    )
+  return lage === 'draft'
+    ? { lage, brister: rader, varningar: [] }
+    : { lage, brister: [], varningar: rader }
+}
+
+/** Repo-roten för en fil: närmaste förälder som innehåller `.git` (en
+ *  katalog, eller en fil i en länkad worktree), null utan. Inget git-anrop. */
+export const repoRotForFil = (abs) => {
+  let cur = dirname(resolve(abs))
+  for (;;) {
+    if (existsSync(join(cur, '.git'))) return cur
+    const parent = dirname(cur)
+    if (parent === cur) return null
+    cur = parent
+  }
+}
+
+/** Symbolkontrollen (ADR-0156 beslut 4): ett `git grep -n -w -F -I -e <symbol>`
+ *  per symbol i `repoRot` (-w: en hel identifierare, så `old` träffar aldrig
+ *  `oldName`), med varje sökväg i `undantag` (filerna designen
+ *  rör) och designdokumentens hem `docs/superpowers/specs` undantagna. Status
+ *  1 är ingen träff, status 0 ger första raden som { symbol, fil, rad }. Ett
+ *  annat status, ett spawnfel (timeout 5000 ms) eller ett kast fyller `fel`
+ *  och stoppar; anroparen gör det till en VARNING, aldrig en tyst passage.
+ *  `kor` är en injicerbar spawnSync, som i arkivRot.
+ *  @returns {{traffar: {symbol: string, fil: string, rad: number|null}[], fel: string|null}} */
+export function symbolkontroll({ symboler, undantag, repoRot, kor = spawnSync }) {
+  const traffar = []
+  const exclude = [...undantag, 'docs/superpowers/specs'].map((p) => `:(exclude)${p}`)
+  for (const symbol of symboler) {
+    let r
+    try {
+      r = kor('git', ['grep', '-n', '-w', '-F', '-I', '-e', symbol, '--', '.', ...exclude], {
+        cwd: repoRot,
+        encoding: 'utf8',
+        timeout: 5000,
+      })
+    } catch (e) {
+      return { traffar, fel: e.message }
+    }
+    if (r?.error) return { traffar, fel: r.error.message }
+    if (r?.status === 1) continue
+    if (r?.status !== 0) {
+      const stderr = String(r?.stderr ?? '').trim()
+      return { traffar, fel: stderr || `git grep avslutades med status ${r?.status}` }
+    }
+    const forsta = String(r.stdout ?? '').split('\n')[0]
+    const m = /^(.+?):(\d+):/.exec(forsta)
+    traffar.push(m ? { symbol, fil: m[1], rad: Number(m[2]) } : { symbol, fil: forsta, rad: null })
+  }
+  return { traffar, fel: null }
+}
+
+/** Symbolkontrollen för ett designdokument, delad av precheck och
+ *  add-design: symbolerna under "## Removed or renamed" greppas i `repoRot`
+ *  utanför filerna under "## Files touched". Inga symboler: inget grep. Ingen
+ *  rot eller ett git-fel ger `varning` (anroparen skriver VARNING, aldrig en
+ *  tyst passage); träffarna mappar anroparen till sin egen rad. */
+export const designSymbolkontroll = (text, repoRot, { kor = spawnSync } = {}) => {
+  const symboler = designRemovedSymbols(text)
+  if (!Array.isArray(symboler) || symboler.length === 0) return { traffar: [], varning: null }
+  if (repoRot == null)
+    return { traffar: [], varning: 'symbolkontrollen kunde inte köras: ingen repo-rot' }
+  const filer = designFilesTouched(text)
+  const undantag = Array.isArray(filer) ? filer : []
+  const { traffar, fel } = symbolkontroll({ symboler, undantag, repoRot, kor })
+  return { traffar, varning: fel ? `symbolkontrollen kunde inte köras: ${fel}` : null }
+}
+
 /** Katalogens id: gid:t ur state.json, annars katalognamnet (en slug-katalog
  *  bär request_id null). En definition, delad av add-design och precheck
  *  --design, så frontmatterns request_id alltid prövas mot samma svar. */
@@ -1114,6 +1433,12 @@ export const FRYSTA_LITERALER = Object.freeze({
     // ADR-0144: paraplyläget i specifierns prompt (bedöms DELA_UPP-val 2).
     'PARAPLY:',
     'DELAR:',
+    // ADR-0156: designerns och designgranskarens promptetiketter.
+    'URSPRUNGLIG FÖRFRÅGAN:',
+    'KONFIG:',
+    'ID:',
+    'SPEC-SHA256:',
+    'DATUM:',
   ]),
   promptvarden: Object.freeze([
     'installerade',

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

@@ -10,12 +10,17 @@
  * blick (poängord i analys, saknad Ingår inte) — de skrivs ut men stoppar inget.
  *
  * Användning: node precheck.mjs <arkivkatalog> [--impact] [--design]
+ *              [--design-utkast <abs fil> [--repo-rot <abs>]]
  *   --impact  kräv och kontrollera även impact.md (bedöm-steget)
  *   --design  kräv och kontrollera även design.md (designa-steget och bedöms grind 1b)
+ *   --design-utkast  kontrollera ett designutkast utan state.design (experimentkanalen,
+ *             ADR-0156): sektionerna, frontmattern, Spec conflicts och symbolkontrollen
+ *   --repo-rot  roten symbolkontrollen greppar i; vinner när den ges, annars repot
+ *             utkastet ligger i
  * Exit 0 = ok, 1 = brister (listade på stdout), 2 = användningsfel.
  */
 import { readFileSync, existsSync } from 'node:fs'
-import { join } from 'node:path'
+import { join, isAbsolute } from 'node:path'
 
 import {
   markerStrippedSha256,
@@ -26,6 +31,7 @@ import {
   specForm,
   headingsByLanguage,
   avvikelseEtikett,
+  avvikelseText,
   AVVIKELSE_ETIKETTER,
   AVVIKELSE_ALIAS,
   STRUKET_PREFIX,
@@ -43,15 +49,33 @@ import {
   designBody,
   specConflicts,
   katalogId,
+  designForm,
+  designSymbolkontroll,
+  repoRotForFil,
 } from './lib.mjs'
 
 const dir = process.argv[2]
 const requireImpact = process.argv.includes('--impact')
 const requireDesign = process.argv.includes('--design')
+const ANVANDNING =
+  'användning: node precheck.mjs <arkivkatalog> [--impact] [--design] [--design-utkast <abs fil> [--repo-rot <abs>]]'
 if (!dir) {
-  console.error('användning: node precheck.mjs <arkivkatalog> [--impact] [--design]')
+  console.error(ANVANDNING)
   process.exit(2)
 }
+/** Värdet efter en sökvägsflagga: en absolut sökväg, annars användningsfel. */
+const sokvagsflagga = (namn) => {
+  const i = process.argv.indexOf(namn)
+  if (i === -1) return null
+  const v = process.argv[i + 1]
+  if (v === undefined || v.startsWith('--') || !isAbsolute(v)) {
+    console.error(`${namn} kräver en absolut sökväg\n${ANVANDNING}`)
+    process.exit(2)
+  }
+  return v
+}
+const designUtkast = sokvagsflagga('--design-utkast')
+const repoRotFlagga = sokvagsflagga('--repo-rot')
 
 const problems = []
 const warnings = []
@@ -59,9 +83,11 @@ const warnings = []
 // ADR-0106, #505): `PRISAVGORANDE: <text>` när granskarblocket flaggar ett
 // prisavgörande öppet val; `KANDIDAT: <utfall>` per block som bär markören,
 // alltid, oavsett exitkod; `AVVIKELSE: <etikett>` när --impact hittar en
-// giltig etikett.
+// giltig etikett, och `AVVIKELSE-TEXT: <fritext>` efter den när raden bär text
+// efter etiketten (#596: en designkonflikt läses ur raden, aldrig ur filen).
 const kandidater = []
 let avvikelse = null
+let avvikelseFritext = null
 let prisavgorande = null
 
 // Kontraktsdriftvakt: rubrik- och vokabulärreglerna nedan speglar specformatet.
@@ -205,6 +231,7 @@ if (requireImpact) {
       const avvikelseRad = granskareRow('Avvikelse mot specen')[dokumentSprak]
       const utfallsvalRad = granskareRow('Obesvarade utfallsval')[dokumentSprak]
       avvikelse = avvikelseEtikett(impact)
+      avvikelseFritext = avvikelseText(impact)
       if (avvikelse == null)
         problems.push(
           `impact.md: raden "**${avvikelseRad}:**" ska börja med en etikett: ${AVVIKELSE_ETIKETTER.map(v.etikett).join(', ')}`,
@@ -257,6 +284,66 @@ if (requireImpact) {
 // ligger i state.json-blocket nedan.
 const designText = requireDesign ? read('design.md', true) : null
 let designRad = null
+// `DESIGN-LÄGE: draft|intervju` (ADR-0156 beslut 4), satt när ett
+// designdokument formprövats; skrivs bland kontraktsraderna.
+let designLage = null
+
+/** Frontmattern, Spec conflicts och tids- och poängorden: kontrollerna som
+ *  gäller dokumentets innehåll, delade av --design och --design-utkast så
+ *  utkastet prövas med exakt samma rader. `id` är katalogens id. */
+const granskaDesignInnehall = (text, id) => {
+  const fm = designFrontmatter(text) ?? {}
+  if (fm.request_id !== id)
+    problems.push(
+      `design.md: frontmatterns request_id "${fm.request_id ?? ''}" är inte katalogens id "${id}"`,
+    )
+  if (spec != null && fm.spec_sha256 !== markerStrippedSha256(join(dir, 'spec.md')))
+    problems.push(
+      'design.md: spec_sha256 är inte nuvarande spec.md, designen gjordes mot en annan spec',
+    )
+  const konflikter = specConflicts(text)
+  if (konflikter === null) problems.push('design.md: sektionen "## Spec conflicts" saknas')
+  else if (konflikter.length > 0)
+    problems.push(
+      `design.md: "## Spec conflicts" är inte none (${konflikter.length}), posten går till kunddialog och respec`,
+    )
+  // Storleks- och poängord i designen är VARNING, aldrig BRIST: dokumentet
+  // skrivs av en människostyrd session och assessorn instrueras att
+  // bortse från dem, men granskaren ska se dem. Bara brödtexten, aldrig
+  // frontmattern (en hash kan råka innehålla "tim").
+  const body = designBody(text)
+  const p = body.match(POANGORD_RE)
+  if (p)
+    warnings.push(
+      `design.md: poängord "${p[0]}", assessorn ska bortse från det, granskaren bör se det`,
+    )
+  const t = body.match(TIDSORD_RE)
+  if (t)
+    warnings.push(
+      `design.md: tidsord "${t[0]}", assessorn ska bortse från det, granskaren bör se det`,
+    )
+}
+
+/** Utkastsektionerna och symbolkontrollen (ADR-0156 beslut 4): designForm
+ *  ger BRIST på ett utkast och VARNING på ett intervjudokument; varje symbol
+ *  under "## Removed or renamed" greppas i `repoRot` utanför filerna under
+ *  "## Files touched". En träff är BRIST; en kontroll som inte kunde köras
+ *  (ingen rot, git-fel, timeout) är VARNING, aldrig en tyst passage.
+ *  `symboler: false` hoppar över greppet (--design utan kanonisk fil, som
+ *  redan är en BRIST). */
+const granskaUtkastform = (text, repoRot, { symboler: greppa = true } = {}) => {
+  const form = designForm(text, { repoRot })
+  designLage = form.lage
+  problems.push(...form.brister)
+  warnings.push(...form.varningar)
+  if (!greppa) return
+  const { traffar, varning } = designSymbolkontroll(text, repoRot)
+  for (const t of traffar)
+    problems.push(
+      `symbolen \`${t.symbol}\` används fortfarande: ${t.fil}:${t.rad} (utanför filerna designen rör)`,
+    )
+  if (varning) warnings.push(varning)
+}
 
 // ---- state.json ------------------------------------------------------------
 const state = read('state.json', true)
@@ -349,50 +436,63 @@ if (state != null) {
               `design.md: den kanoniska filen ${design.path} har en annan hash än design.md`,
             )
         }
-        const fm = designFrontmatter(designText) ?? {}
-        const id = katalogId(s, dir)
-        if (fm.request_id !== id)
-          problems.push(
-            `design.md: frontmatterns request_id "${fm.request_id ?? ''}" är inte katalogens id "${id}"`,
-          )
-        if (spec != null && fm.spec_sha256 !== markerStrippedSha256(join(dir, 'spec.md')))
-          problems.push(
-            'design.md: spec_sha256 är inte nuvarande spec.md, designen gjordes mot en annan spec',
-          )
-        const konflikter = specConflicts(designText)
-        if (konflikter === null) problems.push('design.md: sektionen "## Spec conflicts" saknas')
-        else if (konflikter.length > 0)
-          problems.push(
-            `design.md: "## Spec conflicts" är inte none (${konflikter.length}), posten går till kunddialog och respec`,
-          )
-        // Storleks- och poängord i designen är VARNING, aldrig BRIST: dokumentet
-        // skrivs av en människostyrd session och assessorn instrueras att
-        // bortse från dem, men granskaren ska se dem. Bara brödtexten, aldrig
-        // frontmattern (en hash kan råka innehålla "tim").
-        const body = designBody(designText)
-        const p = body.match(POANGORD_RE)
-        if (p)
-          warnings.push(
-            `design.md: poängord "${p[0]}", assessorn ska bortse från det, granskaren bör se det`,
-          )
-        const t = body.match(TIDSORD_RE)
-        if (t)
-          warnings.push(
-            `design.md: tidsord "${t[0]}", assessorn ska bortse från det, granskaren bör se det`,
-          )
+        granskaDesignInnehall(designText, katalogId(s, dir))
       }
+      // ADR-0156 beslut 4: utkastsektionerna prövas när design.md finns;
+      // symbolkontrollen körs i repot där den kanoniska filen bor, bara när
+      // filen finns (annars står redan en BRIST om den ovan).
+      if (designText != null) {
+        const kanonisk =
+          design !== null && typeof design.path === 'string' && existsSync(design.path)
+            ? design.path
+            : null
+        granskaUtkastform(designText, kanonisk === null ? null : repoRotForFil(kanonisk), {
+          symboler: kanonisk !== null,
+        })
+      }
+      if (design?.review?.verdict === 'stopp')
+        problems.push(
+          `designgranskningen stoppade utkastet (design-review.md): kör designa ${katalogId(s, dir)}`,
+        )
     }
   } catch {
     problems.push('state.json: ogiltig JSON')
   }
 }
 
+// ---- --design-utkast (experimentkanalen, ADR-0156) -------------------------
+// Ett designutkast som aldrig bokförts: ingen state.design läses, filen pekas
+// ut direkt. Samma innehålls- och formrader som --design; symbolkontrollen i
+// --repo-rot när den är given (utkastet kan ligga i arkivets repo, koden i
+// målrepot), annars i repot filen ligger i.
+if (designUtkast != null) {
+  let text = null
+  try {
+    text = readFileSync(designUtkast, 'utf8')
+  } catch (e) {
+    problems.push(`${designUtkast}: går inte att läsa: ${e.message}`)
+  }
+  if (text != null) {
+    let s = null
+    try {
+      s = state != null ? JSON.parse(state) : null
+    } catch {
+      // state.json-blocket ovan har redan fällt den ogiltiga JSON:en.
+    }
+    granskaDesignInnehall(text, katalogId(s, dir))
+    granskaUtkastform(text, repoRotFlagga ?? repoRotForFil(designUtkast))
+  }
+}
+
 // Kontraktsraderna först, före varningar och verdikt: orkestratorn läser dem
 // innan den tolkar exitkoden.
 if (prisavgorande != null) console.log(`PRISAVGORANDE: ${prisavgorande}`)
 for (const k of kandidater) console.log(`KANDIDAT: ${k}`)
 if (avvikelse != null) console.log(`AVVIKELSE: ${avvikelse}`)
+if (avvikelse != null && avvikelseFritext != null)
+  console.log(`AVVIKELSE-TEXT: ${avvikelseFritext}`)
 if (requireDesign) console.log(`DESIGN: ${designRad ?? 'saknas'}`)
+if (designLage != null) console.log(`DESIGN-LÄGE: ${designLage}`)
 for (const w of warnings) console.log(`VARNING: ${w}`)
 if (problems.length === 0) {
   console.log('OK: formkontrollen passerad')