@haus-tech/haus-workflow 5.0.0 → 5.1.0

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

@@ -3,10 +3,10 @@
  * 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 } from 'node:fs'
+import { readFileSync, existsSync } from 'node:fs'
 import { createHash } from 'node:crypto'
 import { homedir } from 'node:os'
-import { join, resolve } from 'node:path'
+import { join, resolve, dirname, basename } from 'node:path'
 
 /**
  * Claude-konfigkatalogen. Installern hedrar CLAUDE_CONFIG_DIR (#278) — det ska
@@ -117,8 +117,51 @@ export function reportDiffs(diffs) {
 export const norm = (s) => s.replace(/[*`]/g, '').replace(/\s+/g, ' ').trim()
 
 /** Kanoniserar ett fakturerat modell-id: kontextsuffix som `[1m]` är samma
- *  modell på en annan kontextnivå, aldrig en egen modell (ADR-0099). */
-export const canonicalModel = (id) => id.replace(/\[[^\]]*\]$/, '')
+ *  modell på en annan kontextnivå, och ett datumsuffix `-YYYYMMDD` är samma
+ *  modell med utgivningsdatum utskrivet, aldrig en egen modell (ADR-0099, #510). */
+export const canonicalModel = (id) => id.replace(/\[[^\]]*\]$/, '').replace(/-\d{8}$/, '')
+
+/** Agenternas svansrader (dispatch-kontraktet): plockas från slutet av
+ *  svaret, aldrig mitt i. Kroppen är allt före den första svansraden. */
+export function parseSvansrader(text) {
+  const lines = String(text).replace(/\r\n/g, '\n').split('\n')
+  const svans = { modell: null, lasta: null, avvikelse: null }
+  const nyckel = { MODELL: 'modell', LÄSTA: 'lasta', AVVIKELSE: 'avvikelse' }
+  let i = lines.length - 1
+  while (i >= 0) {
+    const t = lines[i].trim()
+    if (t === '') {
+      i--
+      continue
+    }
+    const m = /^(MODELL|LÄSTA|AVVIKELSE):\s*(.*)$/u.exec(t)
+    if (!m) break
+    if (svans[nyckel[m[1]]] === null) svans[nyckel[m[1]]] = m[2].trim()
+    i--
+  }
+  return {
+    body: lines
+      .slice(0, i + 1)
+      .join('\n')
+      .trim(),
+    ...svans,
+  }
+}
+
+/** Första JSON-objektet i en svarskropp: i ett ```json-staket om det finns,
+ *  annars från första { till sista }. null när inget går att tolka. */
+export function extraheraJson(body) {
+  const fence = /```(?:json)?\s*\n([\s\S]*?)\n```/u.exec(body)
+  const k = fence ? fence[1] : String(body)
+  const start = k.indexOf('{')
+  const slut = k.lastIndexOf('}')
+  if (start === -1 || slut < start) return null
+  try {
+    return JSON.parse(k.slice(start, slut + 1))
+  } catch {
+    return null
+  }
+}
 
 /** Ett "ordagrant" citat får hoppa med [...] och kortas med inledande/avslutande …
  *  Varje kvarvarande segment måste vara exakt substräng av det normaliserade
@@ -175,13 +218,286 @@ export const SCORE_OUTCOMES = [
   'ESKALERA',
 ]
 
+export const MODES = ['pricing', 'guard']
+
+// Stegschemat (Task 4, requestmotor 2.1). Enumen är ASCII som hog/medel/lag;
+// ett äldre arkiv med "större" läses fortfarande av report.mjs, men en färsk
+// körning måste använda den ASCII-form compare-scores diffar på.
+export const STEP_RELATIONS = ['storre', 'mindre', 'lika']
+
+export const KONFIDENS = ['hog', 'medel', 'lag']
+
+/**
+ * Skalans ankare i POÄNGORDNING, med poäng. Numren är fasta beteckningar satta
+ * när ankaret skrevs, inte platser i ordningen: A17 tillkom efteråt och ligger på
+ * 10 poäng mellan A12 och A13 (poangskala.md, Översikt). Varje script som
+ * behöver "angränsande", "innanför" eller "ankarets poäng" läser HÄR, aldrig ur
+ * ankarnumret (#506). Driftvakt: tests/request-ankartabell.test.js läser
+ * översiktstabellen och fäller varje avvikelse; sha-pinnen på poangskala.md i
+ * contract-check/compare-scores täcker resten av filen.
+ */
+export const ANKARE = Object.freeze([
+  ['A1', 0.25],
+  ['A2', 0.75],
+  ['A3', 0.75],
+  ['A4', 1],
+  ['A5', 2],
+  ['A6', 2.25],
+  ['A7', 2.5],
+  ['A8', 3],
+  ['A9', 4],
+  ['A10', 4],
+  ['A11', 7],
+  ['A12', 9],
+  ['A17', 10],
+  ['A13', 12],
+  ['A14', 13],
+  ['A15', 16],
+  ['A16', 17],
+])
+const ANKAR_INDEX = new Map(ANKARE.map(([id, poang], i) => [id, { i, poang }]))
+/** Position i skalans ordning (0-baserat), null för okänt id eller icke-sträng. */
+export const ankarPosition = (id) => ANKAR_INDEX.get(id)?.i ?? null
+/** Ankarets poäng enligt översiktstabellen, null för okänt id. */
+export const ankarPoang = (id) => ANKAR_INDEX.get(id)?.poang ?? null
+
+/** Skalans översta ankare i POSITIONSORDNING (inte högsta numret: A17 ligger
+ *  mellan A12 och A13). Inget-tak-utfallen måste ha jämfört mot detta (#503). */
+export const toppAnkare = () => ANKARE[ANKARE.length - 1][0]
+
+/** Uppdragstyperna ur översiktstabellen. `type` i score-kuvertet loggas för att
+ *  mäta systematisk felplacering per typ (request-score/SKILL.md, Typen), vilket
+ *  förutsätter ett slutet värdeförråd (#509). */
+export const TYPER = [
+  'Kundvänd funktion',
+  'Underhåll',
+  'Teknisk uppsättning',
+  'Integration',
+  'Internt verktyg',
+]
+
+// Protokollmekanik som aldrig får nå kundtext. Klass/klassas är kundspråk
+// (kunden ser Class-fältet) och KONCEPT/DIAGNOS är legitima kundutfall — de
+// står medvetet INTE här. Poäng och skalans mekanik är interna. Gränserna är
+// Unicode-medvetna (JS \b bryter vid å/ä/ö), och "protokoll" är snävat så att
+// vardagssvenska som "protokollförs" går fri medan klassningsprotokollet fångas.
+const B = (pat) => new RegExp(`(?<![\\p{L}\\d_])(?:${pat})`, 'iu')
+export const CUSTOMER_BLACKLIST = [
+  B('poäng\\p{L}*'),
+  B('basklass\\p{L}*'),
+  B('bump\\p{L}*'),
+  B('ankar\\p{L}*'),
+  B('referensuppdrag\\p{L}*'),
+  B('inringning\\p{L}*'),
+  B('konfidens\\p{L}*'),
+  // Substantivformer av skalan är mekanik; verbet "skalar" (skalbarhet) är
+  // legitim kundsvenska och går fritt.
+  B('skal(?:a|an|ans|or|orna)(?!\\p{L})'),
+  B('protokoll(?:et|en|s)?(?!\\p{L})'),
+  /klassningsprotokoll/iu,
+  B('blast\\s*radius'),
+  B('touchpoint\\p{L}*'),
+  // u-flaggan är obligatorisk: utan den är \p{L} i lookaround teckenklassen
+  // "p{L" och "era B2B-kunder" blir ett falskt BROTT.
+  /(?<![\p{L}\d_])[SB][1-3](?![\p{L}\d_])/u,
+]
+
 /** Rubrikrad: fetstilsrad eller markdown-rubrik som utgör hela raden. Delad
  *  mellan precheck (formkontroll) och report (fältvis jämförelse) så rapporten
  *  läser specen med exakt samma regler som grinden. */
 export const isHeadingLine = (line) =>
   /^\*\*[^*]+\*\*\s*$/.test(line.trim()) || /^#{1,6}\s+\S/.test(line.trim())
 
