ALVA-RULE-200: ett ärende stängs aldrig utan ett varför

Kravet är enkelt att formulera och lätt att bygga fel. En obligatorisk
fritextruta blir "klart" på tredje ärendet, och då har vi bara gjort
dokumentationen långsammare utan att göra den bättre.

Därför fyra frågor med olika adressat i stället för ett fält:

  MOTIVERING   Varför följer slutsatsen av evidensen? Detta är raden som
               saknas i varje verkstadsprotokoll. Underlaget säger vad
               som mättes, slutsatsen vad som är fel — ingenting säger
               varför det ena medför det andra, och det är precis det
               steget en försäkringsbedömare granskar.
  UTESLUTET    Vad övervägdes och varför föll det bort?
  ÅTGÄRDSVAL   Varför denna åtgärd och inte en annan?
  KVARSTÅENDE  Vad är fortfarande osäkert? Får vara "inget" — men aktivt.

Kvalitetsgranskningen är riktad mot hur någon med bråttom faktiskt
skriver: en katalog över icke-svar (klart, åtgärdat, trasig, se ovan,
vet ej), minsta längd, och kravet att texten bär ett orsakssamband eller
refererar konkret evidens. Den som skriver "12,4 V vid stift 14"
hänvisar till en mätning utan att säga ordet — regeln får inte tvinga
fram ett språkbruk som inte är teknikerns.

Den regel som gör underlaget användbart för ett försäkringsbolag härleds
ur loggen: en hypotes som dokumenterats och inte blivit slutsatsen MÅSTE
bemötas. Utan den är en felsökning en gissning som råkade stämma.

Den ärliga vägen finns: orsaken kunde inte fastställas är ett giltigt
utfall, ofta mer användbart än en påhittad orsak — men varför den inte
kunde det är fortfarande ett varför.

Slutsatsen är kunddelbar. Den besvarar "varför kostade det här vad det
kostade" och är den enda rad en bedömare behöver. Att bygga funktionen
och sedan hålla den intern vore att bygga den förgäves.

I gränssnittet granskas fälten medan man skriver, inte efter Spara, och
obemötta hypoteser listas — teknikern ska aldrig behöva gissa vad som
fattas. Det är skillnaden mellan ett krav som respekteras och ett som
kringgås.

---

Typkontrollen avslöjade under arbetet en riktig bugg i mitt eget
grindarbete: schemat och grinden skrevs mot antagna fältnamn i stället
för mot domänmodellen. atgard_utford heter beskrivning och utford, inte
text. Följden var värre än ett typfel — grinden såg utförd åtgärd som
utebliven och krävde därför aldrig kundbesked eller kvalitetskontroll.
Det syntes inte, eftersom testfixturerna hade samma antagande.

Rättat i schema, grind och fixturer, och låst av två nya test: varje
fält i schemat måste finnas i domänmodellen, och varje händelse
demoärendet producerar måste passera serverns validering. Ett schema som
avvisar riktig trafik är värre än inget schema.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012EQg3rJsrQ1ZNTvkzmQAtt

felsokning/app/src/felsokning/Slutsats.tsx

