@haus-tech/haus-workflow 5.1.0 → 5.3.0

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

@@ -18,7 +18,7 @@
  *   node korning.mjs --katalog <abs k<N>> --exp <abs experimentkatalog> --repo-rot <abs>
  *                    --request-id <gid eller slug> --modell <modell|default>
  *                    [--claude <kommando>] [--delar-parallellt 2]
- *                    [--steg-timeout 1800000]
+ *                    [--steg-timeout 1800000] [--effort <low|medium|high|xhigh|max|default>]
  *
  * Läser `<exp>/experiment.json` (`sprak` OBLIGATORISK, ADR-0114: språket
  * gissas aldrig), `<exp>/onskemal.md` och `<exp>/kallmanifest.md`. Skriver
@@ -81,6 +81,11 @@ const STANDARD_DELAR_PARALLELLT = 2
 export const STANDARD_STEG_TIMEOUT = 1800000
 /** Exitkoden efter ett signalavbrott, kutym för dödad av SIGINT. */
 const SIGNAL_EXIT = 130
+/** Effortnivåerna `claude --effort` tar, plus `default` som betyder "agentens
+ *  egen effort ur definitionen" och därför ingen flagga alls, samma regel som
+ *  `--modell default` (#525, ADR-0120). */
+export const EFFORTNIVAER = ['low', 'medium', 'high', 'xhigh', 'max', 'default']
+const STANDARD_EFFORT = 'default'
 const VARDEFLAGGOR = [
   'katalog',
   'exp',
@@ -90,13 +95,14 @@ const VARDEFLAGGOR = [
   'claude',
   'delar-parallellt',
   'steg-timeout',
+  'effort',
 ]
 
 export const ANVANDNING = [
   'användning: korning.mjs --katalog <abs k<N>> --exp <abs experimentkatalog> --repo-rot <abs>',
   '                        --request-id <gid eller slug> --modell <modell|default>',
   `                        [--claude <kommando>] [--delar-parallellt ${STANDARD_DELAR_PARALLELLT}]`,
-  `                        [--steg-timeout ${STANDARD_STEG_TIMEOUT}]`,
+  `                        [--steg-timeout ${STANDARD_STEG_TIMEOUT}] [--effort <${EFFORTNIVAER.join('|')}>]`,
 ].join('\n')
 
 // ---------------------------------------------------------------------------
@@ -112,9 +118,18 @@ export const ANVANDNING = [
  * poängsätta, precis som dess kontrakt kräver. Listan sätts därför explicit i
  * stället för att slå av behörighetslagret (`bypassPermissions` hade tillåtit
  * allt, inklusive skrivningar in i arkivet som bara archive.mjs får göra).
- * Assessorns "bara läsande git"-regel blir här mekanisk: fyra prefix, inte en
+ * Assessorns "bara läsande git"-regel blir här mekanisk: prefix, inte en
  * mening i prosa som modellen kan tolka fel.
+ *
+ * Assessorns lista (#523): sex läsande git-subkommandon, deras
+ * `rtk git`-speglingar (den globala CLAUDE.md instruerar agenten att prefixa
+ * git med rtk, så `git log` nekades tyst i k2-svepet), och de fyra
+ * pipe-målen `head`/`grep`/`wc`/`ls`, som en allow-regel matchar bara som
+ * kommandon i kedjan. ALDRIG `Bash(git -C:*)`: prefixet säger inget om vilket
+ * subkommando som följer katalogen, så det kan inte matchas säkert. ALDRIG
+ * `Bash(echo:*)`: ett fritt echo är ett skrivkommando i förklädnad.
  */
+const ASSESSOR_GIT = ['ls-files', 'check-ignore', 'log', 'grep', 'status', 'rev-parse']
 export const AGENT_VERKTYG = {
   'request-scorer': ['Read', 'Skill'],
   'request-specifier': ['Read', 'Grep', 'Glob', 'Skill'],
@@ -124,17 +139,21 @@ export const AGENT_VERKTYG = {
     'Grep',
     'Glob',
     'Skill',
-    'Bash(git ls-files:*)',
-    'Bash(git check-ignore:*)',
-    'Bash(git log:*)',
-    'Bash(git grep:*)',
+    ...ASSESSOR_GIT.map((sub) => `Bash(git ${sub}:*)`),
+    ...ASSESSOR_GIT.map((sub) => `Bash(rtk git ${sub}:*)`),
+    'Bash(head:*)',
+    'Bash(grep:*)',
+    'Bash(wc:*)',
+    'Bash(ls:*)',
   ],
 }
 
 /** Den pinnade headless-invokationen per agentsteg: agentdefinitionen ur
- *  ~/.claude/agents/ kör med sitt eget verktygsurval och sin egen effort,
- *  `--model` läggs på bara som override. `default` betyder "agentens egen
- *  modell" och får därför ingen flagga alls. `--add-dir` öppnar BARA
+ *  ~/.claude/agents/ kör med sitt eget verktygsurval, `--model` och
+ *  `--effort` läggs på bara som override. `default` betyder "agentens egen
+ *  modell" respektive "agentens egen effort" och får därför ingen flagga
+ *  alls (#525: en effort-override som inte når processen är en proveniens
+ *  som ljuger). `--add-dir` öppnar BARA
  *  skills-katalogen under Claude-konfigkatalogen: det är den agenten läser
  *  med Read (skillfiler och referensfiler ligger utanför repo-roten som är
  *  cwd), medan agentdefinitionen läses av CLI:n själv och aldrig via Read.
@@ -143,7 +162,7 @@ export const AGENT_VERKTYG = {
  *  check-lasta släpper ändå bara igenom request-score-skillens egen katalog.
  *  `--allowedTools` ligger SIST: flaggan är variadisk och skulle annars svälja
  *  allt som kom efter den. Prompten går på stdin som förut. */
-export const agentArgs = ({ agent, modell, maxTurer }) => [
+export const agentArgs = ({ agent, modell, effort = STANDARD_EFFORT, maxTurer }) => [
   '-p',
   '--agent',
   agent,
@@ -154,6 +173,7 @@ export const agentArgs = ({ agent, modell, maxTurer }) => [
   '--add-dir',
   path.join(claudeDir(), 'skills'),
   ...(modell === 'default' ? [] : ['--model', modell]),
+  ...(effort === STANDARD_EFFORT ? [] : ['--effort', effort]),
   ...(AGENT_VERKTYG[agent] === undefined ? [] : ['--allowedTools', ...AGENT_VERKTYG[agent]]),
 ]
 
@@ -161,9 +181,17 @@ export const agentArgs = ({ agent, modell, maxTurer }) => [
  *  (ADR-0114). Tabellen bor i lib.mjs; här väljs bara kolumn. */
 const rubrikrader = (sprak) => SPEC_HEADINGS.map((r) => `**${sprak === 'engelska' ? r.en : r.sv}**`)
 
-/** Specifierns prompt, dispatch-kontraktets mall ordagrant. Ett okänt språk
- *  kastar: scriptet gissar aldrig rubrikspråk (IPC 14001 fällde tio utkast på
- *  just den gissningen). */
+/** Ett okänt språk kastar innan någon process startas: scriptet gissar aldrig
+ *  språk (ADR-0114; IPC 14001 fällde tio utkast på just den gissningen).
+ *  Samma spärr för alla tre prompterna, #521: kundtexten skrevs på svenska i
+ *  ett engelskt ärende när bara specifiern fick raden. */
+const kravSprak = (sprak) => {
+  if (sprak !== 'svenska' && sprak !== 'engelska')
+    throw new Error(`SPRÅK måste vara svenska eller engelska (fick "${sprak}")`)
+  return `SPRÅK: ${sprak}`
+}
+
+/** Specifierns prompt, dispatch-kontraktets mall ordagrant. */
 export function specifierPrompt({
   onskemal,
   manifest,
@@ -173,8 +201,7 @@ export function specifierPrompt({
   eskalerad,
   eskaleringsorsak = null,
 }) {
-  if (sprak !== 'svenska' && sprak !== 'engelska')
-    throw new Error(`SPRÅK måste vara svenska eller engelska (fick "${sprak}")`)
+  const sprakRad = kravSprak(sprak)
   return [
     'ÖNSKEMÅL:',
     onskemal.trim(),
@@ -184,7 +211,7 @@ export function specifierPrompt({
     '',
     `REPO-ROT: ${repoRot}`,
     `DEPS: ${deps}`,
-    `SPRÅK: ${sprak}`,
+    sprakRad,
     'RUBRIKER:',
     ...rubrikrader(sprak),
     `ESKALERAD: ${eskalerad ? (eskaleringsorsak ? `ja, ${eskaleringsorsak}` : 'ja') : 'nej'}`,
@@ -193,11 +220,14 @@ export function specifierPrompt({
 }
 
 /** Assessorns prompt. KÄLLOR ligger med (hävstång 5): analysen skrevs förr
- *  mot ett repo den fick leta i själv, medan manifestet låg färdigt bredvid. */
-export function assessorPrompt({ repoRot, deps, spec, granskarblock, manifest }) {
+ *  mot ett repo den fick leta i själv, medan manifestet låg färdigt bredvid.
+ *  SPRÅK efter DEPS (#521): analysens kundvända delar följer raden. */
+export function assessorPrompt({ repoRot, deps, sprak, spec, granskarblock, manifest }) {
+  const sprakRad = kravSprak(sprak)
   return [
     `REPO-ROT: ${repoRot}`,
     `DEPS: ${deps}`,
+    sprakRad,
     'KÄLLOR:',
     manifest.trim(),
     '',
@@ -210,12 +240,15 @@ export function assessorPrompt({ repoRot, deps, spec, granskarblock, manifest })
   ].join('\n')
 }
 
-/** Scorerns prompt: underlaget per sökväg, aldrig inklistrat (ADR-0099). */
-export function scorerPrompt({ requestId, delpost, specPath, impactPath }) {
+/** Scorerns prompt: underlaget per sökväg, aldrig inklistrat (ADR-0099).
+ *  SPRÅK efter DELPOST (#521): kundtexten i kuvertet följer raden. */
+export function scorerPrompt({ requestId, delpost, sprak, specPath, impactPath }) {
+  const sprakRad = kravSprak(sprak)
   return [
     `REQUEST_ID: ${requestId}`,
     'MODE: pricing',
     `DELPOST: ${delpost ? `ja, del ${delpost.part} av ${delpost.of}` : 'nej'}`,
+    sprakRad,
     '',
     `SPEC: ${specPath}`,
     `PÅVERKANSANALYS: ${impactPath}`,
@@ -385,10 +418,23 @@ export function slaIhopKorning(steg) {
       fil: s.fil,
       agent: s.agent,
       modell_begard: s.modell_begard,
+      // "begärd", inte verifierad: modellen prövas mot modelUsage (ADR-0099),
+      // men faktureringen bär ingen effort, så fältet kan inte kontrolleras
+      // mot något och ingen effortverifiering uppfinns (#525, ADR-0120).
+      effort_begard: s.effort_begard ?? STANDARD_EFFORT,
       total_cost_usd: s.svar?.total_cost_usd ?? 0,
       usage: summera(USAGE_FALT, null, s.svar?.usage),
       num_turns: s.svar?.num_turns ?? 0,
       wall_ms: s.wall_ms ?? null,
+      // Lasten wall_ms mättes under (#526): maskinvid och best effort, null
+      // när räknaren föll eller steget är äldre än fältet.
+      samtidiga_processer: s.samtidiga_processer ?? null,
+      // #523: CLI:ns JSON-svar bär `permission_denials` som lista; antalet
+      // bokförs så en tyst nekning syns. Saknas fältet är det null, aldrig
+      // noll: en nolla skulle läsas som "inget nekades".
+      permission_denials: Array.isArray(s.svar?.permission_denials)
+        ? s.svar.permission_denials.length
+        : null,
       is_error: s.svar ? s.svar.is_error === true : true,
     })),
   }
@@ -482,7 +528,7 @@ const lasFil = (p) => {
 /** Argumenttolkning, fail-closed som svep.mjs och kontroll.mjs: alla saknade
  *  flaggor namnges på en gång, en okänd flagga eller ett värdelöst flaggvärde
  *  stoppar direkt i stället för att gissa. */
-function tolkaArgv(argv) {
+export function tolkaArgv(argv) {
   const enkla = {}
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i]
@@ -506,6 +552,9 @@ function tolkaArgv(argv) {
   const timeoutText = enkla['steg-timeout'] ?? String(STANDARD_STEG_TIMEOUT)
   if (!/^\d+$/.test(timeoutText) || Number(timeoutText) < 1)
     return { fel: `--steg-timeout måste vara ett heltal >= 1 (fick "${timeoutText}")` }
+  const effort = enkla.effort ?? STANDARD_EFFORT
+  if (!EFFORTNIVAER.includes(effort))
+    return { fel: `--effort måste vara en av ${EFFORTNIVAER.join(', ')} (fick "${effort}")` }
   return {
     katalog: enkla.katalog,
     exp: enkla.exp,
@@ -515,6 +564,7 @@ function tolkaArgv(argv) {
     claude: enkla.claude ?? 'claude',
     delarParallellt: Number(takText),
     stegTimeout: Number(timeoutText),
+    effort,
   }
 }
 
@@ -591,13 +641,33 @@ function tolkaSteg({ stdout, stegFil, modell, spawnfel, tidsgransMs, exitCode })
   }
 }
 
+/** Levande agentprocesser på maskinen vid ett stegs start (#526, ADR-0120):
+ *  `pgrep -f` över mönstret varje agentsteg bär (`--agent request-`), räknat
+ *  EFTER att det egna steget startats, så det ingår i talet. Värdet är
+ *  MASKINVIDT, inte körningens: det fångar även en annan körnings steg och ett
+ *  annat kontos svep mot samma checkout (ADR-0093), vilket är precis den last
+ *  wall_ms mättes under utan att den bokfördes. Best effort: exit 1 är
+ *  "ingen träff" (0), allt annat (pgrep saknas, exit >= 2, ett kast) blir
+ *  null, aldrig ett kast som fäller steget. `kor` är injicerbar för testerna. */
+export function raknaSamtidiga(kor = spawnSync) {
+  try {
+    const r = kor('pgrep', ['-f', '--', '--agent request-'], { encoding: 'utf8' })
+    if (r.error || (r.status !== 0 && r.status !== 1)) return null
+    return String(r.stdout ?? '')
+      .split('\n')
+      .filter((rad) => rad.trim() !== '').length
+  } catch {
+    return null
+  }
+}
+
 /** Ett agentsteg: en egen `claude -p --agent`-process med prompten på stdin,
  *  svaret RÅTT i `steg/<fil>` och klockan runt den. Barnet läggs i `ctx.barn`
  *  så signalhanteraren kan döda det: en dödad korning.mjs får aldrig lämna
  *  betalda `claude`-processer efter sig. Väggtidstaket (`--steg-timeout`)
  *  dödar ett steg som hänger utan att svara. Anroparen avgör vad ett fallet
  *  steg betyder. */
-function korAgent({ agent, modell, prompt, fil, maxTurer, ctx }) {
+export function korAgent({ agent, modell, prompt, fil, maxTurer, ctx }) {
   return new Promise((los) => {
     const start = Date.now()
     const stegFil = path.join(ctx.katalog, fil)
@@ -606,23 +676,38 @@ function korAgent({ agent, modell, prompt, fil, maxTurer, ctx }) {
     let klar = false
     let tidsgransMs = null
     let timer = null
+    let samtidiga = null
     const avsluta = ({ exitCode, spawnfel = null }) => {
       if (klar) return
       klar = true
       if (timer !== null) clearTimeout(timer)
       const wall_ms = Date.now() - start
       const t = tolkaSteg({ stdout, stegFil, modell, spawnfel, tidsgransMs, exitCode })
-      ctx.samla({ fil, agent, modell_begard: modell, svar: t.svar, wall_ms })
+      ctx.samla({
+        fil,
+        agent,
+        modell_begard: modell,
+        effort_begard: ctx.effort ?? STANDARD_EFFORT,
+        svar: t.svar,
+        wall_ms,
+        samtidiga_processer: samtidiga,
+      })
       if (t.orsak !== null && stderr.trim() !== '')
         logg(`${fil} stderr: ${stderr.trim().slice(0, 200)}`)
       logg(
         `STEG ${fil} ${agent} ${modell} ${wall_ms}ms ${t.orsak === null ? 'ok' : `fallet: ${t.orsak}`}`,
       )
+      // #523: en nekning i headless-läget syns annars ingenstans förrän
+      // analysen saknar det den skulle ha verifierat.
+      const nekade = Array.isArray(t.svar?.permission_denials)
+        ? t.svar.permission_denials.length
+        : 0
+      if (nekade > 0) logg(`STEG ${fil} ${nekade} nekade verktygsanrop`)
       los({ ...t, exitCode, wall_ms, ok: t.orsak === null })
     }
     let barn
     try {
-      barn = spawn(ctx.claude, agentArgs({ agent, modell, maxTurer }), {
+      barn = spawn(ctx.claude, agentArgs({ agent, modell, effort: ctx.effort, maxTurer }), {
         cwd: ctx.repoRot,
         stdio: ['pipe', 'pipe', 'pipe'],
       })
@@ -631,6 +716,9 @@ function korAgent({ agent, modell, prompt, fil, maxTurer, ctx }) {
       return
     }
     ctx.barn.add(barn)
+    // Räknas efter spawn, så det egna steget ingår; spawn är synkron i libuv
+    // och barnet finns med sin argv när anropet återvänder.
+    samtidiga = (ctx.raknaSamtidiga ?? raknaSamtidiga)()
     timer = setTimeout(() => {
       tidsgransMs = ctx.stegTimeout
       logg(`STEG ${fil} dödas: tidsgräns ${ctx.stegTimeout} ms`)
@@ -679,30 +767,35 @@ const SPEC_REF = () =>
   refFlagga('skills/request-write-spec/references/specformat.md', 'references/specformat.md')
 const SCORE_REF = () => refFlagga('skills/request-score/references/poangskala.md', 'poangskala.md')
 
+/** Argumenten till `archive.mjs add-run` för en runs-rad. `--effort` skickas
+ *  exakt när körningen begärt en override: utan flaggan läser add-run
+ *  `effort:` ur agentdefinitionen (ADR-0107 beslut 3), vilket är rätt för
+ *  `default` och fel för allt annat (#525: 40 av 44 rader i IPC 14001 bar
+ *  definitionens värde över en körning som begärt ett annat). */
+export const addRunArgs = (dir, rad, effort = STANDARD_EFFORT) => [
+  'add-run',
+  dir,
+  '--file',
+  rad.fil,
+  '--skill',
+  rad.skill,
+  '--agent',
+  rad.agent,
+  '--model',
+  rad.model ?? 'okänd',
+  ...(effort === STANDARD_EFFORT ? [] : ['--effort', effort]),
+  ...(rad.fakt ? ['--fakturerad', rad.fakt] : []),
+  ...(rad.ref ?? []),
+  ...(rad.note ? ['--note', rad.note] : []),
+  ...(rad.doubleRun ? ['--double-run', rad.doubleRun] : []),
+  ...(rad.supersededBy ? ['--superseded-by', rad.supersededBy] : []),
+]
+
 /** En runs-rad. Arkivet är append-only och äger sina egna vägransregler; en
  *  vägrad stämpling loggas men fäller aldrig körningen, kvittot på vad som
  *  hände ligger kvar i steg/. */
 function addRun(dir, rad, ctx) {
-  const r = arkiv(
-    [
-      'add-run',
-      dir,
-      '--file',
-      rad.fil,
-      '--skill',
-      rad.skill,
-      '--agent',
-      rad.agent,
-      '--model',
-      rad.model ?? 'okänd',
-      ...(rad.fakt ? ['--fakturerad', rad.fakt] : []),
-      ...(rad.ref ?? []),
-      ...(rad.note ? ['--note', rad.note] : []),
-      ...(rad.doubleRun ? ['--double-run', rad.doubleRun] : []),
-      ...(rad.supersededBy ? ['--superseded-by', rad.supersededBy] : []),
-    ],
-    ctx,
-  )
+  const r = arkiv(addRunArgs(dir, rad, ctx.effort), ctx)
   if (r.status !== 0) logg(`VARNING add-run ${rad.fil}: ${felText(r)}`)
   return r.status === 0
 }
@@ -987,6 +1080,7 @@ async function korAssessor(del, ctx) {
   const prompt = assessorPrompt({
     repoRot: ctx.repoRot,
     deps: ctx.deps,
+    sprak: ctx.sprak,
     spec,
     granskarblock: lasFil(path.join(del.dir, 'granskarblock.md')) ?? 'inget granskarblock',
     manifest: ctx.manifest,
@@ -1098,6 +1192,11 @@ function korKontroll(txt, ren, fixFil, del, ctx) {
       fixPath,
       '--state',
       path.join(del.dir, 'state.json'),
+      // #521: kundtextens språk till contract-check. Ett språkbrott är inte
+      // kundtextfixbart (fixen byter ord, översätter inte) och går till
+      // omdispatch som varje annat modellfel.
+      '--sprak',
+      ctx.sprak,
     ],
     ctx,
   )
@@ -1114,7 +1213,15 @@ function samlaFixsteg(fil, fixPath, ctx) {
   const rasvar = lasJson(fixPath)
   if (!Array.isArray(rasvar)) return
   for (const svar of rasvar)
-    ctx.samla({ fil, agent: 'kundtextfix', modell_begard: FIXMODELL, svar, wall_ms: null })
+    ctx.samla({
+      fil,
+      agent: 'kundtextfix',
+      modell_begard: FIXMODELL,
+      // kontroll.mjs får ingen effort-override, fixanropet kör CLI:ns default.
+      effort_begard: STANDARD_EFFORT,
+      svar,
+      wall_ms: null,
+    })
 }
 
 /** En scorerkörning från agentsvar till dom: kontrollkedjan, EN omdispatch vid
@@ -1137,6 +1244,9 @@ async function kontrolleraScorer(del, k, res, prompt, ctx) {
       modellSvans: kontroll.modell ?? parseSvansrader(sista?.text ?? '').modell,
       fakt: fakturerad(sista?.svar, ctx.modell),
       reparerat: kontroll.reparerat ?? [],
+      // Brotten som tvingade en lyckad omdispatch (#522): kasserades de här
+      // saknade runs-raden spår av varför omkörningen betalades.
+      omdispatchadFor: kontroll.omdispatchadFor ?? [],
     }
   }
   if (!res.ok) {
@@ -1168,7 +1278,11 @@ async function kontrolleraScorer(del, k, res, prompt, ctx) {
     writeFileSync(txt, om.text)
     const andra = korKontroll(txt, ren, `${bas}-omdispatch-kundtextfix.json`, del, ctx)
     if (andra.exit2) return { exit2: true, orsak: `kontroll run${k} (omdispatch): ${andra.orsak}` }
-    kontroll = { ...andra, reparerat: [...kontroll.reparerat, ...andra.reparerat] }
+    kontroll = {
+      ...andra,
+      reparerat: [...kontroll.reparerat, ...andra.reparerat],
+      omdispatchadFor: kontroll.brott,
+    }
     sista = om
   }
   return svarsrad(kontroll, sista)
@@ -1180,6 +1294,7 @@ async function korScorers(del, ctx) {
   const prompt = scorerPrompt({
     requestId: ctx.requestId,
     delpost: del.delpost,
+    sprak: ctx.sprak,
     specPath: path.join(del.dir, 'spec.md'),
     impactPath: path.join(del.dir, 'impact.md'),
   })
@@ -1227,8 +1342,20 @@ function skrivPris(del, namn, kr) {
   writeFileSync(path.join(del.dir, namn), JSON.stringify(innehall, null, 2) + '\n')
 }
 
-const scorerNote = (kr, extra = []) =>
-  [...extra, ...kr.reparerat.map((r) => `reparerat: ${r}`)].filter(Boolean).join('; ') || null
+/** Runs-radens note: extra först, sedan varför en lyckad omdispatch behövdes
+ *  (#522) och sist vad kedjan reparerade. Null när inget finns. */
+export const scorerNote = (kr, extra = []) => {
+  const omdispatchad = (kr.omdispatchadFor ?? []).map((b) => b.replace(/^- /, ''))
+  return (
+    [
+      ...extra,
+      ...(omdispatchad.length > 0 ? [`omdispatchad för: ${omdispatchad.join('; ')}`] : []),
+      ...kr.reparerat.map((r) => `reparerat: ${r}`),
+    ]
+      .filter(Boolean)
+      .join('; ') || null
+  )
+}
 
 const scorerRad = (kr, fil, extra = {}) => ({
   fil,
@@ -1439,7 +1566,13 @@ async function main(argv) {
     return 2
   }
   const allaSteg = []
-  const ctx = { ...val, ...underlag, barn: new Set(), samla: (steg) => allaSteg.push(steg) }
+  const ctx = {
+    ...val,
+    ...underlag,
+    barn: new Set(),
+    samla: (steg) => allaSteg.push(steg),
+    raknaSamtidiga,
+  }
   mkdirSync(path.join(ctx.katalog, 'steg'), { recursive: true })
   const nyckel = `${path.basename(path.dirname(ctx.katalog))}/${path.basename(ctx.katalog)}`
   for (const signal of ['SIGTERM', 'SIGINT'])

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

@@ -441,6 +441,60 @@ export const prisavgorandeForm = (text) => {
 
 const INGA_ORD = ['inga', 'none', '-', 'tom']
 
+/**
+ * Funktionsord per språk för språkgrinden på kundtext (#521). Heuristiken är
+ * medvetet smal: minst två OLIKA hela ord ur fel språk fäller, ett enda är
+ * ett lån eller ett namn. Inget ord får vara vanligt i det andra språket
+ * ("for" är inte svenska, "för" är inte engelska); homograferna som ändå
+ * finns (svenskans "is", "and", "not", "for") fångas av tvåordsgränsen.
+ * Diakritiska tecken är ingen signal: Göteborg står i engelsk text.
+ */
+export const FUNKTIONSORD = {
+  svenska: ['och', 'att', 'inte', 'för', 'som', 'är', 'med', 'till', 'av', 'en', 'ett'],
+  engelska: ['the', 'and', 'with', 'that', 'this', 'for', 'is', 'are', 'will', 'not', 'of', 'to'],
+}
+const ANDRA_SPRAKET = { svenska: 'engelska', engelska: 'svenska' }
+
+/** De olika funktionsorden ur FEL språk som `text` bär som hela ord,
+ *  skiftlägesokänsligt, i listans ordning. `sprak` är det väntade språket;
+ *  ett okänt språk kastar, grinden gissar aldrig (ADR-0114). */
+export const felSprakOrd = (text, sprak) => {
+  const fel = ANDRA_SPRAKET[sprak]
+  if (fel === undefined)
+    throw new Error(`SPRÅK måste vara svenska eller engelska (fick "${sprak}")`)
+  return FUNKTIONSORD[fel].filter((ord) =>
+    new RegExp(`(?<![\\p{L}\\d_])${escapeRe(ord)}(?![\\p{L}\\d_])`, 'iu').test(String(text)),
+  )
+}
+
+const utfallsvalRadRe = () =>
+  new RegExp(
+    `^\\*\\*(?:${[UTFALLSVAL_RAD.sv, UTFALLSVAL_RAD.en].map(escapeRe).join('|')}):\\*\\*\\s*(.*)$`,
+    'u',
+  )
+/** Raderna under raden Obesvarade utfallsval fram till nästa fetstilsrad eller
+ *  rubrik, plus texten efter kolonet; null när raden saknas. Raden är en
+ *  fetstilsrad, inte en rubrik, så sektionen slutar vid nästa `**…:**`. */
+const utfallsvalAvsnitt = (text) => {
+  const lines = String(text).replace(/\r\n/g, '\n').split('\n')
+  const radRe = utfallsvalRadRe()
+  const start = lines.findIndex((l) => radRe.test(l.trim()))
+  if (start === -1) return null
+  const efterKolon = radRe.exec(lines[start].trim())[1].trim()
+  const rader = []
+  for (const l of lines.slice(start + 1)) {
+    const t = l.trim()
+    if (isHeadingLine(t) || /^\*\*[^*]+:\*\*/.test(t)) break
+    rader.push(l)
+  }
+  return { efterKolon, rader }
+}
+const LISTPUNKT_RE = /^(?:[-*+]|\d+[.)])\s+(.*)$/
+/** Ett inga-ord som första ord efter kolonet räknas som inga oavsett svans
+ *  ("inga, eftersom …"); "ingalunda" börjar bara som ett och räknas inte. */
+const arIngaOrd = (efterKolon) =>
+  /^(?:inga|none|tom)(?![\p{L}\d])/iu.test(efterKolon) || /^-\s*\.?$/.test(efterKolon)
+
 /**
  * Antalet listade, ostrukna alternativ under raden Obesvarade utfallsval
  * (#507). Raden är en fetstilsrad, inte en rubrik: sektionen är allt till
@@ -451,24 +505,17 @@ const INGA_ORD = ['inga', 'none', '-', 'tom']
  * ä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()
+  const avsnitt = utfallsvalAvsnitt(text)
+  if (avsnitt === null) return null
+  const efterKolon = avsnitt.efterKolon.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
+  for (const l of avsnitt.rader) {
     // 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)
+    // eget alternativ. Kravet ligger på `l`, inte på en trimmad rad.
+    const m = LISTPUNKT_RE.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
@@ -479,6 +526,23 @@ export const utfallsvalAlternativ = (text) => {
   return antal
 }
 
+/**
+ * Sant när avsnittet under Obesvarade utfallsval bär annan text än en lista
+ * eller ett inga-ord (#520): alternativ i löptext ("(a) … (b) …"), inline
+ * efter kolonet eller på följande rader. Finns minst en listpunkt på kolumn 0
+ * är det aldrig prosa, oavsett text runt om: då räknar utfallsvalAlternativ.
+ * Ett inga-ord som första ord räknas som inga oavsett svans ("inga, eftersom
+ * …"). null när raden saknas (precheck äger felet). Hjälparen tolkar aldrig
+ * vad prosan säger, den ser bara att formen saknas.
+ */
+export const utfallsvalProsa = (text) => {
+  const avsnitt = utfallsvalAvsnitt(text)
+  if (avsnitt === null) return null
+  if (arIngaOrd(avsnitt.efterKolon)) return false
+  if (avsnitt.rader.some((l) => LISTPUNKT_RE.test(l))) return false
+  return avsnitt.efterKolon !== '' || avsnitt.rader.some((l) => l.trim() !== '')
+}
+
 /**
  * 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`

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

@@ -28,6 +28,7 @@ import {
   avvikelseEtikett,
   AVVIKELSE_ETIKETTER,
   utfallsvalAlternativ,
+  utfallsvalProsa,
   prisavgorandeVal,
   prisavgorandeForm,
 } from './lib.mjs'
@@ -264,6 +265,21 @@ if (requireImpact) {
         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