@haus-tech/haus-workflow 5.0.1 → 5.2.0

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

@@ -16,7 +16,22 @@
 import { readFileSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { markerStrippedSha256, refDriftWarning, headingRe, sectionLines } from './lib.mjs'
+import {
+  markerStrippedSha256,
+  refDriftWarning,
+  headingRe,
+  sectionLines,
+  isHeadingLine,
+  SPEC_HEADINGS,
+  headingLanguage,
+  kandidatIn,
+  avvikelseEtikett,
+  AVVIKELSE_ETIKETTER,
+  utfallsvalAlternativ,
+  utfallsvalProsa,
+  prisavgorandeVal,
+  prisavgorandeForm,
+} from './lib.mjs'
 
 const dir = process.argv[2]
 const requireImpact = process.argv.includes('--impact')
@@ -27,11 +42,19 @@ if (!dir) {
 
 const problems = []
 const warnings = []
+// Rader orkestratorn läser ur stdout i stället för ur filerna (ADR-0105,
+// 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.
+const kandidater = []
+let avvikelse = null
+let prisavgorande = null
 
 // 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 = 'e6134fd8a3c1cc9e3056c849d8834310e39d269846f2b6bec2871a83d488fc01'
+const SPECFORMAT_SHA = '2e26f9270ced172cd9903f53384a4f7ad0f972084045040c263bf01dc7a6e422'
 {
   const w = refDriftWarning('request-write-spec/references/specformat.md', SPECFORMAT_SHA)
   if (w) warnings.push(w)
@@ -53,6 +76,55 @@ const read = (name, required) => {
   return readFileSync(p, 'utf8')
 }
 
+/** Rubrikradens text utan fetstil- eller #-markering. */
+const headingText = (line) =>
+  line
+    .trim()
+    .replace(/^\*\*(.+)\*\*$/, '$1')
+    .replace(/^#{1,6}\s*/, '')
+    .trim()
+
+/** En specrubrik enligt tabellen, på något av språken. */
+const isSpecHeading = (line) => SPEC_HEADINGS.some((row) => headingRe(row.key).test(line.trim()))
+
+/** Vilka språkbärande rubriker blocket har, per språk. Literalerna kommer ur
+ *  SPEC_HEADINGS, aldrig härifrån; Problem är neutral och räknas inte. */
+const headingsByLanguage = (block) => {
+  const sv = []
+  const en = []
+  for (const line of block.split('\n')) {
+    if (!isHeadingLine(line)) continue
+    const text = headingText(line)
+    for (const row of SPEC_HEADINGS) {
+      if (row.sv === row.en) continue
+      if (text === row.sv) sv.push(row.sv)
+      else if (text === row.en) en.push(row.en)
+    }
+  }
+  return { sv, en }
+}
+
+/**
+ * Kandidatformen (ADR-0105): titel, markör direkt under titeln, Problem.
+ * Titel = första rubrikrad som varken är en specrubrik eller en markör;
+ * saknas titel ska markören vara blockets första rubrikrad. Lösning och När
+ * det är klart är då fel form, antingen spec eller kandidat. Ingår inte,
+ * Kräver och Villkor tillåts, och ingen 2–5-punktskontroll görs.
+ */
+const checkKandidatForm = (block, kandidat, label) => {
+  const lines = block.split('\n')
+  const headings = lines.map((l, i) => (isHeadingLine(l) ? i : -1)).filter((i) => i !== -1)
+  const title = headings.find((i) => !isSpecHeading(lines[i]) && kandidatIn(lines[i]) == null)
+  const expected = title == null ? headings[0] : headings.find((i) => i > title)
+  if (expected !== kandidat.line)
+    problems.push(
+      `${label}: kandidatmarkören ska stå som första rubrikrad${title == null ? '' : ' efter titeln'}`,
+    )
+  for (const heading of ['Lösning', 'När det är klart'])
+    if (headingRe(heading).test(block))
+      problems.push(`${label}: kandidat med ${heading}: antingen spec eller kandidat`)
+}
+
 // ---- spec.md ---------------------------------------------------------------
 const spec = read('spec.md', true)
 if (spec != null) {
@@ -72,10 +144,29 @@ if (spec != null) {
   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'])
+    // Rubrikspråk (ADR-0114): specen skrivs på önskemålets språk och rubrikerna
+    // på samma språk som brödtexten. Brödtexten kontrolleras inte, men rubriker
+    // ur båda språken i samma block fälls, kunden ser rubrikerna. Vilka som
+    // hittades per språk namnges så rättningen blir riktad.
+    if (headingLanguage(block) === 'blandad') {
+      const { sv, en } = headingsByLanguage(block)
+      problems.push(
+        `${label}: rubriker på två språk (sv: ${sv.join(', ')}, en: ${en.join(', ')}), välj ett`,
+      )
+    }
+    // Obligatoriskt per specformatet: Problem, alltid. Lösning och När det är
+    // klart bara i spec-formen; kandidatformen (ADR-0105) ersätter dem med
+    // markören och routar posten till sitt stopputfall utan analys och poäng.
+    if (!headingRe('Problem').test(block)) problems.push(`${label}: rubriken "Problem" saknas`)
+    const kandidat = kandidatIn(block)
+    if (kandidat) {
+      kandidater.push(kandidat.utfall)
+      checkKandidatForm(block, kandidat, label)
+      return
+    }
+    for (const heading of ['Lösning', 'När det är klart'])
       if (!headingRe(heading).test(block)) problems.push(`${label}: rubriken "${heading}" saknas`)
+    // Ingår inte är valfri i formatet ("ibland ingen alls"), saknad blir varning.
     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
@@ -114,10 +205,22 @@ if (gb != null) {
     'Antaganden',
     'Vägval jag gjort',
     'Öppna utfallsval',
+    'Prisavgörande öppet val',
     'Flaggor',
     'Struket ur underlaget',
   ])
     if (!gb.includes(`**${row}:**`)) problems.push(`granskarblock.md: raden "**${row}:**" saknas`)
+  // Prisavgörande öppet val (#505, ADR-0118): specifierns eget stoppsignal när
+  // ett öppet val avgör priset. Skrivs på stdout för orkestratorn, före
+  // KANDIDAT-raderna. En form som varken är nej eller ett ja med text (bart
+  // ja/yes, kolon utan text, fritext utan etikett) är en BRIST: den ser ut
+  // som ett svar men går inte att läsa, och ska aldrig tyst behandlas som
+  // nej (granskningsfynd, #505).
+  if (prisavgorandeForm(gb) === 'ja-utan-text')
+    problems.push(
+      'granskarblock.md: raden "**Prisavgörande öppet val:**" ska vara "nej" eller "ja: <valet i en mening>"',
+    )
+  prisavgorande = prisavgorandeVal(gb)
 }
 
 // ---- impact.md (bedöm-steget) ---------------------------------------------
@@ -143,6 +246,41 @@ if (requireImpact) {
       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`)
+    // Avvikelseetikett (ADR-0106): raden måste börja med en av de tre
+    // etiketterna, annars har scorern ingen väg att agera på den. Form, aldrig
+    // innehåll: etikettvärdet påverkar inte exitkoden, grinden för motsägelse
+    // ligger i orkestratorn och contract-check. En gammal analys utan etikett
+    // fälls också, kostnaden är en assessor-dispatch per pågående post.
+    if (impact.includes('**Avvikelse mot specen:**')) {
+      avvikelse = avvikelseEtikett(impact)
+      if (avvikelse == null)
+        problems.push(
+          `impact.md: raden "**Avvikelse mot specen:**" ska börja med en etikett: ${AVVIKELSE_ETIKETTER.join(', ')}`,
+        )
+      // #507 (ADR-0117): motsägelse betyder att inget listat alternativ
+      // levererar specens Problem. Bär analysen ändå alternativ är etiketten
+      // fel satt, och posten dispatchas om i stället för att stoppas tyst.
+      const alternativ = utfallsvalAlternativ(impact)
+      if (avvikelse === 'motsägelse' && alternativ !== null && alternativ > 0)
+        problems.push(
+          `impact.md: motsägelse med ${alternativ} listade alternativ under "Obesvarade utfallsval": välj precisering och låt fyrstegsregeln avgöra, eller stryk alternativen med prefixet "struket:" och skälet`,
+        )
+      // #520: alternativ i löptext ("(a) … (b) …") räknas inte som listade
+      // och passerade grinden ovan som om raden vore "inga". Formen krävs:
+      // vid motsägelse är prosa en BRIST (grinden kan annars inte avgöra om
+      // etiketten är rätt), vid precisering en VARNING (scorerns
+      // fyrstegsregel läser listan, prosa läser den inte). Aldrig en
+      // tolkning av vad "(a)" betyder.
+      const formkrav =
+        'skriv en listpunkt per alternativ på kolumn 0 ("- …"), stryk med prefixet "struket:" och skälet, eller skriv "inga"'
+      if (
+        (avvikelse === 'motsägelse' || avvikelse === 'precisering') &&
+        utfallsvalProsa(impact) === true
+      )
+        (avvikelse === 'motsägelse' ? problems : warnings).push(
+          `impact.md: ${avvikelse} med alternativ i löptext under "Obesvarade utfallsval": ${formkrav}`,
+        )
+    }
     // Analysen får inte läcka poängsättning eller tid (ADR-0098: kontrollen
     // gällde tidigare klassord; klassaxeln är borttagen och regeln riktas nu
     // mot poängen, som är det analysens läsare inte får primas mot).
@@ -210,6 +348,11 @@ if (state != null) {
   }
 }
 
+// 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}`)
 for (const w of warnings) console.log(`VARNING: ${w}`)
 if (problems.length === 0) {
   console.log('OK: formkontrollen passerad')

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

@@ -22,7 +22,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { sectionLines } from './lib.mjs'
+import { canonicalModel, sectionLines } from './lib.mjs'
 
 const SPECFALT = ['Problem', 'Lösning', 'När det är klart', 'Ingår inte']
 
@@ -90,13 +90,23 @@ const läsDok = (dir, namn) => {
 const läsKorning = (dir, namn) => {
   const state = läsJson(path.join(dir, 'state.json'))
   const spec = läsSpec(dir)
+  const delar = kataloger(dir)
+    .filter((d) => /^del-\d+$/.test(d))
+    .sort()
+    .map((d) => läsKorning(path.join(dir, d), d))
+  // En bunt (align-beslut F) har sina specar i delarna och ingen egen i
+  // roten. Roten är då hel av det den var; "ofullständig" skulle påstå att
+  // arkivet är trasigt. En rot utan spec OCH utan delar saknar specen på
+  // riktigt och behåller märkningen.
+  const bunt = spec === null && delar.length > 0
   return {
     namn,
     sokvag: dir,
     // Ofullständig betyder att rapporten inte kan visa körningen som en hel
     // körning. Den visas ändå, märkt: tyst utelämnande är den enda utgången
     // som skulle ljuga för läsaren.
-    ofullstandig: state === null || spec === null,
+    ofullstandig: state === null || (spec === null && !bunt),
+    bunt,
     state,
     spec,
     impact: läsDok(dir, 'impact.md'),
@@ -108,10 +118,7 @@ const läsKorning = (dir, namn) => {
     // headless-svaret rått, och en haus-ägd nyckel i den gör den till ett
     // blandat format som inte längre går att diffa mot CLI:ns utdata.
     klocka: läsJson(path.join(dir, 'matning.json')),
-    delar: kataloger(dir)
-      .filter((d) => /^del-\d+$/.test(d))
-      .sort()
-      .map((d) => läsKorning(path.join(dir, d), d)),
+    delar,
   }
 }
 
@@ -212,22 +219,94 @@ const KOSTNADSFALT = [
   // sa 5,5 minuter om en sonnetkörning som tog omkring 34. Ett `wall_ms` som
   // saknas eller inte är ett tal är omätt, aldrig noll: en nolla skulle läsas
   // som en ögonblicklig körning.
-  ['Väggtid', 'klocka', (m) => (Number.isFinite(m.wall_ms) ? minuter(m.wall_ms) : null)],
+  // #526: väggtiden mättes under samtidig last. Lasten står i korning.json:s
+  // steg (`samtidiga_processer`, maxvärdet över stegen: det är den värsta
+  // trängseln körningen köade bakom); saknas fältet (äldre körningar, eller
+  // en räknare som föll i varje steg) är samtidigheten okänd, inte noll.
+  [
+    'Väggtid',
+    'klocka',
+    (m, k) =>
+      Number.isFinite(m.wall_ms) ? `${minuter(m.wall_ms)} (${samtidighet(k.matning)})` : null,
+  ],
   ['Dispatcher', 'matning', (m) => tal(m.subagent_stats?.spawned)],
+  // #523: nekade verktygsanrop, summan av `permission_denials` över stegen.
+  // Ett steg utan fältet (null, eller äldre korning.json) räknas inte; bär
+  // inget steg fältet är summan omätt, aldrig noll.
+  ['Nekade anrop', 'matning', (m) => nekadeAnrop(m)],
 ]
 
-const kostnadsrader = (k) =>
-  KOSTNADSFALT.map(([namn, källa, hämta]) => {
+/** Summan av nekade verktygsanrop över stegen, null när inget steg bär
+ *  fältet. */
+const nekadeAnrop = (matning) => {
+  const tal = (matning?.steg ?? [])
+    .map((s) => s?.permission_denials)
+    .filter((n) => Number.isFinite(n))
+  return tal.length === 0 ? null : String(tal.reduce((a, b) => a + b, 0))
+}
+
+/** Kanoniska modellnycklar i en körnings korning.json, sorterade. Flera
+ *  fakturerade nycklar (t.ex. med `[1m]`-suffix eller ett datumstämplat
+ *  snapshot-namn) kan kanonisera till samma sträng; unionen dedupar dem. */
+const modellNycklar = (m) =>
+  [...new Set(Object.keys(m?.modelUsage ?? {}).map(canonicalModel))].sort()
+
+/** Kostnad per kanonisk nyckel: dubbletter efter kanonisering summeras,
+ *  annars skulle en snapshot-omdöpt nyckel tyst dölja den äldre kostnaden. */
+const kostnadPerNyckel = (m) => {
+  const ut = {}
+  for (const [nyckel, v] of Object.entries(m?.modelUsage ?? {})) {
+    const k = canonicalModel(nyckel)
+    ut[k] = (ut[k] ?? 0) + (v?.costUSD ?? 0)
+  }
+  return ut
+}
+
+/** Maxantalet samtidiga agentprocesser över stegen, som text. Steg med null
+ *  (räknaren föll) räknas inte; utan ett enda tal är samtidigheten okänd. */
+const samtidighet = (matning) => {
+  const tal = (matning?.steg ?? [])
+    .map((s) => s?.samtidiga_processer)
+    .filter((n) => Number.isFinite(n))
+  if (tal.length === 0) return 'okänd samtidighet'
+  const max = Math.max(...tal)
+  return `${max} ${max === 1 ? 'samtidig' : 'samtidiga'}`
+}
+
+const kostnadsrader = (k, nycklar = modellNycklar(k.matning)) =>
+  KOSTNADSFALT.flatMap(([namn, källa, hämta]) => {
     // En del är ingen egen process: mätningen kommer ur headless-svaret för
     // hela körningen. "omätt" skulle påstå att mätningen misslyckades, vilket
     // är en annan sak än att den inte finns på den här nivån.
-    if (k.rot) return [namn, `<em>ingår i ${esc(k.rot)}</em>`]
+    if (k.rot) {
+      const rad = [namn, `<em>ingår i ${esc(k.rot)}</em>`]
+      if (namn !== 'USD') return [rad]
+      // Sektionens nyckelunion gäller även delkolumnen: den har ingen egen
+      // modelUsage, så per-nyckelraderna får samma "ingår i"-text som
+      // totalen, aldrig streck (vilket skulle påstå att nyckeln är omätt här
+      // i stället för bokförd hos föräldern) eller för få celler (vilket
+      // skulle förskjuta tabellen mot syskonkolumnerna).
+      return [rad, ...nycklar.map((n) => [`USD ${n}`, `<em>ingår i ${esc(k.rot)}</em>`])]
+    }
     // Två oberoende källor: en saknad fil säger omätt för SINA rader och
     // ljuger inte om de andra. Radlistan har ändå alltid samma längd och
     // samma fältnamn, mätt eller omätt.
     const dok = k[källa]
-    const värde = dok ? hämta(dok) : null
-    return [namn, värde === null ? '<em>omätt</em>' : esc(värde)]
+    // Hela körningen följer med som andra argument: Väggtid läser klockan ur
+    // matning.json men samtidigheten ur korning.json:s steg.
+    const värde = dok ? hämta(dok, k) : null
+    const rad = [namn, värde === null ? '<em>omätt</em>' : esc(värde)]
+    if (namn !== 'USD') return [rad]
+    // #494: orkestratorns (hjälpmodellens) kostnad låg förr inbakad i
+    // kandidatens siffra under den enda USD-raden. En rad per fakturerad,
+    // kanoniserad nyckel läggs till efter totalen, som sektionens
+    // nyckelunion (`nycklar`) så att alla körningar i sektionen får samma
+    // radlista, mätt eller inte.
+    const per = kostnadPerNyckel(dok)
+    return [
+      rad,
+      ...nycklar.map((n) => [`USD ${n}`, n in per ? esc(usd(per[n])) : '<em>omätt</em>']),
+    ]
   })
 
 const provenienrader = (k) => {
@@ -271,6 +350,28 @@ const varde = (v) => {
   return esc(v)
 }
 
+/** Poängens utfall. Prisfilen är det gällande dokumentet när den finns.
+ *  Saknas den kan körningen ändå ha ett utfall: en kandidat (KONCEPT/DIAGNOS)
+ *  eller en motsägelse (TILLBAKA_TILL_SPEC) stoppas innan scorern körs och
+ *  får aldrig någon prisfil, bara `state.stopp`. Utan den här raden såg en
+ *  sådan körning ut som en tom kolumn, och läsaren kunde inte skilja
+ *  "stoppades tidigt" från "aldrig kört". Äldre arkiv utan `stopp` ger streck
+ *  som förut. */
+const poangUtfall = (k) => {
+  if (k.poang?.outcome != null) return k.poang.outcome
+  const stopp = k.state?.stopp
+  if (!stopp || typeof stopp !== 'object' || stopp.utfall == null) return null
+  return stopp.kalla ? `${stopp.utfall} (stopp ur ${stopp.kalla})` : `${stopp.utfall} (stopp)`
+}
+
+/** Statuscellen. Ofullständig går först: en bunt utan state.json är
+ *  fortfarande oläsbar som körning, och det får inte döljas bakom buntetiketten. */
+const statuscell = (k) => {
+  if (k.ofullstandig) return '<strong>ofullständig</strong>'
+  if (k.bunt) return esc(`bunt (${k.delar.length} delar)`)
+  return esc(k.state?.status ?? '–')
+}
+
 /** Kuverten är slutna och nycklarna deras, inte rapportens: klassningen bär sitt
  *  utfall i `classification.utfall`, poängen sitt tal i `score` och sin
  *  inringning i `bracket`. Formerna är pinnade i contract-check.mjs. */
@@ -278,10 +379,10 @@ const utfallsrader = (k, harKlass = true) => [
   ...(harKlass ? [['Klass', esc(k.klass?.classification?.utfall ?? '–')]] : []),
   ['Poäng', esc(k.poang?.score ?? '–')],
   ['Inringning', esc(inringning(k.poang?.bracket))],
-  ['Utfall poäng', esc(k.poang?.outcome ?? '–')],
+  ['Utfall poäng', esc(poangUtfall(k) ?? '–')],
   ['Delning', k.delar.length ? esc(`${k.delar.length} delar`) : 'delade sig inte'],
   ['Dubbelkörning', esc(k.state?.runs?.at(-1)?.double_run ?? '–')],
-  ['Status', k.ofullstandig ? '<strong>ofullständig</strong>' : esc(k.state?.status ?? '–')],
+  ['Status', statuscell(k)],
 ]
 
 const specrader = (k) => SPECFALT.map((f) => [f, `<pre>${esc(k.spec?.[f] ?? '–')}</pre>`])
@@ -333,7 +434,7 @@ const klassrader = (k) => {
 const poangrader = (k) => {
   const p = k.poang
   return [
-    ['Utfall', varde(p?.outcome)],
+    ['Utfall', varde(poangUtfall(k))],
     ['Poäng', varde(p?.score)],
     ['Typ', varde(p?.type)],
     ['Inringning', esc(inringning(p?.bracket))],
@@ -347,6 +448,7 @@ const poangrader = (k) => {
     ['Villkor', varde(p?.conditions)],
     ['Beroenden', varde(p?.dependencies)],
     ['Noter', varde(p?.notes)],
+    ['Täckningspost', varde(p?.coverage_post)],
     ['Alternativ', varde(p?.alternatives)],
     ['Kundmotivering', varde(p?.customer_rationale)],
   ]
@@ -421,6 +523,10 @@ const postSektion = (post) => {
   // äldre arkiv. Kalibreringshistoriken kastas inte, men en post utan axeln
   // ska inte visa en tom sektion för den.
   const harKlass = korningar.some((k) => k.klass != null)
+  // #494: nyckelunionen beräknas en gång för hela sektionen, inte per
+  // körning, annars kan två körningar i samma sektion få olika radlängd på
+  // Kostnad och tabellen skulle förskjutas.
+  const kostnadsnycklar = [...new Set(korningar.flatMap((k) => modellNycklar(k.matning)))].sort()
   const block = [
     ['Utfall', (k) => utfallsrader(k, harKlass)],
     ...(harKlass ? [['Klassning', klassrader]] : []),
@@ -428,7 +534,7 @@ const postSektion = (post) => {
     ['Spec', specrader],
     ['Analys', analysrader],
     ['Granskarblock', granskarrader],
-    ['Kostnad', kostnadsrader],
+    ['Kostnad', (k) => kostnadsrader(k, kostnadsnycklar)],
     ['Proveniens', provenienrader],
   ]
   return `