@haus-tech/haus-workflow 4.5.0 → 4.7.0

package/library/global/skills/request/scripts/contract-check.mjs

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+/**
+ * Mekanisk efterhandskontroll av en classify- eller score-JSON mot sitt
+ * underlag. Fångar det starka modeller ändå slarvar med i lång kontext:
+ * parafraserade "ordagranna" citat, läckta protokolltermer i kundtext, brutna
+ * enum- och upplösningsregler. Bedömer aldrig innehållets rimlighet — bara
+ * kontraktet. Vid BROTT: dispatcha agenten om EN gång med felraderna, sedan
+ * stopp. VARNING är heuristik (t.ex. ankar-id som krockar med pappersformat) —
+ * visas, stoppar inte.
+ *
+ * Användning: node contract-check.mjs <run.json> <spec.md> [impact.md]
+ * Exit 0 = ok, 1 = kontraktsbrott (listade), 2 = användningsfel.
+ */
+import { readFileSync } from 'node:fs'
+
+import { refDriftWarning } from './lib.mjs'
+
+const argv = process.argv.slice(2)
+let expectId = null
+const idFlag = argv.indexOf('--expect-id')
+if (idFlag !== -1) {
+  expectId = argv[idFlag + 1]
+  argv.splice(idFlag, 2)
+}
+const [jsonPath, specPath, impactPath] = argv
+if (!jsonPath || !specPath) {
+  console.error(
+    'användning: node contract-check.mjs <run.json> <spec.md> [impact.md] [--expect-id <id>]',
+  )
+  process.exit(2)
+}
+
+const problems = []
+const warnings = []
+
+// Kontraktsdriftvakt: enums, upplösning och svartlista nedan SPEGLAR reglerna
+// i referensfilerna. Pinsen är markör-strippade (stabila över haus-releaser,
+// som stämplar om filer med paketversionen) och sökvägarna hedrar
+// CLAUDE_CONFIG_DIR — se lib.mjs.
+const EXPECTED_REFS = {
+  'request-classify/references/klassningsinstruktion.md':
+    '811f0bff62c749255e86da7ea8db0ea868ebc9df14262f9889101c110d9d14ff',
+  'request-score/references/poangskala.md':
+    'cb5a6c221b5d39c445ca31a427fd3f96c648388ac5441c22ea2ea5f72e1f8e31',
+}
+for (const [rel, expected] of Object.entries(EXPECTED_REFS)) {
+  const w = refDriftWarning(rel, expected)
+  if (w) warnings.push(w)
+}
+// Markdown-betoning (**fet**, *kursiv*, `kod`) strippas före jämförelse — ett
+// citat som återges utan källans markeringar är fortfarande ordagrant.
+const norm = (s) => s.replace(/[*`]/g, '').replace(/\s+/g, ' ').trim()
+let doc
+try {
+  doc = JSON.parse(readFileSync(jsonPath, 'utf8'))
+} catch (e) {
+  console.log(`BROTT: ${jsonPath} är inte giltig JSON (${e.message})`)
+  process.exit(1)
+}
+// Oläsbart underlag är dispatcherns fel (exit 2), aldrig ett kontraktsbrott —
+// exit 1 skulle trigga en meningslös och dyr omdispatch av agenten.
+let source
+try {
+  source = norm(
+    readFileSync(specPath, 'utf8') + '\n' + (impactPath ? readFileSync(impactPath, 'utf8') : ''),
+  )
+} catch (e) {
+  console.error(`kunde inte läsa underlaget: ${e.message}`)
+  process.exit(2)
+}
+
+/** Ett "ordagrant" citat får hoppa med [...] och kortas med inledande/avslutande …
+ *  — varje kvarvarande segment måste vara exakt substräng av underlaget.
+ *  Ett citat som blir tomt efter filtreringen är INTE ordagrant (annars vore
+ *  "[...]" ett giltigt belägg för vad som helst). */
+const quoteOk = (q) => {
+  const segments = q
+    .split(/\s*\[(?:\.\.\.|…)\]\s*/)
+    .map((seg) => norm(seg.replace(/^(\.\.\.|…)|(\.\.\.|…)$/g, '')))
+    .filter((seg) => seg.length > 0)
+  return segments.length > 0 && segments.every((seg) => source.includes(seg))
+}
+
+/** Alla strängvärden ur ett godtyckligt värde (drivers kan vara objekt). */
+const collectStrings = (v) => {
+  if (typeof v === 'string') return [v]
+  if (Array.isArray(v)) return v.flatMap(collectStrings)
+  if (v && typeof v === 'object') return Object.values(v).flatMap(collectStrings)
+  return []
+}
+
+// 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')
+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,
+]
+// Ankar-id (A1–A17) kolliderar strukturellt med pappersformat (A3/A4/A5) och
+// går inte att regexa isär — heuristik, alltså varning i stället för brott.
+const ANCHOR_RE = /(?<![\p{L}\d_])A(?:1[0-7]|[1-9])(?![\p{L}\d_])/u
+const checkCustomerText = (text, field) => {
+  if (typeof text !== 'string') return
+  for (const re of CUSTOMER_BLACKLIST) {
+    const m = text.match(re)
+    if (m) problems.push(`${field}: protokollterm "${m[0]}" i kundtext`)
+  }
+  const a = text.match(ANCHOR_RE)
+  if (a) warnings.push(`${field}: "${a[0]}" — ankar-id eller pappersformat? Kontrollera`)
+}
+
+/** Poängupplösning: 0.25-steg under 3, heltal från 3, alltid > 0.
+ *  Multiplar av 0.25 är exakta i binär flyttal, så *4-testet är exakt. */
+const checkScoreValue = (score, field) => {
+  if (typeof score !== 'number') {
+    problems.push(`${field}: saknas eller är inte ett tal`)
+    return
+  }
+  if (score <= 0) problems.push(`${field}: ${score} — poäng måste vara större än 0`)
+  else if (score < 3 ? Math.round(score * 4) !== score * 4 : !Number.isInteger(score))
+    problems.push(`${field}: ${score} bryter upplösningen (0.25-steg under 3, heltal från 3)`)
+}
+const checkBracket = (b, field) => {
+  // Under-A1-fallet är kontraktsenligt golvlöst: "Får du inget golv: posten är
+  // mindre än A1 och får A1:s poäng" — då är floor null och taket A1.
+  const floorless = b?.floor == null && b?.ceiling?.anchor === 'A1'
+  if (
+    !(floorless || b?.floor?.anchor) ||
+    !b?.ceiling?.anchor ||
+    !Array.isArray(b?.between) ||
+    !Array.isArray(b?.steps)
+  ) {
+    problems.push(
+      `${field}: ofullständig inringning (floor/ceiling/between/steps krävs; undantag: floor null när taket är A1) — en poäng utan inringning är inte ett giltigt utfall`,
+    )
+    return
+  }
+  if (!floorless && b.between.length !== 2)
+    problems.push(
+      `${field}.between: ${b.between.length} element (kräver exakt 2 angränsande ankare)`,
+    )
+  if (b.steps.length === 0)
+    problems.push(`${field}.steps: tom — inringningen ska redovisa ankarjämförelserna`)
+}
+
+const MODES = ['pricing', 'guard']
+const BASKLASS = ['TINY', 'SMALL', 'MEDIUM', 'LARGE', 'OVER']
+
+// Kuverten är slutna: agenterna får aldrig lägga till egna nycklar ("ordagrant
+// och orört"). Okänd toppnyckel är ett brott, inte en utökning.
+const ENVELOPE_KEYS = {
+  classify: ['request_id', 'mode', 'classification', 'customer', 'guard_diff'],
+  score: [
+    'request_id',
+    'mode',
+    'outcome',
+    'score',
+    'type',
+    'bracket',
+    'drivers',
+    'confidence',
+    'conditions',
+    'assumptions_stated',
+    'alternatives',
+    'dependencies',
+    'notes',
+    'customer_rationale',
+    'guard_diff',
+  ],
+}
+const checkEnvelopeKeys = (kind) => {
+  for (const key of Object.keys(doc))
+    if (!ENVELOPE_KEYS[kind].includes(key))
+      problems.push(`okänd toppnyckel "${key}" — kuvertet är slutet, egna nycklar är förbjudna`)
+}
+
+if (doc.classification !== undefined) {
+  // ---- classify ------------------------------------------------------------
+  const UTFALL = [
+    'TINY',
+    'SMALL',
+    'MEDIUM',
+    'LARGE',
+    'OFFERT',
+    'KONCEPT',
+    'DIAGNOS',
+    'TILLBAKA_TILL_SPEC',
+    'INPUT_SAKNAS',
+    'ESKALERA',
+  ]
+  // Trasig form är brottet, aldrig en krasch — utan '- '-rader har omdispatchen
+  // inget att citera och stacktracen ser ut som ett scriptfel.
+  const c = doc.classification && typeof doc.classification === 'object' ? doc.classification : null
+  if (c === null) {
+    console.log('BROTT (1):')
+    console.log('- classification: null eller inte ett objekt — kuvertet är trasigt')
+    process.exit(1)
+  }
+  checkEnvelopeKeys('classify')
+  if (!MODES.includes(doc.mode)) problems.push(`mode: ogiltigt värde "${doc.mode}"`)
+  if (!UTFALL.includes(c.utfall))
+    problems.push(`classification.utfall: ogiltigt värde "${c.utfall}"`)
+  if (c.basklass != null && !BASKLASS.includes(c.basklass))
+    problems.push(`classification.basklass: ogiltigt värde "${c.basklass}"`)
+  // En klassning utan frågerader har ingen belägglogik alls — tom lista är
+  // samma brott som tomt belägg. Undantag: INPUT_SAKNAS stoppar i Steg 0,
+  // FÖRE frågorna — då är kravet i stället en icke-tom saknas-lista.
+  if (c.utfall === 'INPUT_SAKNAS') {
+    if (!Array.isArray(c.saknas) || c.saknas.length === 0)
+      problems.push(
+        'classification.saknas: tom trots INPUT_SAKNAS — utfallet ska lista vad som saknas',
+      )
+  } else if (!Array.isArray(c.fragor) || c.fragor.length === 0) {
+    problems.push(
+      'classification.fragor: saknas eller är tom — varje körning ska redovisa sina frågerader',
+    )
+  }
+  const fragorRows = Array.isArray(c.fragor) ? c.fragor : []
+  for (const f0 of fragorRows) {
+    if (f0 == null || typeof f0 !== 'object') {
+      problems.push('fragor: en rad är null eller inte ett objekt')
+      continue
+    }
+    const f = f0
+    // S1–S3/B1–B3 svarar JA/NEJ; basklassraden svarar med en klass
+    // (instruktionens JSON, "ordagrant och orört" — tvinga aldrig om den).
+    if (/^[SB][1-3]$/i.test(f.id ?? '')) {
+      if (!['JA', 'NEJ'].includes(f.svar))
+        problems.push(`fråga ${f.id}: svar "${f.svar}" (kräver JA/NEJ)`)
+    } else if (!BASKLASS.includes(f.svar) && !['JA', 'NEJ'].includes(f.svar)) {
+      problems.push(`fråga ${f.id}: svar "${f.svar}" (kräver basklassvärde eller JA/NEJ)`)
+    }
+    if (typeof f.konfidens !== 'number' || f.konfidens < 0 || f.konfidens > 1)
+      problems.push(`fråga ${f.id}: konfidens ${f.konfidens} utanför 0–1`)
+    // Belägg är obligatoriskt per instruktionen — saknat belägg är brottet,
+    // inte låg kvalitet.
+    if (!f.belagg || norm(f.belagg).length === 0)
+      problems.push(`fråga ${f.id}: belägg saknas (obligatoriskt, ordagrant citat)`)
+    else if (!quoteOk(f.belagg))
+      problems.push(
+        `fråga ${f.id}: belägg är inte ordagrant citat ur underlaget: "${f.belagg.slice(0, 70)}..."`,
+      )
+  }
+  checkCustomerText(doc.customer?.rationale, 'customer.rationale')
+  for (const [i, cond] of (doc.customer?.conditions ?? []).entries())
+    checkCustomerText(cond, `customer.conditions[${i}]`)
+  for (const [i, dep] of (doc.customer?.dependencies ?? []).entries())
+    checkCustomerText(dep, `customer.dependencies[${i}]`)
+} else if (doc.outcome !== undefined) {
+  // ---- score ---------------------------------------------------------------
+  const OUTCOMES = [
+    'POANG',
+    'KONCEPT',
+    'DIAGNOS',
+    'TILLBAKA_TILL_SPEC',
+    'DELA_UPP',
+    'OVER_SKALAN',
+    'INPUT_SAKNAS',
+  ]
+  checkEnvelopeKeys('score')
+  if (!MODES.includes(doc.mode)) problems.push(`mode: ogiltigt värde "${doc.mode}"`)
+  if (!OUTCOMES.includes(doc.outcome)) problems.push(`outcome: ogiltigt värde "${doc.outcome}"`)
+  if (!['hog', 'medel', 'lag'].includes(doc.confidence))
+    problems.push(`confidence: ogiltigt värde "${doc.confidence}"`)
+  if (doc.outcome === 'POANG') {
+    checkScoreValue(doc.score, 'score')
+    checkBracket(doc.bracket, 'bracket')
+    if (!Array.isArray(doc.drivers) || doc.drivers.length < 2 || doc.drivers.length > 3)
+      problems.push(
+        `drivers: ${Array.isArray(doc.drivers) ? doc.drivers.length : 'saknas'} (skillen kräver två eller tre faktorer)`,
+      )
+  } else if (doc.score != null) {
+    problems.push(`score: ska vara null när outcome är ${doc.outcome}`)
+  }
+  // Citat i drivers (även i objektform) ska vara ordagranna ur underlaget.
+  // Både raka och typografiska citattecken räknas. Ett icke-array-värde är
+  // redan fällt av POANG-kontrollen ovan — här skyddar vi bara iterationen.
+  for (const [i, d] of (Array.isArray(doc.drivers) ? doc.drivers : []).entries())
+    for (const str of collectStrings(d))
+      for (const m of str.matchAll(/["“”„«»]([^"“”„«»]{15,})["“”„«»]/g))
+        if (!quoteOk(m[1]))
+          problems.push(
+            `drivers[${i}]: citat är inte ordagrant ur underlaget: "${m[1].slice(0, 70)}..."`,
+          )
+  checkCustomerText(doc.customer_rationale, 'customer_rationale')
+  for (const [i, cond] of (doc.conditions ?? []).entries())
+    checkCustomerText(cond, `conditions[${i}]`)
+  for (const [i, a] of (doc.assumptions_stated ?? []).entries())
+    checkCustomerText(a, `assumptions_stated[${i}]`)
+  // Alternativa lösningar bär samma kontrakt som huvudpoängen: kundspråk i
+  // label, giltig upplösning, och "ett alternativ utan inringning är lika
+  // ogiltigt som en post utan".
+  for (const [i, alt] of (doc.alternatives ?? []).entries()) {
+    checkCustomerText(alt?.label, `alternatives[${i}].label`)
+    checkCustomerText(alt?.adds, `alternatives[${i}].adds`)
+    if (alt?.score != null) {
+      checkScoreValue(alt.score, `alternatives[${i}].score`)
+      checkBracket(alt?.bracket, `alternatives[${i}].bracket`)
+    }
+  }
+} else {
+  problems.push('okänd dokumenttyp: varken classification (classify) eller outcome (score)')
+}
+
+// Kuvertets request_id ska höra till katalogen det arkiveras i.
+if (expectId != null && doc.request_id !== expectId)
+  problems.push(`request_id: "${doc.request_id}" matchar inte förväntat "${expectId}"`)
+
+for (const w of warnings) console.log(`VARNING: ${w}`)
+if (problems.length === 0) {
+  console.log('OK: kontraktet håller')
+  process.exit(0)
+}
+console.log(`BROTT (${problems.length}):`)
+for (const p of problems) console.log(`- ${p}`)
+process.exit(1)

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

@@ -0,0 +1,113 @@
+/**
+ * Delade byggstenar för requestmotorns kontrollscript. En kopia av varje regel:
+ * 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 { createHash } from 'node:crypto'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+/**
+ * Claude-konfigkatalogen. Installern hedrar CLAUDE_CONFIG_DIR (#278) — det ska
+ * scripten också göra, annars läser driftvakten fel eller kvarlämnat träd på
+ * relokerade maskiner.
+ */
+export function claudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude')
+}
+
+/**
+ * Tar bort haus ägarmarkör ur filinnehåll före hashning. Installern stämplar
+ * varje fil med paketversionen i markören, så en hash ÖVER markören byter värde
+ * vid varje release utan att innehållet ändrats — driftvakten skulle bli
+ * permanent brus och guardens skevhetsvägran skulle ogiltigförklara alla
+ * arkiverade körningar vid varje haus-uppgradering. Strippningen är idempotent
+ * och en no-op på ostämplade filer.
+ */
+export function stripHausMarker(content) {
+  return content
+    .split('\n')
+    .filter(
+      (line, i) =>
+        !(
+          line.startsWith('<!-- HAUS-MANAGED') ||
+          ((i === 0 || i === 1) && line.startsWith('// HAUS-MANAGED')) ||
+          /^haus_managed:\s/.test(line)
+        ),
+    )
+    .join('\n')
+}
+
+/** sha256 (hex) över markör-strippat filinnehåll. */
+export function markerStrippedSha256(path) {
+  return createHash('sha256')
+    .update(stripHausMarker(readFileSync(path, 'utf8')))
+    .digest('hex')
+}
+
+/**
+ * Kontraktsdriftvakt: jämför en referensfils markör-strippade hash mot den pin
+ * scriptet byggdes mot. Returnerar en varningssträng eller null — anroparen
+ * väljer kanal (precheck/contract-check samlar i sin rapport, compare-scripten
+ * skriver till stderr så verdiktraden på stdout förblir ren).
+ */
+export function refDriftWarning(relSkillPath, expectedSha) {
+  const p = join(claudeDir(), 'skills', relSkillPath)
+  try {
+    if (markerStrippedSha256(p) !== expectedSha)
+      return `referensfilen ${p} har ändrats sedan scriptet skrevs — se över att kontrollerna fortfarande speglar den`
+  } catch {
+    return `referensfilen ${p} gick inte att läsa för driftkontroll`
+  }
+  return null
+}
+
+/**
+ * Dispatcher-räls för compare-scripten: argv, samma-fil-vägran, läs+parse,
+ * byteidentisk-vägran och mode-kontroll. Exit 2 = jämförelsen kan inte göras
+ * (dispatcherns fel, aldrig LIKA). Returnerar { a, b } (hela dokumenten).
+ */
+export function loadRunPair(usage) {
+  const [aPath, bPath] = process.argv.slice(2)
+  if (!aPath || !bPath) {
+    console.error(usage)
+    process.exit(2)
+  }
+  if (resolve(aPath) === resolve(bPath)) {
+    console.error('samma fil två gånger — driftvakten kräver två oberoende körningar')
+    process.exit(2)
+  }
+  let rawA, rawB, a, b
+  try {
+    rawA = readFileSync(aPath, 'utf8')
+    rawB = readFileSync(bPath, 'utf8')
+    a = JSON.parse(rawA)
+    b = JSON.parse(rawB)
+  } catch (e) {
+    console.error(`kunde inte läsa körningarna: ${e.message}`)
+    process.exit(2)
+  }
+  if (rawA === rawB) {
+    console.error(
+      'filerna är byteidentiska — två oberoende körningar är aldrig det; fel fil skickad?',
+    )
+    process.exit(2)
+  }
+  if (a.mode !== 'pricing' || b.mode !== 'pricing') {
+    console.error(`båda körningarna måste vara mode pricing (fick "${a.mode}" och "${b.mode}")`)
+    process.exit(2)
+  }
+  return { a, b }
+}
+
+/** Skriver LIKA (exit 0) eller OLIKA + diffrader (exit 1) på stdout. */
+export function reportDiffs(diffs) {
+  if (diffs.length === 0) {
+    console.log('LIKA')
+    process.exit(0)
+  }
+  console.log(`OLIKA (${diffs.length}):`)
+  for (const d of diffs) console.log(`- ${d}`)
+  process.exit(1)
+}

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

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+/**
+ * Mekanisk förhandskontroll av en requestpost i arkivet, före dyra
+ * bedömningskörningar. Kontrollerar ENDAST form, aldrig innehåll — en post som
+ * passerar kan fortfarande stoppas av protokollen (TILLBAKA_TILL_SPEC m.fl.),
+ * och det är deras jobb, inte det här scriptets. Returnerar därför ett eget
+ * status (ok/fel-lista), aldrig ett protokollutfall.
+ *
+ * BRISTER (exit 1) är hårda formfel. VARNING är heuristik som kräver mänsklig
+ * blick (klassord i analys, saknad Ingår inte) — de skrivs ut men stoppar inget.
+ *
+ * Användning: node precheck.mjs <arkivkatalog> [--impact]
+ *   --impact  kräv och kontrollera även impact.md (bedöm-steget)
+ * Exit 0 = ok, 1 = brister (listade på stdout), 2 = användningsfel.
+ */
+import { readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { markerStrippedSha256, refDriftWarning } from './lib.mjs'
+
+const dir = process.argv[2]
+const requireImpact = process.argv.includes('--impact')
+if (!dir) {
+  console.error('användning: node precheck.mjs <arkivkatalog> [--impact]')
+  process.exit(2)
+}
+
+const problems = []
+const warnings = []
+
+// Kontraktsdriftvakt: rubrik- och vokabulärreglerna nedan speglar specformatet.
+// Pinnen är markör-strippad (stabil över haus-releaser, som stämplar om filer
+// med paketversionen) och sökvägen hedrar CLAUDE_CONFIG_DIR — se lib.mjs.
+const SPECFORMAT_SHA = '53bbb92ad6337557901e827c97a0995ff92150f88e0ede2810a28f36b51aa17c'
+{
+  const w = refDriftWarning('request-write-spec/references/specformat.md', SPECFORMAT_SHA)
+  if (w) warnings.push(w)
+}
+
+// Tidsord förbjuds i både spec och analys — EN regex, så reglerna aldrig glider isär.
+const TIDSORD_RE = /[\p{L}]*tim(?:me|mar|marna|men)[\p{L}]*|[\p{L}]*estim(?:at|er)[\p{L}]*/iu
+
+// JS \b bryter vid å/ä/ö — svenska ord kräver Unicode-medvetna gränser
+// ("kräver" får aldrig matcha förbudet "kr").
+const W = (pat) => new RegExp(`(?<![\\p{L}\\d_])(?:${pat})(?![\\p{L}\\d_])`, 'iu')
+// Rubrikrad: fetstilsrad eller markdown-rubrik som utgör hela raden.
+const isHeadingLine = (line) =>
+  /^\*\*[^*]+\*\*\s*$/.test(line.trim()) || /^#{1,6}\s+\S/.test(line.trim())
+const headingRe = (h) => new RegExp(`^(\\*\\*${h}\\*\\*|#{1,6}\\s*${h})\\s*$`, 'm')
+/** Raderna i sektionen under rubriken `heading`, fram till nästa rubrikrad. */
+const sectionLines = (block, heading) => {
+  const lines = block.split('\n')
+  const start = lines.findIndex((l) => headingRe(heading).test(l.trim()))
+  if (start === -1) return null
+  const rest = lines.slice(start + 1)
+  const end = rest.findIndex((l) => isHeadingLine(l))
+  return rest.slice(0, end === -1 ? rest.length : end)
+}
+
+const read = (name, required) => {
+  const p = join(dir, name)
+  if (!existsSync(p)) {
+    if (required) problems.push(`${name}: saknas`)
+    return null
+  }
+  return readFileSync(p, 'utf8')
+}
+
+// ---- spec.md ---------------------------------------------------------------
+const spec = read('spec.md', true)
+if (spec != null) {
+  // En katalog = en spec. Specformatet föreskriver ingen separator mellan
+  // specar, så bunt-detektionen räknar den obligatoriska Problem-rubriken över
+  // hela filen — fler än en betyder att en bunt inte delats i egna kataloger,
+  // och då klassas två beslut som en post (fel pris åt något håll).
+  const problemCount = (spec.match(new RegExp(headingRe('Problem').source, 'gm')) ?? []).length
+  if (problemCount > 1)
+    problems.push(
+      `spec.md: ${problemCount} "Problem"-rubriker i en katalog — en spec per katalog, dela bunten först`,
+    )
+  const blocks = spec
+    .split(/\n---\n/)
+    .map((b) => b.trim())
+    .filter(Boolean)
+  if (blocks.length === 0) problems.push('spec.md: tom')
+  blocks.forEach((block, i) => {
+    const label = blocks.length > 1 ? `spec.md block ${i + 1}` : 'spec.md'
+    // Obligatoriskt per specformatet: Problem, Lösning, När det är klart.
+    // Ingår inte är valfri i formatet ("ibland ingen alls") — saknad blir varning.
+    for (const heading of ['Problem', 'Lösning', 'När det är klart'])
+      if (!headingRe(heading).test(block)) problems.push(`${label}: rubriken "${heading}" saknas`)
+    if (!headingRe('Ingår inte').test(block))
+      warnings.push(`${label}: "Ingår inte" saknas — ofta rätt att ringa in vad som inte ingår`)
+    // 2–5 numrerade punkter under När det är klart, avgränsat vid nästa
+    // rubrikrad (inte vid första ** — fetstil inuti en punkt är tillåten).
+    const sect = sectionLines(block, 'När det är klart')
+    if (sect != null) {
+      const items = sect.filter((l) => /^\d+\.\s/.test(l.trim()))
+      if (items.length < 2 || items.length > 5)
+        problems.push(`${label}: "När det är klart" har ${items.length} punkter (kräver 2–5)`)
+      for (const it of items)
+        if (W('eller').test(it))
+          problems.push(`${label}: "eller" i utfallspunkt: ${it.trim().slice(0, 60)}`)
+    }
+  })
+  // Förbjuden vokabulär i hela specen (tid, pengar, hedge-ord). Tidsord matchas
+  // utan inledande gräns så sammansättningar (arbetstimmar, halvtimme) fälls.
+  // "kr" kräver siffra före sig — annars fälls identifierare som "KR-2".
+  const banned = ['förslagsvis', 'alternativt', 'beroende på', 'en lämplig', 'kronor', 'SEK']
+  for (const word of banned) {
+    const m = spec.match(W(word))
+    if (m) problems.push(`spec.md: förbjudet ord "${m[0]}"`)
+  }
+  // Bindestreck friar identifierare ("punkt 3: KR-2" är inget belopp).
+  const kr = spec.match(/\d[\s.,:]*kr(?![\p{L}\d_-])/iu)
+  if (kr) problems.push(`spec.md: belopp "${kr[0].trim()}"`)
+  const time = spec.match(TIDSORD_RE)
+  if (time) problems.push(`spec.md: förbjudet tidsord "${time[0]}"`)
+}
+
+// ---- granskarblock.md ------------------------------------------------------
+const gb = read('granskarblock.md', true)
+if (gb != null) {
+  if (!gb.includes('## Till granskaren'))
+    problems.push('granskarblock.md: rubriken "## Till granskaren" saknas')
+  for (const row of [
+    'Antaganden',
+    'Vägval jag gjort',
+    'Öppna utfallsval',
+    'Flaggor',
+    'Struket ur underlaget',
+  ])
+    if (!gb.includes(`**${row}:**`)) problems.push(`granskarblock.md: raden "**${row}:**" saknas`)
+}
+
+// ---- impact.md (bedöm-steget) ---------------------------------------------
+if (requireImpact) {
+  const impact = read('impact.md', true)
+  if (impact != null) {
+    const headings = [
+      'Berörda repon och filer',
+      'Datalagring',
+      'Integrationspunkter',
+      'Flöden',
+      'Gränssnitt',
+      'Verifiering',
+      'Delbarhet',
+      'Konsekvens av fel',
+      'Vägval',
+      'Antaganden',
+      'Beroenden',
+    ]
+    for (const h of headings)
+      if (!headingRe(h).test(impact)) problems.push(`impact.md: rubriken "${h}" saknas`)
+    if (!impact.includes('## Till granskaren'))
+      problems.push('impact.md: "## Till granskaren" saknas')
+    for (const row of ['Ej verifierat', 'Avvikelse mot specen', 'Obesvarade utfallsval'])
+      if (!impact.includes(`**${row}:**`)) problems.push(`impact.md: raden "**${row}:**" saknas`)
+    // Analysen får inte läcka klass eller tid. Klassord är dock en heuristik —
+    // "felklassen", "den klassen (av ändringar)" och ett ordagrant citerat
+    // kod-enum (MEDIUM/LARGE i ett repo) är legitima — så träffar blir
+    // varningar för mänsklig blick, aldrig hårda stopp. Tidsord förblir hårda.
+    const m = impact.match(W('klass(?:er|en|ning\\p{L}*)?'))
+    if (m)
+      warnings.push(
+        `impact.md: klassord "${m[0]}" — kontrollera att analysen inte läcker klassning`,
+      )
+    const cls = impact.match(/(?<![\p{L}\d_])(TINY|SMALL|MEDIUM|LARGE|OFFERT)(?![\p{L}\d_])/u)
+    if (cls)
+      warnings.push(
+        `impact.md: klassnamnet "${cls[0]}" — läcka, eller citat av ett kod-enum? Kontrollera`,
+      )
+    const t = impact.match(TIDSORD_RE)
+    if (t) problems.push(`impact.md: förbjudet tidsord "${t[0]}"`)
+  }
+}
+
+// ---- state.json ------------------------------------------------------------
+const state = read('state.json', true)
+if (state != null) {
+  try {
+    const s = JSON.parse(state)
+    for (const key of ['request_id', 'slug', 'title', 'status', 'runs'])
+      if (!(key in s)) problems.push(`state.json: fältet "${key}" saknas`)
+    // Underlagsproveniens: analysen måste höra till DEN spec som ligger i
+    // katalogen nu. En respec efter underkännande lämnar annars en gammal
+    // analys som prissätts mot ny spec — helt osynligt utan den här kontrollen.
+    if (requireImpact && spec != null && Array.isArray(s.runs)) {
+      const impactRun = [...s.runs].reverse().find((r) => r.file === 'impact.md')
+      const recorded = impactRun?.underlag_sha256?.['spec.md']
+      if (recorded == null) {
+        // Tystnad här är exakt skevheten grinden finns för — varna alltid när
+        // analysen inte kan knytas till specen, oavsett varför.
+        warnings.push(
+          impactRun
+            ? 'state.json: analysens runs-rad saknar underlag_sha256 — kan inte verifiera att analysen hör till nuvarande spec'
+            : 'state.json: impact.md finns men ingen runs-rad för den — kan inte verifiera att analysen hör till nuvarande spec',
+        )
+      } else if (recorded !== markerStrippedSha256(join(dir, 'spec.md'))) {
+        problems.push(
+          'impact.md: analysen gjordes mot en annan version av spec.md — kör om analysen innan posten bedöms',
+        )
+      }
+    }
+  } catch {
+    problems.push('state.json: ogiltig JSON')
+  }
+}
+
+for (const w of warnings) console.log(`VARNING: ${w}`)
+if (problems.length === 0) {
+  console.log('OK: formkontrollen passerad')
+  process.exit(0)
+}
+console.log(`BRISTER (${problems.length}):`)
+for (const p of problems) console.log(`- ${p}`)
+process.exit(1)

package/library/global/skills/request/scripts/ref-hash.mjs

@@ -0,0 +1,22 @@
+/**
+ * Skriver den markör-strippade sha256:an för en fil — den enda hash som är
+ * stabil över haus-releaser (installern stämplar om filer med paketversionen).
+ * Används av /request-wrappern för state.json:s reference_sha256 och
+ * underlag_sha256, och är samma hashdefinition som driftvakterna i lib.mjs.
+ *
+ * Användning: node ref-hash.mjs <fil>
+ * Exit 0 + hex-hash på stdout; 2 = användningsfel/oläsbar fil.
+ */
+import { markerStrippedSha256 } from './lib.mjs'
+
+const [file] = process.argv.slice(2)
+if (!file) {
+  console.error('användning: node ref-hash.mjs <fil>')
+  process.exit(2)
+}
+try {
+  console.log(markerStrippedSha256(file))
+} catch (e) {
+  console.error(`kunde inte läsa ${file}: ${e.message}`)
+  process.exit(2)
+}