@@ -0,0 +1,205 @@
+// ALVA-RULE-200 · Slutsatspanelen.
+//
+// Här möter teknikern kravet, och här avgörs om regeln blir älskad eller
+// hatad. Tre val styr det:
+//
+//   Fyra fält, inte ett.   En stor ruta ger "klart". Fyra namngivna
+//                          frågor med olika adressat ger fyra svar,
+//                          eftersom var och en är konkret nog att
+//                          besvara utan att först fundera på vad som
+//                          efterfrågas.
+//
+//   Granskning medan man   Bristerna visas under fältet direkt, inte som
+//   skriver.               ett felmeddelande efter Spara. Att bli nekad
+//                          efter att ha skrivit klart är det som gör
+//                          obligatoriska fält förhatliga.
+//
+//   Hypoteserna listas.    Systemet visar vilka misstankar som ligger i
+//                          loggen och behöver bemötas. Teknikern ska
+//                          aldrig behöva gissa vad som fattas.
+
+import { useMemo, useState } from "react";
+import type { Arende, Handelse } from "./domain";
+import { granskaSlutsats, obemottaHypoteser } from "../../../services/gemensam/motivering.mjs";
+import { FARG, Etikett, Knapp, Statusmärke } from "@/alva/komponenter";
+
+interface Brist {
+  falt: string;
+  text: string;
+}
+
+const FALT = [
+  {
+    id: "motivering" as const,
+    etikett: "Motivering",
+    fraga: "Varför följer slutsatsen av underlaget?",
+    hjalp: "Knyt mätvärden, foton och kontroller till slutsatsen. Vad i evidensen gör att just detta följer?",
+    rader: 4,
+  },
+  {
+    id: "uteslutet" as const,
+    etikett: "Uteslutna alternativ",
+    fraga: "Vad övervägdes, och varför föll det bort?",
+    hjalp: "En felsökning utan uteslutna alternativ är en gissning som råkade stämma.",
+    rader: 3,
+  },
+  {
+    id: "atgardsval" as const,
+    etikett: "Val av åtgärd",
+    fraga: "Varför denna åtgärd och inte en annan?",
+    hjalp: "Byte eller justering? Hela enheten eller en del? Skälet läses av den som granskar kostnaden.",
+    rader: 2,
+  },
+  {
+    id: "kvarstaende" as const,
+    etikett: "Kvarstående osäkerhet",
+    fraga: "Vad är fortfarande osäkert?",
+    hjalp: 'Får vara "inget" — men det måste sägas aktivt.',
+    rader: 2,
+  },
+];
+
+export function Slutsatspanel({ arende, skicka }: { arende: Arende; skicka: (h: Handelse) => void }) {
+  const handelser = useMemo(() => arende.handelser.map((p) => p.handelse), [arende]);
+  const befintlig = useMemo(
+    () => [...handelser].reverse().find((h) => h.typ === "slutsats"),
+    [handelser],
+  ) as Extract<Handelse, { typ: "slutsats" }> | undefined;
+
+  const [fastställd, setFastställd] = useState(befintlig?.orsakFastställd !== false);
+  const [utkast, setUtkast] = useState({
+    motivering: befintlig?.motivering ?? "",
+    uteslutet: befintlig?.uteslutet ?? "",
+    atgardsval: befintlig?.atgardsval ?? "",
+    kvarstaende: befintlig?.kvarstaende ?? "",
+  });
+
+  const förslag = { typ: "slutsats" as const, ...utkast, orsakFastställd: fastställd };
+  const brister: Brist[] = useMemo(
+    () => granskaSlutsats(förslag, handelser),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [utkast, fastställd, handelser],
+  );
+  const obemötta: string[] = useMemo(() => obemottaHypoteser(handelser, förslag), [handelser, förslag]);
+
+  const brist = (falt: string) => brister.find((b) => b.falt === falt && !b.text.includes("bemöts inte"));
+  const klar = brister.length === 0;
+
+  const arbeteUtfört = handelser.some((h) => h.typ === "atgard_utford" && h.utford);
+
+  return (
+    <section className="mb-4 border bg-white" style={{ borderColor: FARG.lightSteel }}>
+      <header
+        className="flex flex-wrap items-baseline justify-between gap-2 border-b px-4 py-2"
+        style={{ borderColor: FARG.lightSteel, background: FARG.background }}
+      >
+        <h3 className="text-[16px] font-semibold uppercase tracking-[0.06em]" style={{ color: FARG.graphite }}>
+          Closing statement
+        </h3>
+        <div className="flex items-center gap-4">
+          <Statusmärke status={klar ? "complete" : "incomplete"} />
+          <span className="font-mono text-[11px]" style={{ color: FARG.steel }}>
+            ALVA-RULE-200
+          </span>
+        </div>
+      </header>
+
+      <div className="px-4 py-2">
+        <p className="mb-4 max-w-[62ch] text-[13px] leading-[20px]" style={{ color: FARG.steel }}>
+          Underlaget visar vad som mättes. Slutsatsen visar vad som är fel. Det här är raden som säger varför det
+          ena följer av det andra — och den enda en garantihandläggare eller försäkringsbedömare behöver granska.
+        </p>
+
+        {/* Den ärliga vägen. Att orsaken inte kunnat fastställas är ett
+            giltigt utfall, och ofta mer användbart än en påhittad orsak.
+            Men varför den inte kunde det är fortfarande ett varför. */}
+        <div className="mb-4 flex flex-wrap gap-2">
+          {[
+            { värde: true, text: "Orsak fastställd" },
+            { värde: false, text: "Orsak kunde inte fastställas" },
+          ].map((val) => (
+            <button
+              key={String(val.värde)}
+              type="button"
+              onClick={() => setFastställd(val.värde)}
+              aria-pressed={fastställd === val.värde}
+              className="border px-4 py-2 text-[12px] font-semibold uppercase tracking-[0.08em]"
+              style={{
+                background: fastställd === val.värde ? FARG.graphite : FARG.white,
+                color: fastställd === val.värde ? FARG.white : FARG.graphite,
+                borderColor: fastställd === val.värde ? FARG.graphite : FARG.steel,
+              }}
+            >
+              {val.text}
+            </button>
+          ))}
+        </div>
+
+        {obemötta.length > 0 && (
+          <div className="mb-4 border-2 px-4 py-2" style={{ borderColor: FARG.graphite }}>
+            <Etikett ton="graphite">Hypoteser i loggen som behöver bemötas</Etikett>
+            <ul className="mt-2 text-[13px] leading-[20px]" style={{ color: FARG.graphite }}>
+              {obemötta.map((text) => (
+                <li key={text} className="flex gap-2">
+                  <span aria-hidden="true">□</span>
+                  {text}
+                </li>
+              ))}
+            </ul>
+            <p className="mt-2 text-[12px] leading-[16px]" style={{ color: FARG.steel }}>
+              Ange under Uteslutna alternativ varför de föll bort — eller varför de kvarstår.
+            </p>
+          </div>
+        )}
+
+        {FALT.filter((f) => f.id !== "atgardsval" || arbeteUtfört).map((f) => {
+          const fel = brist(f.id);
+          const etikett = f.id === "motivering" && !fastställd ? "Skäl till att orsaken inte fastställts" : f.etikett;
+          return (
+            <div key={f.id} className="border-t py-2" style={{ borderColor: FARG.lightSteel }}>
+              <label
+                htmlFor={`slutsats-${f.id}`}
+                className="block text-[11px] font-semibold uppercase tracking-[0.12em]"
+                style={{ color: FARG.steel }}
+              >
+                {etikett}
+              </label>
+              <p className="mt-1 text-[13px]" style={{ color: FARG.graphite }}>
+                {f.fraga}
+              </p>
+              <textarea
+                id={`slutsats-${f.id}`}
+                rows={f.rader}
+                value={utkast[f.id]}
+                onChange={(e) => setUtkast({ ...utkast, [f.id]: e.target.value })}
+                aria-describedby={`slutsats-${f.id}-hjalp`}
+                aria-invalid={Boolean(fel)}
+                className="mt-2 w-full border px-4 py-2 text-[14px] leading-[20px]"
+                style={{
+                  borderColor: fel ? FARG.graphite : FARG.lightSteel,
+                  borderWidth: fel ? 2 : 1,
+                  background: FARG.white,
+                  color: FARG.graphite,
+                }}
+              />
+              <p id={`slutsats-${f.id}-hjalp`} className="mt-1 text-[12px] leading-[16px]" style={{ color: FARG.steel }}>
+                {fel ? fel.text : f.hjalp}
+              </p>
+            </div>
+          );
+        })}
+
+        <div className="mt-4 flex flex-wrap items-center gap-4">
+          <Knapp disabled={!klar} onClick={() => skicka(förslag)}>
+            {befintlig ? "Uppdatera slutsats" : "Registrera slutsats"}
+          </Knapp>
+          {!klar && (
+            <span className="text-[12px]" style={{ color: FARG.steel }}>
+              {brister.length} {brister.length === 1 ? "brist" : "brister"} kvar.
+            </span>
+          )}
+        </div>
+      </div>
+    </section>
+  );
+}