-export const headingRe = (h) => new RegExp(`^(\\*\\*${h}\\*\\*|#{1,6}\\s*${h})\\s*$`, 'm')
+/**
+ * Specformatets rubriker, EN tabell (ADR-0114). Nyckeln är den svenska
+ * literalen som scripten alltid anropat med; `en` är den engelska literal
+ * specformatet tillåter när önskemålet är på engelska. IPC 14001: alla tio
+ * specutkast fälldes för att rubrikmatchningen bara kände svenska medan
+ * skillen sa "svenska om önskemålet är på svenska" och önskemålet var på
+ * engelska. Literalerna bor här och ingen annanstans: precheck, report och
+ * sectionLines går alla genom `headingRe(key)`.
+ */
+export const SPEC_HEADINGS = [
+  { key: 'Problem', sv: 'Problem', en: 'Problem' },
+  { key: 'Lösning', sv: 'Lösning', en: 'Solution' },
+  { key: 'När det är klart', sv: 'När det är klart', en: 'Done when' },
+  { key: 'Ingår inte', sv: 'Ingår inte', en: 'Not included' },
+  { key: 'Utseende', sv: 'Utseende', en: 'Appearance' },
+  { key: 'Kräver', sv: 'Kräver', en: 'Requires' },
+  { key: 'Villkor', sv: 'Villkor', en: 'Conditions' },
+]
+
+/** Kandidatformens markörrad (ADR-0105): står direkt under titeln i stället
+ *  för Lösning och När det är klart, och routar posten till sitt stopputfall
+ *  utan analys eller poäng. */
+export const KANDIDAT_MARKORER = [
+  { utfall: 'KONCEPT', sv: 'Koncept-kandidat', en: 'Concept candidate' },
+  { utfall: 'DIAGNOS', sv: 'Diagnos-kandidat', en: 'Diagnosis candidate' },
+]
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+/** Regex som matchar en hel rubrikrad för NÅGON av literalerna. */
+const literalsRe = (literals, flags = 'm') => {
+  const alt = [...new Set(literals)].map(escapeRe).join('|')
+  // `#{1,6}\\s+`, aldrig `\\s*`: isHeadingLine kräver mellanslag efter #, och de
+  // två måste se samma rader som rubriker, annars läcker `##Villkor` in i
+  // föregående sektion i sectionLines (granskningsfynd 2026-09-02).
+  return new RegExp(`^(\\*\\*(?:${alt})\\*\\*|#{1,6}\\s+(?:${alt}))\\s*$`, flags)
+}
+
+/** Rubrikregex för en nyckel: en specrubrik matchar båda språkens literal,
+ *  en okänd nyckel (impact-rubrikerna) matchas som literal precis som förut. */
+export const headingRe = (h) => {
+  const row = SPEC_HEADINGS.find((r) => r.key === h)
+  return literalsRe(row ? [row.sv, row.en] : [h])
+}
+
+/**
+ * Rubrikernas språk i ett specblock: 'sv', 'en', 'blandad' (minst en rubrik
+ * ur varje språk) eller null (ingen språkbärande rubrik alls). Problem är
+ * samma ord på båda språk och räknas därför inte. Blandning fälls av precheck:
+ * kunden ser rubrikerna, och opus-varvet i IPC 14001 lämnade engelsk brödtext
+ * under svenska rubriker efter omdispatchen.
+ */
+export const headingLanguage = (block) => {
+  const found = new Set()
+  for (const line of block.split('\n')) {
+    const t = line.trim()
+    for (const row of SPEC_HEADINGS) {
+      if (row.sv === row.en) continue
+      if (literalsRe([row.sv], '').test(t)) found.add('sv')
+      else if (literalsRe([row.en], '').test(t)) found.add('en')
+    }
+  }
+  if (found.size === 0) return null
+  return found.size === 2 ? 'blandad' : [...found][0]
+}
+
+/** Kandidatmarkören i ett block: { utfall, line } eller null. Bara en hel
+ *  rubrikrad räknas, aldrig ett omnämnande i löptext. */
+export const kandidatIn = (block) => {
+  const lines = block.split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    const t = lines[i].trim()
+    for (const m of KANDIDAT_MARKORER)
+      if (literalsRe([m.sv, m.en], '').test(t)) return { utfall: m.utfall, line: i }
+  }
+  return null
+}
+
+export const AVVIKELSE_ETIKETTER = ['ingen', 'precisering', 'motsägelse']
+
+/**
+ * Etiketten på analysens rad `**Avvikelse mot specen:**` (ADR-0106): ordet
+ * direkt efter kolonet, skiftlägesokänsligt, följt av radslut eller ett
+ * skiljetecken/mellanslag. Fritext utan etikett ger null; det är precis den
+ * rad ("bör tillbaka till specen") som scorern aldrig fick en väg att agera på.
+ */
+export const avvikelseEtikett = (text) => {
+  const m = /^\s*\*\*Avvikelse mot specen:\*\*\s*(\p{L}+)(?=$|[\s.,;:!?])/imu.exec(text)
+  if (!m) return null
+  const ord = m[1].toLowerCase()
+  return AVVIKELSE_ETIKETTER.includes(ord) ? ord : null
+}
+
+export const UTFALLSVAL_RAD = { sv: 'Obesvarade utfallsval', en: 'Unanswered outcome choices' }
+export const STRUKET_PREFIX = ['struket:', 'struck:']
+
+export const PRISAVGORANDE_RAD = {
+  sv: 'Prisavgörande öppet val',
+  en: 'Price-decisive open choice',
+}
+
+/** Texten efter `ja:`/`yes:` på raden Prisavgörande öppet val, annars null.
+ *  Raden är specifierns eget stoppsignal (#505, ADR-0118): ett val som
+ *  avgör priset och som den inte kan ta utan att gissa kundens avsikt. */
+export const prisavgorandeVal = (text) => {
+  const re = new RegExp(
+    `^\\*\\*(?:${[PRISAVGORANDE_RAD.sv, PRISAVGORANDE_RAD.en].map(escapeRe).join('|')}):\\*\\*\\s*(ja|yes)\\s*:\\s*(.+)$`,
+    'imu',
+  )
+  const m = re.exec(String(text))
+  return m ? m[2].trim() : null
+}
+
+/** Formen på raden Prisavgörande öppet val: 'nej' | 'ja' | 'ja-utan-text' |
+ *  null (raden saknas). 'ja-utan-text' täcker ett bart ja/yes, en kolon utan
+ *  text efter, och fritext som inte är nej/ja/no/yes. Allt sådant är ett
+ *  ja utan ett läsbart val, och precheck ska fälla det i stället för att
+ *  tyst likställa det med nej (granskningsfynd, #505). */
+export const prisavgorandeForm = (text) => {
+  const radRe = new RegExp(
+    `^\\*\\*(?:${[PRISAVGORANDE_RAD.sv, PRISAVGORANDE_RAD.en].map(escapeRe).join('|')}):\\*\\*\\s*(.*)$`,
+    'imu',
+  )
+  const m = radRe.exec(String(text))
+  if (!m) return null
+  const rest = m[1].trim()
+  if (/^(?:nej|no)(?=$|[\s.,;:!?])/i.test(rest)) return 'nej'
+  if (/^(?:ja|yes)\s*:\s*(\S.*)$/i.test(rest)) return 'ja'
+  return 'ja-utan-text'
+}
+
+const INGA_ORD = ['inga', 'none', '-', 'tom']
+
+/**
+ * Antalet listade, ostrukna alternativ under raden Obesvarade utfallsval
+ * (#507). Raden är en fetstilsrad, inte en rubrik: sektionen är allt till
+ * nästa fetstilsrad eller rubrik. En listpunkt ("- " eller "1. ") på kolumn 0
+ * är ett alternativ; en indenterad rad är en underrad till föregående
+ * alternativ (t.ex. en struket-motivering) och räknas inte för sig. En punkt
+ * som börjar med struket:/struck: räknas inte. null när raden saknas (då
+ * äger precheck felet).
+ */
+export const utfallsvalAlternativ = (text) => {
+  const lines = String(text).replace(/\r\n/g, '\n').split('\n')
+  const radRe = new RegExp(
+    `^\\*\\*(?:${[UTFALLSVAL_RAD.sv, UTFALLSVAL_RAD.en].map(escapeRe).join('|')}):\\*\\*\\s*(.*)$`,
+    'u',
+  )
+  const start = lines.findIndex((l) => radRe.test(l.trim()))
+  if (start === -1) return null
+  const efterKolon = radRe.exec(lines[start].trim())[1].trim().toLowerCase()
+  if (INGA_ORD.includes(efterKolon.replace(/[.]$/, ''))) return 0
+  let antal = 0
+  for (const l of lines.slice(start + 1)) {
+    const t = l.trim()
+    if (isHeadingLine(t) || /^\*\*[^*]+:\*\*/.test(t)) break
+    // Ett alternativ är ett listobjekt på kolumn 0 av originalraden (#507
+    // uppföljning): en indenterad rad under ett objekt är en underrad
+    // (delar av samma alternativ, t.ex. en struket-motivering), inte ett
+    // eget alternativ. Kravet ligger på `l`, inte på den trimmade `t`.
+    const m = /^(?:[-*+]|\d+[.)])\s+(.*)$/.exec(l)
+    if (!m) continue
+    // Prefixtestet körs mot normaliserad text: markdown-emfas (**fetstil**,
+    // _kursiv_, `kod`) runt "struket:" får inte dölja markören för
+    // ostruken-räkningen.
+    const punkt = m[1].replace(/[*_`]/g, '').trim().toLowerCase()
+    if (!STRUKET_PREFIX.some((p) => punkt.startsWith(p))) antal++
+  }
+  return antal
+}
+
+/**
+ * Närmaste katalog, från `dir` och uppåt, som innehåller `file`; sökvägen
+ * till filen eller null. Stannar vid en katalog med ett namn i `stopNames`
+ * (sökningen går aldrig ut ur experimentytan), vid filsystemets rot, och
+ * efter `maxLevels` steg. Används av proveniens: korning.json ligger på
+ * körningsnivå medan stämplingen ibland görs per del-N.
+ */
+export const findUpward = (dir, file, stopNames = ['experiments'], maxLevels = 3) => {
+  let cur = resolve(dir)
+  for (let level = 0; level <= maxLevels; level++) {
+    if (stopNames.includes(basename(cur))) return null
+    const p = join(cur, file)
+    if (existsSync(p)) return p
+    const parent = dirname(cur)
+    if (parent === cur) return null
+    cur = parent
+  }
+  return null
+}
 
 /** Raderna i sektionen under rubriken `heading`, fram till nästa rubrikrad. */
 export const sectionLines = (block, heading) => {
@@ -192,3 +508,159 @@ export const sectionLines = (block, heading) => {
   const end = rest.findIndex((l) => isHeadingLine(l))
   return rest.slice(0, end === -1 ? rest.length : end)
 }
+
+/** Specifierns svar: specblock, vart och ett följt av sitt eget "## Till
+ *  granskaren" (ADR-0118). Titel = rubrikrad som varken är specrubrik (något
+ *  språk), kandidatmarkör eller granskarrubrik; varje titel startar en ny
+ *  spec, ett granskarblock hör till specen den direkt följer. Gamla formatet
+ *  (ett enda block sist efter flera specar) paras med alla specar och märks
+ *  `delat`, så att `granskaBuntBlock` i korning.mjs kan fälla det som BRIST.
+ *  Sonnet-orkestratorn gjorde detta i prosa; nu är det kod som precheck
+ *  prövar resultatet av. */
+export function delaSpecifierSvar(body) {
+  const lines = String(body).replace(/\r\n/g, '\n').split('\n')
+  const isGranskare = (l) => /^##\s+Till granskaren\s*$/u.test(l.trim())
+  const isSpecHeading = (l) => SPEC_HEADINGS.some((row) => headingRe(row.key).test(l.trim()))
+  const isTitle = (l) =>
+    isHeadingLine(l) && !isSpecHeading(l) && kandidatIn(l) === null && !isGranskare(l)
+  // En fristående fetstilsrad ("**...**", hela raden, inget efter): true om
+  // raden utgör en HEL fetstilsrad, med den inre texten (utan "**") som
+  // andra värdet. Skiljer en specTITEL ("**Chefer raderar...**", ingen
+  // avslutande kolon) från en granskarblocks ETIKETTRAD ("**Flaggor:**",
+  // avslutande kolon, värdet på nästa rad eller inget alls).
+  const fetstilsrad = (l) => {
+    const m = /^\*\*([^*]+)\*\*\s*$/u.exec(l.trim())
+    return m ? m[1].trim() : null
+  }
+  // En rad som avslutar ett ÖPPET granskarblock: (1) en rubrik av nivå 1
+  // eller 2 (## eller #) som inte själv är granskarrubriken, eller (2) en
+  // fristående fetstilsrad vars text INTE slutar på kolon - det är en ny
+  // spectitel (specformatet skriver specrubriker som fetstil, ADR-0114/
+  // specformat.md). En fristående fetstilsrad SOM slutar på kolon
+  // ("**Antaganden:**", "**Flaggor:**") är en granskarblocks etikettrad och
+  // hör till blockets EGET innehåll, liksom en djupare underrubrik
+  // (### Flaggor). Granskningsfynd 1: `isTitle` (all fetstil räknas som
+  // rubrik) körd INUTI blocket klippte av det vid varje etikettrad.
+  // Granskningsfynd 2 (regression i fixen för fynd 1): att bara tillåta
+  // #/##-rubriker missade att en bunts specTITLAR i praktiken är fetstil,
+  // inte markdown-rubriker - två bunt-specar med varsitt block kollapsade
+  // till en enda spec.
+  // Granskningsfynd 3 (M8, final-review): en fristående kandidatmarkör utan
+  // kolon ("**Koncept-kandidat**") är varken en granskarrubrik eller en
+  // specTITEL - den hör till blockets EGET innehåll, precis som `isTitle`
+  // redan undantar den från att räknas som en ny spec.
+  const avslutarBlock = (l) => {
+    if (isGranskare(l)) return false
+    if (kandidatIn(l) !== null) return false
+    if (/^#{1,2}\s+\S/.test(l.trim())) return true
+    const inre = fetstilsrad(l)
+    return inre !== null && !inre.endsWith(':')
+  }
+
+  // Pass 1: hitta varje granskarblocks utsträckning (start till nästa
+  // blockavslutande rubrik eller granskarrubrik, annars slutet).
+  const granskareStarts = []
+  lines.forEach((l, i) => {
+    if (isGranskare(l)) granskareStarts.push(i)
+  })
+  const granskareRanges = granskareStarts.map((start) => {
+    let end = lines.length
+    for (let i = start + 1; i < lines.length; i++) {
+      if (avslutarBlock(lines[i]) || isGranskare(lines[i])) {
+        end = i
+        break
+      }
+    }
+    return { start, end, text: lines.slice(start, end).join('\n').trim() }
+  })
+  const iGranskareIntervall = (i) => granskareRanges.some((r) => i >= r.start && i < r.end)
+
+  // Pass 2: dela resten (utanför granskarblocken) i specar via titelrader.
+  const specar = []
+  let cur = null
+  let curStart = -1
+  const stang = () => {
+    if (cur) specar.push({ text: cur.join('\n').trim(), start: curStart })
+    cur = null
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i]
+    if (iGranskareIntervall(i)) continue
+    if (l.trim() === '---') continue
+    if (isTitle(l)) {
+      stang()
+      cur = [l]
+      curStart = i
+      continue
+    }
+    if (cur === null) {
+      if (l.trim() === '') continue
+      cur = [l]
+      curStart = i
+    } else cur.push(l)
+  }
+  stang()
+
+  const medSpec = specar.filter((s) => s.text !== '')
+
+  // Para varje spec med granskarblocket som ligger direkt efter den (före
+  // nästa specs start).
+  const perSpec = medSpec.map((s, i) => {
+    const nasta = i + 1 < medSpec.length ? medSpec[i + 1].start : Infinity
+    const block = granskareRanges.find((r) => r.start > s.start && r.start < nasta)
+    return { spec: s.text, granskarblock: block ? block.text : null }
+  })
+
+  // Gamla formatet: fler än en spec, exakt ETT granskarblock i hela svaret,
+  // och det hör (strukturellt) bara till sista specen. Ett svar där varje
+  // spec redan bär sitt eget block ska INTE märkas delat.
+  const delat =
+    perSpec.length > 1 &&
+    granskareRanges.length === 1 &&
+    perSpec.filter((s) => s.granskarblock !== null).length === 1 &&
+    perSpec[perSpec.length - 1].granskarblock !== null
+
+  if (delat) {
+    const blockText = perSpec[perSpec.length - 1].granskarblock
+    return {
+      specar: perSpec.map((s) => ({ spec: s.spec, granskarblock: blockText })),
+      delat: true,
+    }
+  }
+  return { specar: perSpec, delat: false }
+}
+
+/** DEPS-raden ur dispatch-kontraktet: `installerade` när node_modules/ finns
+ *  under repo-roten, annars `saknas`. */
+export const avgorDeps = (repoRot) =>
+  existsSync(join(repoRot, 'node_modules')) ? 'installerade' : 'saknas'
+
+/** En fakturerad nyckel är begärd när den ÄR modellvärdet eller ett fullt
+ *  id i samma familj (`opus` täcker `claude-opus-5`). Nyckeln kanoniseras av
+ *  anroparen. */
+export const matcharModell = (nyckel, modell) =>
+  nyckel === modell || nyckel === `claude-${modell}` || nyckel.startsWith(`claude-${modell}-`)
+
+/** Schemaläggaren: högst `taket` tickets i flykt, nästa ticket startar när
+ *  en är helt klar. `korTicket(ticket, index)` returnerar ett löfte som löses
+ *  när ticketens samtliga modeller är klara. Ett fel i en ticket stoppar
+ *  aldrig svepet (Batch: "Kör vidare vid fel"); det landar som `{ fel }` i
+ *  resultatet. Resultaten kommer i ticketordning. */
+export async function schemalagg(tickets, taket, korTicket) {
+  if (!Number.isInteger(taket) || taket < 1)
+    throw new Error(`taket måste vara ett heltal >= 1 (fick ${taket})`)
+  const resultat = new Array(tickets.length)
+  let nasta = 0
+  const arbetare = async () => {
+    while (nasta < tickets.length) {
+      const i = nasta++
+      try {
+        resultat[i] = await korTicket(tickets[i], i)
+      } catch (e) {
+        resultat[i] = { fel: e?.message ?? String(e) }
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(taket, tickets.length) }, arbetare))
+  return resultat
+}