@haus-tech/haus-workflow 5.6.1 → 5.7.0

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

@@ -50,6 +50,8 @@ import {
   CLASS_UTFALL,
   SCORE_OUTCOMES,
   CUSTOMER_BLACKLIST,
+  CUSTOMER_BLACKLIST_TVETYDIG,
+  TVA_SIGNAL_RE,
   MODES,
   STEP_RELATIONS,
   KONFIDENS,
@@ -239,7 +241,12 @@ const ANCHOR_RE = /(?<![\p{L}\d_])A(?:1[0-7]|[1-9])(?![\p{L}\d_])/u
 //
 // "poängen är att" behöver ingen lookahead: "är att" följs alltid av en
 // sats, aldrig av en poängangivelse.
-const IDIOM_ALLOW = [/hela\s+poängen\s+(?:med|i)\b(?![^.!?]*\d)/giu, /poängen\s+är\s+att\b/giu]
+const IDIOM_ALLOW = [
+  /hela\s+poängen\s+(?:med|i)\b(?![^.!?]*\d)/giu,
+  /poängen\s+är\s+att\b/giu,
+  /the\s+whole\s+point\s+of\b(?![^.!?]*\d)/giu,
+  /the\s+point\s+is\s+that\b/giu,
+]
 const maskIdioms = (text) =>
   IDIOM_ALLOW.reduce((t, re) => t.replace(re, (m) => '�'.repeat(m.length)), text)
 const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
@@ -261,6 +268,15 @@ const checkCustomerText = (text, field) => {
     const m = masked.match(re)
     if (m && !iUnderlaget(m[0])) problems.push(`${field}: protokollterm "${m[0]}" i kundtext`)
   }
+  // Tvetydig tier: ordet ensamt är legitim engelska. Radformen är identisk med
+  // den entydiga tiern, så kontroll.mjs KUNDTEXT_RE väljer kundtextfixen för
+  // båda.
+  if (TVA_SIGNAL_RE.test(masked)) {
+    for (const re of CUSTOMER_BLACKLIST_TVETYDIG) {
+      const m = masked.match(re)
+      if (m && !iUnderlaget(m[0])) problems.push(`${field}: protokollterm "${m[0]}" i kundtext`)
+    }
+  }
   // Ankarvarningen körs mot ORIGINALET, aldrig mot den maskade strängen.
   // Maskningen bevarar längden men inte innehållet, och varningscitatet ska
   // visa vad som faktiskt stod i texten.

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

@@ -310,12 +310,14 @@ export function hamtaFalt(doc, falt) {
 
 export function omskrivningsPrompt(text, term) {
   return [
-    'Skriv om följande kundtext så att ordet "' +
+    'Rewrite the following customer-facing text so that the word "' +
       term +
-      '" (och böjningar av det) inte förekommer.',
-    'Behåll innebörden och längden. Använd inga ord som beskriver hur ett pris räknats fram',
-    '(poäng, ankare, skala, referensuppdrag, inringning, konfidens, klass, protokoll).',
-    'Svara med enbart den omskrivna texten, utan citattecken och utan kommentar.',
+      '" (and inflections of it) does not appear.',
+    'Keep the meaning and the length. Do not translate the text: answer in the same',
+    'language it is written in. Use no words that describe how a price was derived',
+    '(score, anchor, scale, reference assignment, bracketing, confidence, base class,',
+    'protocol; poäng, ankare, skala, referensuppdrag, inringning, konfidens, klass, protokoll).',
+    'Answer with the rewritten text only, no quotation marks and no commentary.',
     '',
     text,
   ].join('\n')

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

@@ -57,6 +57,7 @@ import {
   claudeDir,
   canonicalModel,
   SPEC_HEADINGS,
+  IMPACT_HEADINGS,
   SCORE_OUTCOMES,
 } from './lib.mjs'
 
@@ -228,6 +229,15 @@ export function assessorPrompt({ repoRot, deps, sprak, spec, granskarblock, mani
     `REPO-ROT: ${repoRot}`,
     `DEPS: ${deps}`,
     sprakRad,
+    // Analysen är intern och skrivs alltid på engelska: assessorskillen
+    // föreskriver IMPACT_HEADINGS:s engelska literaler, och skelettet är
+    // därför den engelska kolumnen. Det är oberoende av SPRÅK, som bara styr
+    // analysens kundvända delar, inte denna interna struktur. Skelettet finns
+    // av samma skäl som specifierns (ADR-0114): modellen ska aldrig gissa
+    // literalen, och en gissning kostar en omdispatch. Arkivets svenska
+    // analyser läses fortfarande, headingRe matchar båda kolumnerna.
+    'RUBRIKER:',
+    ...IMPACT_HEADINGS.map((row) => `**${row.en}**`),
     'KÄLLOR:',
     manifest.trim(),
     '',
@@ -858,10 +868,13 @@ export const granskaBuntBlock = ({ specar, delat }) => {
   const varningar = []
   if (delat && specar.length > 1)
     brister.push(
-      '- granskarblock delat över bunten, ett per spec krävs: skriv "## Till granskaren" direkt efter varje spec',
+      '- granskarblock delat över bunten, ett per spec krävs: skriv rubriken "For the reviewer" (svenska: "Till granskaren") direkt efter varje spec',
     )
   specar.forEach((s, i) => {
-    if (s.granskarblock === null) brister.push(`- spec ${i + 1} saknar Till granskaren-block`)
+    if (s.granskarblock === null)
+      brister.push(
+        `- spec ${i + 1} saknar granskarblock ("For the reviewer", svenska: "Till granskaren")`,
+      )
   })
   for (let i = 0; i < specar.length; i++)
     for (let j = i + 1; j < specar.length; j++)
@@ -940,7 +953,7 @@ function skrivSpec(del, spec, granskarblock, meta, ctx) {
   writeFileSync(path.join(del.dir, 'spec.md'), spec.trim() + '\n')
   if (granskarblock)
     writeFileSync(path.join(del.dir, 'granskarblock.md'), granskarblock.trim() + '\n')
-  else logg(`VARNING ${path.basename(del.dir)}: svaret bar inget Till granskaren-block`)
+  else logg(`VARNING ${path.basename(del.dir)}: svaret bar inget granskarblock (For the reviewer)`)
   addRun(
     del.dir,
     {

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

@@ -266,7 +266,7 @@ export const ankarPoang = (id) => ANKAR_INDEX.get(id)?.poang ?? null
 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
+ *  mäta systematisk felplacering per typ (request-score/SKILL.md, The type), vilket
  *  förutsätter ett slutet värdeförråd (#509). */
 export const TYPER = [
   'Kundvänd funktion',
@@ -285,7 +285,6 @@ 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}*'),
@@ -300,8 +299,46 @@ export const CUSTOMER_BLACKLIST = [
   // 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,
+  // Engelska motsvarigheter (requestmotor engelska artefakter, spec §3):
+  // entydiga termer som fäller ensamma, precis som de svenska ovan.
+  B('reference\\s+assignment\\p{L}*'),
+  B('base\\s+class\\p{L}*'),
+  B('bracketing'),
+]
+
+/**
+ * Tvetydig tier (spec §3): ord som är protokollmekanik hos oss och vanlig
+ * engelska hos kunden ("scale the component", "a confidence interval"). De
+ * fäller bara tillsammans med en andra signal i samma fält — ett poängformat
+ * tal eller ett ankar-id. Ett falskt utslag kostar en omdispatch, ett missat
+ * läckage når kunden, och basfrekvensen är hög: därför två signaler, samma
+ * logik som tvåordsgränsen i språkgrinden (ADR-0122). "bump" hör hemma här
+ * (inte i den entydiga tiern ovan): ordet är vanlig engelska ("bump the
+ * version") lika ofta som det är protokollmekanik. Mönstret är däremot
+ * `bump\p{L}*`, inte `bumps?`: kundens text kan stå på svenska även när
+ * motorns egen prosa är engelsk, och som `bumps?` hade bumpa, bumpade och
+ * bumpning varit ofångbara vid varje signalnivå (ADR-0129).
+ */
+export const CUSTOMER_BLACKLIST_TVETYDIG = [
+  B('scores?(?![\\p{L}\\d_])'),
+  B('scoring(?![\\p{L}\\d_])'),
+  B('anchors?(?![\\p{L}\\d_])'),
+  B('scales?(?![\\p{L}\\d_])'),
+  B('confidence(?![\\p{L}\\d_])'),
+  B('bump\\p{L}*'),
 ]
 
+/** Den andra signalen: ett ankar-id (A1-A17, alltid VERSAL A — en gemen "a"
+ *  som i "a4 paper" räknas inte, lookbehind ger ingen skiftlägesfrihet här),
+ *  ett poängformat tal i 0,25-steg (2.5, 2,75, 2.50 …), eller valfritt tal
+ *  följt av "point(s)"/"poäng". Decimalgrenen är klämd mellan två speglade
+ *  vakter, `(?<!\d\.)` och `(?!\.\d)`, så inget segment av ett punktat
+ *  versionsnummer kan bli den andra signalen: varken sista ledet ("2.5.1")
+ *  eller ett mellanled ("release 10.50.25", "v1.2.75"). Ett ensamt "2,75"
+ *  eller "2.5" är oberört. */
+export const TVA_SIGNAL_RE =
+  /(?<![\p{L}\d_])(?:A(?:1[0-7]|[1-9])|(?<!\d\.)\d+[.,](?:25|5|50|75)(?!\.\d)|\d+\s*(?:[Pp]oints?|[Pp]oäng))(?![\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. */
@@ -327,6 +364,23 @@ export const SPEC_HEADINGS = [
   { key: 'Villkor', sv: 'Villkor', en: 'Conditions' },
 ]
 
+/** Påverkansanalysens rubriker (ADR-0114:s mekanism, nu även för impact.md).
+ *  Analysen är intern och skrivs på engelska; den svenska literalen står kvar
+ *  så att arkivet och pågående poster fortfarande läses. */
+export const IMPACT_HEADINGS = [
+  { key: 'Berörda repon och filer', sv: 'Berörda repon och filer', en: 'Affected repos and files' },
+  { key: 'Datalagring', sv: 'Datalagring', en: 'Data storage' },
+  { key: 'Integrationspunkter', sv: 'Integrationspunkter', en: 'Integration points' },
+  { key: 'Flöden', sv: 'Flöden', en: 'Flows' },
+  { key: 'Gränssnitt', sv: 'Gränssnitt', en: 'Interfaces' },
+  { key: 'Verifiering', sv: 'Verifiering', en: 'Verification' },
+  { key: 'Delbarhet', sv: 'Delbarhet', en: 'Splittability' },
+  { key: 'Konsekvens av fel', sv: 'Konsekvens av fel', en: 'Consequence of failure' },
+  { key: 'Vägval', sv: 'Vägval', en: 'Decisions taken' },
+  { key: 'Antaganden', sv: 'Antaganden', en: 'Assumptions' },
+  { key: 'Beroenden', sv: 'Beroenden', en: 'Dependencies' },
+]
+
 /** 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. */
@@ -335,6 +389,23 @@ export const KANDIDAT_MARKORER = [
   { utfall: 'DIAGNOS', sv: 'Diagnos-kandidat', en: 'Diagnosis candidate' },
 ]
 
+/** Tidsord förbjuds i både spec och analys (precheck: BRISTER). EN regex, så
+ *  reglerna aldrig glider isär, och den bor här i stället för i precheck.mjs så
+ *  att driftvakten kan läsa samma regex som grinden: en skill som själv primar
+ *  modellen med ett ord grinden fäller (uppgift 13: "estimated") fälls i
+ *  testet, inte i nästa skarpa körning. Båda språken, eftersom interna
+ *  dokument nu skrivs på engelska. Tidsord matchas utan inledande gräns så
+ *  sammansättningar (arbetstimmar, halvtimme) fälls. */
+export const TIDSORD_RE =
+  /[\p{L}]*tim(?:me|mar|marna|men)[\p{L}]*|[\p{L}]*estim(?:at|er)[\p{L}]*|(?<![\p{L}\d_])hours?(?![\p{L}\d_])|(?<![\p{L}\d_])man-?days?(?![\p{L}\d_])/iu
+
+/** Poängord i analysen (precheck: VARNING, aldrig brist — "poängen med
+ *  ändringen" och ett ordagrant citerat kod-enum är legitima). Unicode-medvetna
+ *  gränser: JS \b bryter vid å/ä/ö. Delad med driftvakten av samma skäl som
+ *  TIDSORD_RE. */
+export const POANGORD_RE =
+  /(?<![\p{L}\d_])(?:poäng(?:en|er|sätt\p{L}*|sättning\p{L}*)?|scor(?:e|es|ing))(?![\p{L}\d_])/iu
+
 const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 
 /** Regex som matchar en hel rubrikrad för NÅGON av literalerna. */
@@ -346,10 +417,10 @@ const literalsRe = (literals, flags = 'm') => {
   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. */
+/** Rubrikregex för en nyckel: en spec- eller impact-rubrik matchar båda
+ *  språkens literal, en okänd nyckel matchas som literal precis som förut. */
 export const headingRe = (h) => {
-  const row = SPEC_HEADINGS.find((r) => r.key === h)
+  const row = SPEC_HEADINGS.find((r) => r.key === h) ?? IMPACT_HEADINGS.find((r) => r.key === h)
   return literalsRe(row ? [row.sv, row.en] : [h])
 }
 
@@ -374,6 +445,23 @@ export const headingLanguage = (block) => {
   return found.size === 2 ? 'blandad' : [...found][0]
 }
 
+/** Som headingLanguage, fast över IMPACT_HEADINGS. Egen funktion, aldrig en
+ *  flagga på headingLanguage: specens och analysens tabeller ska inte kunna
+ *  fälla varandra när ett dokument citerar den andras rubrik. */
+export const impactHeadingLanguage = (block) => {
+  const found = new Set()
+  for (const line of block.split('\n')) {
+    const t = line.trim()
+    for (const row of IMPACT_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) => {
@@ -386,28 +474,88 @@ export const kandidatIn = (block) => {
   return null
 }
 
+export const TILL_GRANSKAREN = { sv: 'Till granskaren', en: 'For the reviewer' }
+
+/** Granskarblockets etikettrader, `{ key, sv, en }` per rad — nyckeln är den
+ *  svenska literalen som anroparna alltid använt. Tabellen är den enda platsen
+ *  för literalerna; UTFALLSVAL_RAD och PRISAVGORANDE_RAD härleds ur den så att
+ *  de befintliga konsumenterna i lib.mjs behåller sin form. Frusen: raderna
+ *  läses av precheck, korning och kontroll, och en muterad rad hade tyst
+ *  ändrat vad grindarna kräver. */
+export const GRANSKARE_ROWS = Object.freeze(
+  [
+    { key: 'Antaganden', sv: 'Antaganden', en: 'Assumptions' },
+    { key: 'Vägval jag gjort', sv: 'Vägval jag gjort', en: 'Decisions I made' },
+    { key: 'Öppna utfallsval', sv: 'Öppna utfallsval', en: 'Open outcome choices' },
+    {
+      key: 'Prisavgörande öppet val',
+      sv: 'Prisavgörande öppet val',
+      en: 'Price-decisive open choice',
+    },
+    { key: 'Flaggor', sv: 'Flaggor', en: 'Flags' },
+    { key: 'Struket ur underlaget', sv: 'Struket ur underlaget', en: 'Struck from the source' },
+    { key: 'Ej verifierat', sv: 'Ej verifierat', en: 'Not verified' },
+    { key: 'Avvikelse mot specen', sv: 'Avvikelse mot specen', en: 'Deviation from the spec' },
+    {
+      key: 'Obesvarade utfallsval',
+      sv: 'Obesvarade utfallsval',
+      en: 'Unanswered outcome choices',
+    },
+  ].map((row) => Object.freeze(row)),
+)
+
+export const granskareRow = (key) => {
+  const row = GRANSKARE_ROWS.find((r) => r.key === key)
+  if (!row) throw new Error(`okänd granskarblocksrad: ${key}`)
+  return row
+}
+
+/** Regex för en granskarblocksrad `**Etikett:**` i BÅDA språken. Fetstilen och
+ *  kolonet är formkravet: "Flaggor: inga" utan fetstil är inte raden. */
+export const granskareRadRe = (key) => {
+  const row = granskareRow(key)
+  const alt = [...new Set([row.sv, row.en])].map(escapeRe).join('|')
+  return new RegExp(`^\\s*\\*\\*(?:${alt}):\\*\\*`, 'imu')
+}
+
+/** Regex för rubriken `## Till granskaren` i båda språken. */
+export const tillGranskarenRe = () => {
+  const alt = [TILL_GRANSKAREN.sv, TILL_GRANSKAREN.en].map(escapeRe).join('|')
+  return new RegExp(`^#{1,6}\\s+(?:${alt})\\s*$`, 'imu')
+}
+
 export const AVVIKELSE_ETIKETTER = ['ingen', 'precisering', 'motsägelse']
 
+/** Engelsk literal -> svensk nyckel. Nyckeln är kanonisk i hela motorn:
+ *  contract-check, kontroll, korning och archive jämför mot den svenska. */
+export const AVVIKELSE_ALIAS = {
+  ingen: 'ingen',
+  precisering: 'precisering',
+  motsägelse: 'motsägelse',
+  none: 'ingen',
+  refinement: 'precisering',
+  contradiction: '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å.
+ * Etiketten på analysens rad `**Avvikelse mot specen:**` / `**Deviation from
+ * the spec:**` (ADR-0106): ordet direkt efter kolonet, skiftlägesokänsligt,
+ * följt av radslut eller ett skiljetecken. Fritext utan etikett ger null.
+ * RADETIKETTEN är tvåspråkig, inte bara värdet: missas den går en engelsk
+ * motsägelse tyst förbi precheck:s includes-grind till poängsättning.
  */
 export const avvikelseEtikett = (text) => {
-  const m = /^\s*\*\*Avvikelse mot specen:\*\*\s*(\p{L}+)(?=$|[\s.,;:!?])/imu.exec(text)
+  const rad = granskareRadRe('Avvikelse mot specen').source
+  const m = new RegExp(`${rad}\\s*(\\p{L}+)(?=$|[\\s.,;:!?])`, 'imu').exec(String(text))
   if (!m) return null
   const ord = m[1].toLowerCase()
-  return AVVIKELSE_ETIKETTER.includes(ord) ? ord : null
+  return Object.hasOwn(AVVIKELSE_ALIAS, ord) ? AVVIKELSE_ALIAS[ord] : null
 }
 
-export const UTFALLSVAL_RAD = { sv: 'Obesvarade utfallsval', en: 'Unanswered outcome choices' }
+export const UTFALLSVAL_RAD = granskareRow('Obesvarade utfallsval')
 export const STRUKET_PREFIX = ['struket:', 'struck:']
 
-export const PRISAVGORANDE_RAD = {
-  sv: 'Prisavgörande öppet val',
-  en: 'Price-decisive open choice',
-}
+export const PRISAVGORANDE_RAD = granskareRow('Prisavgörande öppet val')
 
 /** Texten efter `ja:`/`yes:` på raden Prisavgörande öppet val, annars null.
  *  Raden är specifierns eget stoppsignal (#505, ADR-0118): ett val som
@@ -583,7 +731,7 @@ export const sectionLines = (block, heading) => {
  *  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 isGranskare = (l) => tillGranskarenRe().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)
@@ -728,3 +876,127 @@ export async function schemalagg(tickets, taket, korTicket) {
   await Promise.all(Array.from({ length: Math.min(taket, tickets.length) }, arbetare))
   return resultat
 }
+
+/**
+ * Literaler som ALDRIG översätts när motorns prosa skrivs om till engelska
+ * (spec §4). De är identifierare, inte språk: script jämför dem literalt, och
+ * ett byte bryter arkivets uppspelbarhet eller Asanas uppslag. Registret har
+ * två uppgifter — det säger vad omskrivningen ska citera ordagrant, och
+ * språkvakten (tests/request-sprakkontrakt.test.js) stryker dem ur texten
+ * innan den mäter språk. En literal som bara finns på ett av ställena hade
+ * gjort vakten fel, därför bor listan här.
+ *
+ * `rubriker` härleds ur de tvåspråkiga tabellernas svenska kolumn i stället
+ * för att kopieras för hand: SPEC_HEADINGS, IMPACT_HEADINGS, GRANSKARE_ROWS,
+ * TILL_GRANSKAREN, KANDIDAT_MARKORER, AVVIKELSE_ETIKETTER och STRUKET_PREFIX:s
+ * svenska entré. Tabellerna är sanningen; en handkopierad lista hade kunnat
+ * glida isär från dem tyst.
+ */
+const RUBRIK_LITERALER = [
+  ...SPEC_HEADINGS.map((r) => r.sv),
+  ...IMPACT_HEADINGS.map((r) => r.sv),
+  ...GRANSKARE_ROWS.map((r) => r.sv),
+  TILL_GRANSKAREN.sv,
+  ...KANDIDAT_MARKORER.map((m) => m.sv),
+  ...AVVIKELSE_ETIKETTER,
+  STRUKET_PREFIX[0],
+]
+
+export const FRYSTA_LITERALER = Object.freeze({
+  promptnycklar: Object.freeze([
+    'SPRÅK:',
+    'KÄLLOR:',
+    'REPO-ROT:',
+    'DEPS:',
+    'MODE:',
+    'DELPOST:',
+    'ESKALERAD:',
+    'REQUEST_ID:',
+    'RUBRIKER:',
+    'LÄSTA:',
+    'MODELL:',
+    'AVVIKELSE:',
+    'RÄTTNINGAR:',
+    'ÖNSKEMÅL:',
+    'SPEC:',
+    'PÅVERKANSANALYS:',
+    'SPEC (godkänd):',
+    'GRANSKARBLOCK',
+    'GRANSKARBLOCK (internt underlag, följer aldrig med i analysens kundtext):',
+    'FULLPLAN:',
+    'TIDIGARE_POANG:',
+  ]),
+  promptvarden: Object.freeze([
+    'installerade',
+    'saknas',
+    'ja',
+    'nej',
+    'inga',
+    'svenska',
+    'engelska',
+    'ja, del N av M',
+  ]),
+  jsonEnum: Object.freeze([
+    ...SCORE_OUTCOMES,
+    ...STEP_RELATIONS,
+    ...KONFIDENS,
+    ...MODES,
+    ...TYPER,
+    'grund',
+    'yta',
+    'omfattning',
+    'ankare',
+    'kalla',
+    'delstrang',
+    'citat',
+    'pastaende',
+  ]),
+  asana: Object.freeze([
+    'Analys',
+    'Påverkansanalys',
+    'Poängsättning',
+    '## Ursprunglig förfrågan',
+    '## Specifikation',
+    '## Lösning och omfattning',
+    'Beställd',
+    'Ej beställd',
+    'Uppskjuten',
+    'Mottaget',
+    'Under bedömning',
+    'Inkommet',
+    'Poängsättning redo för granskning',
+    // Fullständiga fältnamn och statusvärden ur request-sync/SKILL.md.
+    // Redan engelska fältnamn (t.ex. "Original request") räknas också som
+    // identifierare — Asana slår upp dem literalt.
+    'Original request',
+    'Original request title',
+    'Source',
+    'Customer',
+    'Requested by',
+    'Request type',
+    'Funding',
+    'Score',
+    'Has conditions',
+    'Decision',
+    'Decision reason',
+    'Spec iterations',
+    'Score iterations',
+    'Offer status',
+    'Request status',
+    'Kundstatus',
+    'Class rationale',
+    'Kunden skrev själv',
+    'Mejl',
+    'Möte',
+    'Haus initierade',
+    'Bug',
+    'Improvement',
+    'Wear',
+    '📥 Inkommet',
+    '🔍 Spec redo för granskning',
+    '✅ Spec ok',
+    '⚖️ Poängsättning redo för granskning',
+    '📤 Klar – till kund',
+  ]),
+  rubriker: Object.freeze([...new Set(RUBRIK_LITERALER)]),
+})