felsokning/app/src/felsokning/__tests__/grind.test.ts

@@ -5,6 +5,7 @@
 // signerad behållare för overifierade påståenden, och kvalitetsgrinden
 // ett råd. Går något av testerna sönder har den garantin försvunnit —
 // och det syns inte i gränssnittet förrän någon bestrider ett ärende.
+import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 import { granskaHändelse, tillPost } from "../../../../services/gemensam/handelser.mjs";
 import { SPARRFRAGOR as SPARR_SERVER, grinda, grindaArendetyp } from "../../../../services/gemensam/grind.mjs";
@@ -23,9 +24,18 @@ function komplettLogg(extra: Record<string, unknown>[] = []) {
     { typ: "matarstallning", lage: "utgaende", varde: "14 205" },
     { typ: "reproducering", status: "ja", beskrivning: "Reproducerat vid 88 km/h." },
     { typ: "felorsak", avvikelse: "Obalans", orsaker: ["Normalt slitage"], underlag: ["Mätvärde"], sakerhet: "hog" },
-    { typ: "atgard_utford", text: "Balanserade hjulen." },
-    { typ: "kundbeslut", utfall: "godkant", kanal: "Telefon" },
-    { typ: "kvalitetskontroll", utfall: "borta", beskrivning: "Provkört, symptomet borta." },
+    { typ: "atgard_utford", beskrivning: "Balanserade hjulen.", utford: true },
+    { typ: "kundbeslut", beslut: "godkant", kanal: "Telefon" },
+    { typ: "kvalitetskontroll", resultat: "symptomet_borta", beskrivning: "Provkört, symptomet borta." },
+    {
+      typ: "slutsats",
+      motivering:
+        "Uppmätt obalans 38 g på höger framhjul mot toleransen 5 g, vilket förklarar varför vibrationen " +
+        "uppträder hastighetsberoende kring 88 km/h och försvann efter balansering.",
+      uteslutet: "Kast och bussningar kontrollerades utan anmärkning och uteslöts därför.",
+      kvarstaende: "Inget. Symptomet reproducerades före och uteblev efter åtgärd.",
+      atgardsval: "Balansering valdes framför däckbyte eftersom däcket är oskadat och slitaget inom gräns.",
+    },
     { typ: "matvarde", beskrivning: "Lufttryck", varde: "2,4" },
     { typ: "foto", beskrivning: "Objektet" },
     { typ: "foto", beskrivning: "Typskylt" },
@@ -117,7 +127,7 @@ describe("C-2 · kvalitetsgrinden spärrar på servern", () => {
 
   it("arbete utfört trots avböjt förslag är ett hårt fel, inte en varning", () => {
     const logg = komplettLogg().map((h) =>
-      h.typ === "kundbeslut" ? { ...h, utfall: "avbojt" } : h,
+      h.typ === "kundbeslut" ? { ...h, beslut: "avbojt" } : h,
     );
     expect(grinda(logg, GENERISK).map((h) => h.id)).toContain("avbojt_men_utfort");
   });
@@ -194,3 +204,44 @@ describe("ärendetypens regelpaket", () => {
     expect(grindaArendetyp(logg, trasigt)[0].rubrik).toMatch(/Okänt krav/);
   });
 });
+
+// Skydd mot den drift som faktiskt inträffade: schemat på servern skrevs
+// mot antagna fältnamn i stället för mot domänmodellen. Följden var värre
+// än ett typfel — grinden såg utförd åtgärd som utebliven, och krävde
+// därför aldrig kundbesked eller kvalitetskontroll. Det syntes inte,
+// eftersom testfixturerna hade samma antagande.
+describe("schemat följer domänmodellen", () => {
+  it("varje obligatoriskt fält i schemat finns i domain.ts", async () => {
+    const { HÄNDELSESCHEMA } = await import("../../../../services/gemensam/handelser.mjs");
+    const domain = readFileSync("src/felsokning/domain.ts", "utf8");
+    const avvikelser: string[] = [];
+
+    for (const [typ, schema] of Object.entries(HÄNDELSESCHEMA as Record<string, object>)) {
+      // Klipp ut den del av unionen som beskriver typen.
+      const start = domain.indexOf(`typ: "${typ}"`);
+      if (start < 0) {
+        avvikelser.push(`${typ}: saknas i domain.ts`);
+        continue;
+      }
+      const block = domain.slice(start, start + 700);
+      for (const falt of Object.keys(schema)) {
+        // Bilagefälten ärvs via intersektion med Bilaga och står inte i blocket.
+        if (["bilagaId", "bilagaHash", "dataUrl"].includes(falt)) continue;
+        if (!new RegExp(`\\b${falt}\\??:`).test(block)) avvikelser.push(`${typ}.${falt}`);
+      }
+    }
+    expect(avvikelser).toEqual([]);
+  });
+
+  it("demoärendets händelser passerar serverns validering", async () => {
+    // Slutkontrollen: allt klienten faktiskt producerar måste gå igenom.
+    // Ett schema som avvisar riktig trafik är värre än inget schema.
+    const { granskaHändelse } = await import("../../../../services/gemensam/handelser.mjs");
+    const { byggDemoArende } = await import("../demo");
+    const avvisade = byggDemoArende(1)
+      .handelser.map((p) => [p.handelse.typ, granskaHändelse(p.handelse)] as const)
+      .filter(([, fel]) => fel !== null)
+      .map(([typ, fel]) => `${typ}: ${fel}`);
+    expect([...new Set(avvisade)]).toEqual([]);
+  });
+});

felsokning/app/src/felsokning/__tests__/slutsats.test.ts

@@ -0,0 +1,180 @@
+// @vitest-environment node
+// ALVA-RULE-200 · Ett ärende stängs aldrig utan ett varför.
+//
+// Regeln är värdelös om den går att uppfylla med "klart". Testerna nedan
+// är därför mest en katalog över hur någon med bråttom faktiskt skriver,
+// och ett krav på att systemet inte accepterar det.
+//
+// Den viktigaste regeln är den sista: en hypotes som dokumenterats och
+// inte blivit slutsatsen måste bemötas. Utan den är en felsökning en
+// gissning som råkade stämma — och det är precis den skillnaden en
+// försäkringsbedömare försöker avgöra.
+import { describe, expect, it } from "vitest";
+import {
+  MINSTA_MOTIVERING,
+  granskaFalt,
+  granskaSlutsats,
+  obemottaHypoteser,
+} from "../../../../services/gemensam/motivering.mjs";
+
+const GILTIG = {
+  typ: "slutsats",
+  motivering:
+    "Uppmätt spänningsfall 2,1 V över reläets slutkontakt vid belastning, mot 0,2 V som är gränsen. " +
+    "Det förklarar varför bränslepumpen inte får full matning och varför felet bara uppträder varm.",
+  uteslutet:
+    "Bränslepumpen själv uteslöts eftersom den drar rätt ström vid direktmatning. Kablaget mättes utan anmärkning.",
+  kvarstaende: "Inget. Symptomet reproducerades och försvann efter bytet.",
+  atgardsval:
+    "Reläet byttes i stället för att rengöras eftersom kontaktytorna är eroderade och rengöring inte återställer dem.",
+};
+
+const ARBETE = [{ typ: "atgard_utford", beskrivning: "Bytte bränslepumpsrelä.", utford: true }];
+
+describe("motiveringen måste vara ett skäl, inte en upprepning", () => {
+  it("avvisar tomt fält", () => {
+    expect(granskaFalt("Motivering", "")).toMatch(/saknas/);
+    expect(granskaFalt("Motivering", "   ")).toMatch(/saknas/);
+  });
+
+  it.each([
+    "klart",
+    "OK",
+    "åtgärdat",
+    "fixat",
+    "se ovan",
+    "trasig",
+    "defekt",
+    "sliten",
+    "behöver bytas",
+    "enligt kund",
+    "vet ej",
+    "-",
+    "n/a",
+  ])("avvisar icke-svaret %s", (text) => {
+    expect(granskaFalt("Motivering", text)).toMatch(/är inget skäl/);
+  });
+
+  it("avvisar text som är för kort för att gå att granska", () => {
+    expect(granskaFalt("Motivering", "Reläet var dåligt", { minsta: MINSTA_MOTIVERING })).toMatch(/för kort/);
+  });
+
+  it("avvisar en omformulering av slutsatsen utan orsakssamband", () => {
+    // Vad, men inte varför. Detta är den vanligaste bristen och den
+    // svåraste att fånga — texten ser fullgod ut tills man frågar vad
+    // den egentligen påstår.
+    const fel = granskaFalt(
+      "Motivering",
+      "Reläet till bränslepumpen fungerade inte som det ska och byttes därmed ut mot ett nytt relä.",
+      { minsta: MINSTA_MOTIVERING, kravOrsak: true },
+    );
+    expect(fel).toMatch(/anger vad, men inte varför/);
+  });
+
+  it("godtar ett resonemang med orsakssamband", () => {
+    expect(granskaFalt("Motivering", GILTIG.motivering, { minsta: MINSTA_MOTIVERING, kravOrsak: true })).toBeNull();
+  });
+
+  it("godtar konkreta mätvärden som evidensreferens även utan orsaksord", () => {
+    // Den som skriver "12,4 V vid stift 14" hänvisar till en mätning
+    // utan att säga ordet mätning. Regeln får inte tvinga fram ett
+    // språkbruk som inte är teknikerns.
+    expect(
+      granskaFalt("Motivering", "Stift 14 låg på 12,4 V med tändning på, stift 7 på 0,03 ohm mot jord.", {
+        minsta: MINSTA_MOTIVERING,
+        kravOrsak: true,
+      }),
+    ).toBeNull();
+  });
+});
+
+describe("hela slutsatsen inför avslut", () => {
+  it("saknad slutsats spärrar avslutet", () => {
+    const brister = granskaSlutsats(undefined, []);
+    expect(brister).toHaveLength(1);
+    expect(brister[0].text).toMatch(/kan inte avslutas utan en slutsats/);
+  });
+
+  it("en fullständig slutsats passerar", () => {
+    expect(granskaSlutsats(GILTIG, ARBETE)).toEqual([]);
+  });
+
+  it("kräver val av åtgärd när arbete utförts — men inte annars", () => {
+    const utanVal = { ...GILTIG, atgardsval: undefined };
+    expect(granskaSlutsats(utanVal, ARBETE).map((b) => b.falt)).toContain("atgardsval");
+    // Utan utfört arbete finns inget åtgärdsval att motivera.
+    expect(granskaSlutsats(utanVal, [{ typ: "atgard_utford", beskrivning: "Ingen åtgärd.", utford: false }])).toEqual([]);
+  });
+
+  it("kvarstående osäkerhet får vara inget — men måste sägas aktivt", () => {
+    expect(granskaSlutsats({ ...GILTIG, kvarstaende: "Inget." }, ARBETE)).toEqual([]);
+    expect(granskaSlutsats({ ...GILTIG, kvarstaende: "" }, ARBETE).map((b) => b.falt)).toContain("kvarstaende");
+  });
+
+  it("den ärliga vägen: orsaken kunde inte fastställas, men varför måste stå där", () => {
+    const oklart = {
+      typ: "slutsats",
+      orsakFastställd: false,
+      motivering:
+        "Felet gick inte att reproducera under de förhållanden som rådde, eftersom det enligt kunden " +
+        "bara uppträder vid längre körning i kyla. Ingen avvikelse kunde mätas fram vid undersökningen.",
+      uteslutet: "Kablaget och kontaktdonen kontrollerades utan anmärkning vid genomgång.",
+      kvarstaende: "Orsaken är inte fastställd. Fordonet bör återkomma vid symptom.",
+    };
+    expect(granskaSlutsats(oklart, [])).toEqual([]);
+
+    // Men "vet ej" duger inte som skäl till att man inte vet.
+    expect(granskaSlutsats({ ...oklart, motivering: "vet ej" }, []).map((b) => b.falt)).toContain("motivering");
+  });
+});
+
+describe("dokumenterade hypoteser måste bemötas", () => {
+  const HYPOTES = { typ: "hypotes", text: "Misstänkt glapp i hjullagret höger fram", niva: "medel" };
+
+  it("en obemött hypotes spärrar avslutet", () => {
+    const brister = granskaSlutsats(GILTIG, [...ARBETE, HYPOTES]);
+    expect(brister.map((b) => b.text).join(" ")).toMatch(/finns i loggen men bemöts inte/);
+  });
+
+  it("hypotesen är bemött när uteslutandet nämner den", () => {
+    const bemött = {
+      ...GILTIG,
+      uteslutet:
+        "Hjullagret kontrollerades utan glapp och uteslöts därför. Bränslepumpen drar rätt ström vid direktmatning.",
+    };
+    expect(obemottaHypoteser([...ARBETE, HYPOTES], bemött)).toEqual([]);
+    expect(granskaSlutsats(bemött, [...ARBETE, HYPOTES])).toEqual([]);
+  });
+
+  it("hypotesen är bemött när den blev den fastställda orsaken", () => {
+    const logg = [
+      ...ARBETE,
+      HYPOTES,
+      { typ: "felorsak", avvikelse: "Glapp i hjullagret höger fram, 1,2 mm axiellt.", orsaker: [], underlag: [] },
+    ];
+    expect(obemottaHypoteser(logg, GILTIG)).toEqual([]);
+  });
+
+  it("flera hypoteser rapporteras var för sig", () => {
+    const logg = [
+      ...ARBETE,
+      HYPOTES,
+      { typ: "hypotes", text: "Möjlig obalans i framhjulen", niva: "lag" },
+    ];
+    const brister = granskaSlutsats(GILTIG, logg).filter((b) => b.text.includes("bemöts inte"));
+    expect(brister).toHaveLength(2);
+  });
+
+  it("ett ärende utan hypoteser kräver inget bemötande", () => {
+    expect(obemottaHypoteser(ARBETE, GILTIG)).toEqual([]);
+  });
+});
+
+describe("grinden spärrar avslutet utan slutsats", () => {
+  it("saknad slutsats ger ett hinder med id slutsats_slutsats", async () => {
+    const { grinda } = await import("../../../../services/gemensam/grind.mjs");
+    const { ALLA_METODIKER } = await import("../../../../services/gemensam/metodiker.mjs");
+    const hinder = grinda([], ALLA_METODIKER.at(-1)).map((h) => h.id);
+    expect(hinder).toContain("slutsats_slutsats");
+  });
+});

felsokning/app/src/felsokning/domain.ts

@@ -189,6 +189,30 @@ export type Handelse =
       modell: string;
     }
   // Avslutet signeras av teknikern — slutsatsen får en ansvarig avsändare.
+  /**
+   * ALVA-RULE-200 · Teknikerns varför.
+   *
+   * Fyra frågor med olika adressat, som i dag blandas ihop till en rad i
+   * en arbetsorder — vilket är varför verkstadsprotokoll är svåra att
+   * använda i efterhand. Fälten valideras i
+   * services/gemensam/motivering.mjs och spärrar avslutet.
+   */
+  | {
+      typ: "slutsats";
+      /** Varför följer slutsatsen av evidensen? */
+      motivering: string;
+      /** Vad övervägdes och varför föll det bort? */
+      uteslutet: string;
+      /** Vad är fortfarande osäkert? Får vara "inget" — men aktivt sagt. */
+      kvarstaende: string;
+      /** Varför denna åtgärd och inte en annan? Krävs när arbete utförts. */
+      atgardsval?: string;
+      /**
+       * Falskt när orsaken inte kunnat fastställas. Det är ett giltigt
+       * utfall — men varför den inte kunde det är fortfarande ett varför.
+       */
+      orsakFastställd?: boolean;
+    }
   | { typ: "arende_avslutat"; signatur?: string };
 
 export interface LoggPost {

felsokning/app/src/pages/felsokning/ArendeSida.tsx

@@ -6,6 +6,7 @@ import type { Metodik, NastaSteg } from "@/felsokning/metodik";
 import { nastaSteg } from "@/felsokning/metodik";
 import { fasFor, klaraFaser } from "../../../../services/gemensam/faser.mjs";
 import { Fasrad } from "@/alva/komponenter";
+import { Slutsatspanel } from "@/felsokning/Slutsats";
 import { arendebeteckning, fasDefinition } from "@/alva/system";
 import {
   arAvslutat,
@@ -1302,6 +1303,11 @@ function GuideFlik({
         </p>
       </div>
 
+      {/* ALVA-RULE-200. Panelen visas när metodiken är genomförd — det
+          är då varför-frågan har ett underlag att vila på. Att fråga
+          tidigare vore att be om en gissning. */}
+      {steg.klart && <Slutsatspanel arende={arende} skicka={skicka} />}
+
       <Panel rubrik={`Metodik: ${metodik.namn} · Steg: ${steg.steg.rubrik}`}>
         {steg.klart ? (
           <>

felsokning/services/gemensam/grind.mjs

@@ -15,6 +15,8 @@
 // databasåtkomst, ingen tid, inget slumpmässigt — samma logg ger alltid
 // samma utfall, vilket är vad som gör en spärr granskbar.
 
+import { granskaSlutsats } from "./motivering.mjs";
+
 const UNDANTAG_MOTIVERAT = (h) => typeof h.undantag === "string" && h.undantag.trim().length > 0;
 
 // Frågor som måste besvaras jakande för att arbetet ska få avslutas.
@@ -69,7 +71,7 @@ export function grinda(handelser, metodik) {
   // Åtgärdskedjan. En utebliven åtgärd är ett giltigt utfall — men bara
   // när skälet står i loggen.
   const atgarder = av(handelser, "atgard_utford");
-  const utfordArbete = atgarder.some((h) => (h.text ?? "").trim().length > 0);
+  const utfordArbete = atgarder.some((h) => h.utford === true);
   krav(
     "atgard",
     "Åtgärd dokumenterad eller motiverad",
@@ -85,7 +87,7 @@ export function grinda(handelser, metodik) {
     krav(
       "avbojt_men_utfort",
       "Utfört arbete trots avböjt åtgärdsförslag",
-      !beslut.some((h) => h.utfall === "avbojt"),
+      !beslut.some((h) => h.beslut === "avbojt"),
       "Kunden avböjde förslaget men arbete har dokumenterats som utfört.",
     );
 
@@ -124,6 +126,19 @@ export function grinda(handelser, metodik) {
   );
   krav("foton", "Foton finns för fotokrävande kontroller", utanFoto.length === 0 || foton >= utanFoto.length);
 
+  // ALVA-RULE-200 · Slutsatsen. Ett ärende stängs aldrig utan att
+  // teknikern lämnat ett varför — motiveringen som knyter slutsatsen
+  // till underlaget, vad som uteslöts, och vad som kvarstår osäkert.
+  //
+  // Detta är den rad som saknas i varje verkstadsprotokoll: underlaget
+  // säger vad som mättes, slutsatsen vad som är fel, men ingenting
+  // varför det ena medför det andra. Det är precis det steget en
+  // garantihandläggare eller försäkringsbedömare behöver granska.
+  const slutsats = av(handelser, "slutsats").at(-1);
+  for (const brist of granskaSlutsats(slutsats, handelser)) {
+    hinder.push({ id: `slutsats_${brist.falt}`, rubrik: brist.text });
+  }
+
   // Säkerhetsspärrar. Ett nekande svar på en spärrfråga får aldrig
   // passera som "besvarad" — se SPARRFRAGOR i klientens metodik.ts.
   // Klientens spärr är vägledning; den här är hindret (QUALITET M-2).

felsokning/services/gemensam/handelser.mjs

@@ -40,18 +40,30 @@ export const HÄNDELSESCHEMA = {
   matarstallning: { lage: ["ingaende", "utgaende"], varde: "text" },
   historik_kontrollerad: { kontrollerad: "boolean" },
   reproducering: { status: ["ja", "delvis", "nej"], beskrivning: "text" },
-  felorsak: { avvikelse: "text", orsaker: "lista", underlag: "lista", sakerhet: ["hog", "medel", "lag"] },
-  atgardsforslag: { text: "text" },
-  kundbeslut: { utfall: ["godkant", "avbojt", "delvis"], kanal: "text" },
-  atgard_utford: { text: "text" },
-  kvalitetskontroll: { utfall: ["borta", "kvarstar", "delvis", "ej_verifierat"], beskrivning: "text" },
+  felorsak: {
+    avvikelse: "text",
+    orsaker: "lista",
+    underlag: "lista",
+    sakerhet: ["hog", "medel", "lag"],
+    atgard: "text",
+  },
+  atgardsforslag: { beskrivning: "text" },
+  kundbeslut: { beslut: ["godkant", "avbojt", "delvis"], kanal: "text" },
+  atgard_utford: { beskrivning: "text", utford: "boolean" },
+  kvalitetskontroll: {
+    resultat: ["symptomet_borta", "kvarstar", "delvis", "ej_verifierbar"],
+    beskrivning: "text",
+  },
   kommentar: { text: "text" },
   kategori_byte: { kategori: "text" },
   inaktivitet_forklarad: { text: "text", minuter: "tal" },
   overlamning: { fran: "text" },
   ansvarig_satt: { ansvarig: "text" },
-  ai_svar: { rader: "lista" },
+  ai_svar: { rader: "lista", nastaSteg: "text", modell: "text" },
   export_skapad: { format: "text", version: "tal" },
+  // ALVA-RULE-200: teknikerns varför. Fälten valideras utöver formen i
+  // services/gemensam/motivering.mjs — här kontrolleras bara att de finns.
+  slutsats: { motivering: "text", uteslutet: "text", kvarstaende: "text" },
   arende_avslutat: {},
 };
 

felsokning/services/gemensam/motivering.mjs

@@ -0,0 +1,242 @@
+// ALVA-RULE-200 · Closing statement.
+//
+// Ett ärende stängs aldrig utan att teknikern har lämnat ett varför.
+//
+// Det låter enkelt och är det inte. En obligatorisk fritextruta blir
+// "klart" på tredje ärendet, och då har vi bara gjort dokumentationen
+// långsammare utan att göra den bättre. Ett varför som ska hålla i en
+// garantitvist måste vara strukturerat, kopplat till evidensen, och
+// kvalitetsgranskat mot det som faktiskt skrivs när någon har bråttom.
+//
+// ---- Vad ett varför faktiskt består av -------------------------------
+//
+// Fyra frågor med olika adressat. De blandas i dag ihop till en enda
+// rad i en arbetsorder, och det är därför verkstadsprotokoll är svåra
+// att använda i efterhand:
+//
+//   MOTIVERING    Varför följer slutsatsen av evidensen?
+//                 Läses av: nästa tekniker, försäkringsbedömaren.
+//                 Detta är den rad som saknas i varje system jag sett.
+//                 Underlaget säger VAD som mättes. Slutsatsen säger VAD
+//                 som är fel. Ingenting säger varför det ena medför det
+//                 andra — och det är precis det steget en bedömare
+//                 behöver granska.
+//
+//   UTESLUTET     Vad övervägdes och varför föll det bort?
+//                 Läses av: försäkringsbolaget, garantihandläggaren.
+//                 En felsökning utan uteslutna alternativ är en gissning
+//                 som råkade stämma. Härleds delvis ur loggen: en
+//                 hypotes som dokumenterats och inte blev slutsatsen
+//                 MÅSTE bemötas.
+//
+//   ÅTGÄRDSVAL    Varför denna åtgärd och inte en annan?
+//                 Läses av: kunden, kostnadsgranskaren.
+//                 Byte eller justering? Varför hela enheten?
+//
+//   KVARSTÅENDE   Vad är fortfarande osäkert?
+//                 Läses av: nästa tekniker, flottansvarig.
+//                 Får vara "inget" — men det måste sägas aktivt.
+//
+// ---- Den ärliga vägen -------------------------------------------------
+//
+// Ibland vet teknikern inte varför. Systemet måste ha en väg för det som
+// inte är en lögn: orsaken kunde inte fastställas, och varför den inte
+// kunde det. Det är också ett varför, och ofta ett mer användbart än en
+// påhittad orsak.
+
+/** Fraser som ser ut som svar men inte är det. */
+const ICKESVAR = [
+  "klart",
+  "ok",
+  "okej",
+  "åtgärdat",
+  "atgardat",
+  "fixat",
+  "se ovan",
+  "se logg",
+  "enligt ovan",
+  "som vanligt",
+  "trasig",
+  "defekt",
+  "sliten",
+  "utsliten",
+  "behöver bytas",
+  "behover bytas",
+  "byttes",
+  "bytt",
+  "enligt kund",
+  "kunden sa",
+  "vet ej",
+  "ingen aning",
+  "diverse",
+  "allmänt slitage",
+  "-",
+  "n/a",
+  "na",
+];
+
+// Ett resonemang innehåller ett därför. Utan orsakssamband är texten en
+// omformulering av slutsatsen, inte ett skäl för den.
+const ORSAKSORD = [
+  "eftersom",
+  "därför",
+  "darfor",
+  "beror",
+  "orsakas",
+  "orsakade",
+  "medför",
+  "medfor",
+  "leder till",
+  "ledde till",
+  "vilket",
+  "på grund av",
+  "pga",
+  "resulterar",
+  "resulterade",
+  "innebär",
+  "innebar",
+  "följaktligen",
+  "foljaktligen",
+  "till följd av",
+  "förklarar",
+  "forklarar",
+  "stämmer överens",
+  "stammer overens",
+  "bekräftas av",
+  "bekraftas av",
+  "visar att",
+  "utesluter",
+];
+
+export const MINSTA_MOTIVERING = 40;
+export const MINSTA_KORT = 15;
+
+const normalisera = (text) => String(text ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+
+/** Är texten ett icke-svar? Jämför mot hela fältet, inte delsträngar. */
+function ärIckesvar(text) {
+  const n = normalisera(text).replace(/[.!]+$/, "");
+  return ICKESVAR.includes(n);
+}
+
+function harOrsakssamband(text) {
+  const n = normalisera(text);
+  return ORSAKSORD.some((ord) => n.includes(ord));
+}
+
+/**
+ * Refererar texten till dokumenterad evidens? Godtar både uttryckliga
+ * ord för underlag och konkreta mätvärden med enhet — den som skriver
+ * "12,4 V vid stift 14" hänvisar till en mätning även utan att säga
+ * ordet "mätning".
+ */
+function refererarEvidens(text) {
+  const n = normalisera(text);
+  const ord = ["mät", "mat", "foto", "bild", "video", "felkod", "avläs", "avlas", "prov", "test", "dokument", "historik", "kontroll"];
+  const värde = /\d+([.,]\d+)?\s*(v|volt|a|ampere|ω|ohm|bar|kpa|mpa|nm|°c|c|mm|km|mil|%|g|hz|rpm|varv)\b/;
+  return ord.some((o) => n.includes(o)) || värde.test(n);
+}
+
+/**
+ * Granskar ett fält i slutsatsen.
+ * @returns null när fältet duger, annars en förklaring till teknikern.
+ */
+export function granskaFalt(namn, text, { minsta = MINSTA_KORT, kravOrsak = false } = {}) {
+  const rå = String(text ?? "").trim();
+  if (!rå) return `${namn} saknas.`;
+  if (ärIckesvar(rå)) {
+    return `${namn}: "${rå}" är inget skäl. Beskriv vad som faktiskt gäller och varför.`;
+  }
+  if (rå.length < minsta) {
+    return `${namn} är för kort (${rå.length} av minst ${minsta} tecken) för att gå att granska i efterhand.`;
+  }
+  if (kravOrsak && !harOrsakssamband(rå) && !refererarEvidens(rå)) {
+    return `${namn} anger vad, men inte varför. Knyt slutsatsen till underlaget — vad i evidensen gör att det här följer?`;
+  }
+  return null;
+}
+
+/**
+ * Hypoteser som dokumenterats men inte blivit slutsatsen.
+ *
+ * Härleds ur loggen: den som skrivit ned en misstanke och sedan landat i
+ * något annat måste säga varför den föll bort. Det är den enskilda regel
+ * som gör underlaget användbart för en försäkringsbedömare — utan den är
+ * en felsökning en gissning som råkade stämma.
+ */
+export function obemottaHypoteser(handelser, slutsats) {
+  const hypoteser = handelser.filter((h) => h?.typ === "hypotes").map((h) => h.text);
+  if (hypoteser.length === 0) return [];
+
+  const uteslutet = normalisera(slutsats?.uteslutet);
+  const orsak = normalisera(
+    [slutsats?.motivering, ...(handelser.filter((h) => h?.typ === "felorsak").map((h) => h.avvikelse) ?? [])].join(" "),
+  );
+
+  // En hypotes är bemött om något meningsbärande ord ur den återkommer i
+  // uteslutandet eller i den fastställda orsaken. Trubbigt, men det
+  // fångar den som skriver "uteslutet: inget" med tre öppna hypoteser i
+  // loggen.
+  return hypoteser.filter((text) => {
+    const ord = normalisera(text)
+      .split(/[^a-zåäöéü0-9]+/)
+      .filter((o) => o.length >= 5);
+    if (ord.length === 0) return false;
+    return !ord.some((o) => uteslutet.includes(o) || orsak.includes(o));
+  });
+}
+
+/**
+ * Granskar hela slutsatsen inför avslut.
+ *
+ * @param slutsats  händelsen av typ "slutsats"
+ * @param handelser hela loggen, för de regler som härleds ur den
+ * @returns lista med brister; tom lista betyder godkänd
+ */
+export function granskaSlutsats(slutsats, handelser = []) {
+  const brister = [];
+  const lägg = (fält, text) => text && brister.push({ falt: fält, text });
+
+  if (!slutsats) {
+    return [
+      {
+        falt: "slutsats",
+        text: "Ärendet kan inte avslutas utan en slutsats. Motivera varför slutsatsen följer av underlaget.",
+      },
+    ];
+  }
+
+  const fastställd = slutsats.orsakFastställd !== false;
+
+  if (fastställd) {
+    lägg("motivering", granskaFalt("Motivering", slutsats.motivering, { minsta: MINSTA_MOTIVERING, kravOrsak: true }));
+  } else {
+    // Den ärliga vägen. Att orsaken inte kunnat fastställas är ett
+    // giltigt utfall — men varför den inte kunnat det är fortfarande ett
+    // varför, och det måste stå där.
+    lägg(
+      "motivering",
+      granskaFalt("Skäl till att orsaken inte fastställts", slutsats.motivering, {
+        minsta: MINSTA_MOTIVERING,
+        kravOrsak: true,
+      }),
+    );
+  }
+
+  lägg("uteslutet", granskaFalt("Uteslutna alternativ", slutsats.uteslutet, { minsta: MINSTA_KORT }));
+  lägg("kvarstaende", granskaFalt("Kvarstående osäkerhet", slutsats.kvarstaende, { minsta: 5 }));
+
+  const utfördArbete = handelser.some((h) => h?.typ === "atgard_utford" && h.utford === true);
+  if (utfördArbete) {
+    lägg("atgardsval", granskaFalt("Val av åtgärd", slutsats.atgardsval, { minsta: MINSTA_KORT, kravOrsak: true }));
+  }
+
+  for (const text of obemottaHypoteser(handelser, slutsats)) {
+    brister.push({
+      falt: "uteslutet",
+      text: `Hypotesen "${text}" finns i loggen men bemöts inte. Ange varför den uteslöts, eller varför den kvarstår.`,
+    });
+  }
+
+  return brister;
+}

felsokning/services/plattform/motivering.mjs

@@ -0,0 +1 @@
+../gemensam/motivering.mjs

felsokning/services/plattform/server.mjs

@@ -288,6 +288,17 @@ export const DELBART_KUND = [
   "atgard_utford",
   "kvalitetskontroll",
   "export_skapad",
+  // ALVA-RULE-200 · Teknikerns varför delas med kunden.
+  //
+  // Det är den enda raden som besvarar "varför kostade det här vad det
+  // kostade", och den enda en försäkringsbedömare faktiskt behöver.
+  // Att hålla den intern vore att bygga funktionen och sedan gömma den.
+  //
+  // Fältet "uteslutet" nämner hypoteser som förkastats. Det är inte
+  // samma sak som att dela en öppen hypotes: en utesluten misstanke,
+  // redovisad som utesluten, är stärkande — "vi kontrollerade hjullagret
+  // och det var helt" är precis vad kunden betalade för att få veta.
+  "slutsats",
   "arende_avslutat",
 ];