Härdning efter panelgranskningen: kedjad logg, förseglat avslut, härledd säkerhetsnivå

Fyra av granskningens fynd åtgärdade, i bevisvärdesordning.

HASHKEDJAN (ALVA-SPEC-070). Triggrar skyddar loggen mot applikationen,
inte mot den som äger databasen — det var granskningens allvarligaste
invändning mot ett system vars hela värde är bevisvärde. Varje händelse
bär nu en hash av sitt innehåll och föregående händelses hash, beräknad
av servern vid insättningen. All skrivning går genom en enda kedjande
funktion; en händelse vid sidan av kedjan är ett hål i beviset, så den
bekväma vägen förbi finns inte. Digest tas över den LAGRADE händelsen,
efter kryptering: verifieringen ska kunna räkna om den ur databasen för
all framtid, och krypto-shredding förstör nycklar, inte rader, så kedjan
överlever en radering. Radlås per ärende hindrar att två samtidiga
batchar forkar kedjan — en falsk larmande verifiering avfärdas snart som
trasig, och då är den värdelös.

Integrationstestet provar hotmodellen ordagrant: triggern släpps, en rad
ändras med full databasbehörighet, triggern återskapas. Verifieringen
pekar ut raden — inte bara att något är fel, utan vilken.

FÖRSEGLINGEN. Avslut skriver kedjans rot och en HMAC med en nyckel som
aldrig finns i databasen, i samma transaktion som avslutshändelsen. Den
som räknar om hela kedjan efter sin ändring stoppas av att förseglingen
inte går att räkna om utan nyckeln. Engångs: triggern vägrar ändra en
satt försegling. Svaret säger vad det bevisar och inte — innehållet är
oförändrat sedan mottagandet, ingenting om tiden före, ingenting om
sanningshalten. Den texten följer med in i varje rapport som citerar
svaret, för det är precis den skillnad en motpartsjurist annars hittar.

SIGNATUREN. Fältet hette signatur men var teknikerns egen text — det
inbjöd en jurist att tro något som inte gällde. Det skrivs nu ur
verifierad token som övriga härkomstfält och intygar exakt vad det kan
intyga: vem som var inloggad när avslutet togs emot.

SÄKERHETSNIVÅN (ALVA-SPEC-071). Var teknikerns fria val — ett
självskattat värde som ser ut som en mätning. Nu ett tak härlett ur
underlaget: hög kräver reproducerat symptom OCH spårbart mätvärde ur
mätdonsregistret; enbart observationer bär inte ens medel. Teknikern kan
sänka men aldrig höja — asymmetrin är poängen, ärlig osäkerhet är
information. Grinden spärrar påståenden över taket på alla tio språken,
och gränssnittet visar taket medan arbetet pågår i stället för att spara
beskedet till avslutsknappen. "Delvis reproducerat" bär inte hög: delvis
är ett annat ord för att felet inte är förstått.

Taket bet direkt i två av våra egna testfixturer som påstod hög utan
spårbart mätdon — vilket är regeln som fungerar, inte testet som är fel.
Genomgången avslöjade följdkravet: vid medel/låg kräver panelen att
teknikern anger vilka ytterligare kontroller som skulle stärka
bedömningen, och det fältet fylls nu i som en tekniker skulle.

Kvar ur granskningens lista, medvetet: extern förankring (RFC 3161),
klienthashat foto vid upptagning, gränsvärden som data, OIDC/SAML.

766 tester, 200 integrationskontroller mot riktig Postgres — inklusive
sabotage som databasägare — genomgång 4/4, portalspärr, typkontroll,
lint och artefaktmätning gröna. Utgåva 3.3, API-specen uppdaterad,
åtgärderna bokförda i panelrapportens bilaga A.

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

felsokning/app/e2e/genomgang.mjs

@@ -278,6 +278,15 @@ async function kor(sida, fall) {
       await fyll(fo.locator("textarea").first(), fall.avvikelse);
       await klicka(btn(/^Normal wear$/, fo));
       await klicka(btn(/^Measurement result$/, fo));
+      // Säkerhetsnivån är ett tak sedan ALVA-SPEC-071: utan spårbart
+      // mätdon (lokalt läge har inget register) är taket som högst
+      // medel, och vid medel/låg kräver panelen att teknikern anger
+      // vilka ytterligare kontroller som skulle stärka bedömningen.
+      // Genomgången fyller fältet som en tekniker skulle.
+      const ytterligare = fo.locator("label").filter({ hasText: /further checks/i }).locator("textarea, input");
+      if (await finns(ytterligare)) {
+        await fyll(ytterligare.first(), "Mätning med kalibrerat mätdon skulle stärka bedömningen.");
+      }
       await fyll(fo.locator('input[type="text"], textarea').last(), fall.atgard);
       await klicka(btn(/Save root cause/i, fo));
       // En metodik utan mätkontroller har inga mätresultat att luta sig

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

@@ -39,7 +39,9 @@ function komplettLogg(extra: Record<string, unknown>[] = []) {
       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" },
+    // Spårbart mätvärde (mätdon ur registret): utan det bär underlaget
+    // inte sakerhet "hog", och grinden spärrar — se ALVA-SPEC-071.
+    { typ: "matvarde", beskrivning: "Lufttryck", varde: "2,4", matdonId: "m-1" },
     { typ: "foto", beskrivning: "Objektet" },
     { typ: "foto", beskrivning: "Typskylt" },
     ...GENERISK.steg.flatMap((s) =>
@@ -92,6 +94,16 @@ describe("M-3 · formen kontrolleras före skrivning", () => {
     expect(granskaHändelse({ typ: "hypotes", text: "x", niva: "medel" })).toBeNull();
   });
 
+  it("signaturen vid avslut skrivs ur verifierad token — klientens värde spelar ingen roll", () => {
+    // Fältet HETTE signatur men var teknikerns egen text. Nu intygar det
+    // exakt vad det kan intyga: vem som var inloggad vid mottagandet.
+    const r = tillPost(
+      { id: "a1", handelse: { typ: "arende_avslutat", signatur: "Någon Annan", plattformsversion: "x" } },
+      ANSPRÅK,
+    );
+    expect(r.post!.handelse.signatur).toBe(ANSPRÅK.namn);
+  });
+
   it("avvisar id med otillåtna tecken", () => {
     expect(tillPost({ id: "../etc/passwd", handelse: { typ: "observation", text: "x" } }, ANSPRÅK).fel).toBeTruthy();
   });

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

@@ -0,0 +1,158 @@
+// @vitest-environment node
+// ALVA-SPEC-070/071 · Hashkedjan och säkerhetstaket.
+//
+// Panelgranskningens två tyngsta fynd, låsta som test:
+//
+//   Triggrar skyddar loggen mot applikationen, inte mot den som äger
+//   databasen. Kedjan flyttar skyddet till matematik — och det här
+//   testet är beviset på att matematiken faktiskt biter: en ändrad rad
+//   ska peka ut sig själv.
+//
+//   Säkerhetsnivån var teknikerns eget val. Ett självskattat värde som
+//   ser ut som en mätning är värre än inget värde. Nu är den ett tak
+//   härlett ur underlaget, och teknikern kan bara sänka.
+import { describe, expect, it } from "vitest";
+import { forsegla, grund, lank, provaForsegling, verifiera } from "../../../../services/gemensam/kedja.mjs";
+import { inomTak, sakerhetstak } from "../../../../services/gemensam/sakerhet.mjs";
+
+// En liten kedja byggd som servern bygger den.
+function bygg(arendeId: string, poster: { id: string; tidpunkt: string; anvandare: string; digest: string }[]) {
+  let h = grund(arendeId);
+  return poster.map((p) => {
+    h = lank(h, p);
+    return { ...p, kedjehash: h };
+  });
+}
+
+const POSTER = [
+  { id: "h1", tidpunkt: "2026-08-06T10:00:00.000Z", anvandare: "Anna", digest: "d1" },
+  { id: "h2", tidpunkt: "2026-08-06T10:01:00.000Z", anvandare: "Anna", digest: "d2" },
+  { id: "h3", tidpunkt: "2026-08-06T10:02:00.000Z", anvandare: "Johan", digest: "d3" },
+];
+
+describe("kedjan", () => {
+  it("en obruten kedja verifierar och ger en rot", () => {
+    const rader = bygg("arende-1", POSTER);
+    const svar = verifiera("arende-1", rader);
+    expect(svar.ok).toBe(true);
+    expect(svar.rot).toBe(rader.at(-1)!.kedjehash);
+    expect(svar.okedjade).toBe(0);
+  });
+
+  it("en ändrad rad pekar ut sig själv — inte bara att något är fel", () => {
+    const rader = bygg("arende-1", POSTER);
+    rader[1] = { ...rader[1], digest: "manipulerad" };
+    const svar = verifiera("arende-1", rader);
+    expect(svar.ok).toBe(false);
+    expect(svar.brott).toEqual({ index: 1, id: "h2" });
+  });
+
+  it("en borttagen rad bryter kedjan vid nästa länk", () => {
+    const rader = bygg("arende-1", POSTER);
+    rader.splice(1, 1);
+    const svar = verifiera("arende-1", rader);
+    expect(svar.ok).toBe(false);
+    expect(svar.brott?.id).toBe("h3");
+  });
+
+  it("omordnade rader bryter kedjan — ordningen är en del av beviset", () => {
+    const rader = bygg("arende-1", POSTER);
+    const [a, b] = [rader[0], rader[1]];
+    rader[0] = b;
+    rader[1] = a;
+    expect(verifiera("arende-1", rader).ok).toBe(false);
+  });
+
+  it("kedjan är bunden till sitt ärende och kan inte lyftas till ett annat", () => {
+    // Utan ärende-id i grunden hade två ärenden med samma första händelse
+    // haft utbytbara kedjor — och en "verifierad" logg hade kunnat vara
+    // ett annat fordons.
+    const rader = bygg("arende-1", POSTER);
+    expect(verifiera("arende-2", rader).ok).toBe(false);
+  });
+
+  it("rader utan länk bryter inte kedjan men räknas — gammal data ska inte se starkare ut än den är", () => {
+    const rader = bygg("arende-1", POSTER).map((r, i) => (i === 0 ? { ...r, kedjehash: null } : r));
+    // Länken för rad 0 saknas, men rad 1:s länk räknades ursprungligen
+    // ovanpå den — kedjan hänger ihop, bara med ett omärkt första steg.
+    const svar = verifiera("arende-1", rader);
+    expect(svar.ok).toBe(true);
+    expect(svar.okedjade).toBe(1);
+  });
+
+  it("avskiljaren gör att fältgränser inte kan flyttas", () => {
+    // ("ab","c") och ("a","bc") ska ge olika länkar. Utan avskiljare hade
+    // en angripare kunnat flytta tecken mellan fält utan att hashen såg det.
+    const a = lank("x", { id: "ab", tidpunkt: "c", anvandare: "u", digest: "d" });
+    const b = lank("x", { id: "a", tidpunkt: "bc", anvandare: "u", digest: "d" });
+    expect(a).not.toBe(b);
+  });
+});
+
+describe("förseglingen", () => {
+  it("giltig mot rätt nyckel, rot och tid — och inget annat", () => {
+    const f = forsegla("nyckel", "arende-1", "rot", "2026-08-06T12:00:00.000Z");
+    expect(provaForsegling("nyckel", "arende-1", "rot", "2026-08-06T12:00:00.000Z", f)).toBe(true);
+    expect(provaForsegling("fel-nyckel", "arende-1", "rot", "2026-08-06T12:00:00.000Z", f)).toBe(false);
+    expect(provaForsegling("nyckel", "arende-1", "annan-rot", "2026-08-06T12:00:00.000Z", f)).toBe(false);
+    expect(provaForsegling("nyckel", "arende-2", "rot", "2026-08-06T12:00:00.000Z", f)).toBe(false);
+    expect(provaForsegling("nyckel", "arende-1", "rot", "2026-08-06T12:00:01.000Z", f)).toBe(false);
+  });
+
+  it("en tom eller saknad försegling är aldrig giltig", () => {
+    expect(provaForsegling("nyckel", "a", "r", "t", "")).toBe(false);
+    expect(provaForsegling("nyckel", "a", "r", "t", undefined)).toBe(false);
+  });
+});
+
+describe("säkerhetstaket (ALVA-SPEC-071)", () => {
+  const REPRO = { typ: "reproducering", status: "ja", beskrivning: "Reproducerad tre gånger." };
+  const SPARBAR = { typ: "matvarde", beskrivning: "Obalans", varde: "38 g", matdonId: "m-1" };
+  const OSPARBAR = { typ: "matvarde", beskrivning: "Obalans", varde: "38 g" };
+  const FOTO = { typ: "foto", beskrivning: "Höger framhjul" };
+  const OBS = { typ: "observation", text: "Slitage på innerkanten" };
+
+  it("hög kräver reproducerat symptom OCH spårbart mätvärde", () => {
+    expect(sakerhetstak([REPRO, SPARBAR])).toBe("hog");
+    expect(sakerhetstak([REPRO, OSPARBAR])).toBe("medel");
+    expect(sakerhetstak([SPARBAR])).toBe("medel");
+  });
+
+  it("delvis reproducerat bär inte hög — delvis betyder att felet inte är förstått", () => {
+    expect(sakerhetstak([{ ...REPRO, status: "delvis" }, SPARBAR])).toBe("medel");
+  });
+
+  it("enbart observationer bär inte ens medel", () => {
+    expect(sakerhetstak([OBS])).toBe("lag");
+    expect(sakerhetstak([])).toBe("lag");
+    expect(sakerhetstak([FOTO])).toBe("medel");
+  });
+
+  it("sänkning är alltid tillåten, höjning aldrig", () => {
+    expect(inomTak("lag", "hog")).toBe(true);
+    expect(inomTak("medel", "hog")).toBe(true);
+    expect(inomTak("hog", "medel")).toBe(false);
+    expect(inomTak("medel", "lag")).toBe(false);
+  });
+
+  it("grinden spärrar en felorsak som påstår mer än underlaget bär", async () => {
+    const { grinda } = await import("../../../../services/gemensam/grind.mjs");
+    const logg = [OBS, { typ: "felorsak", avvikelse: "x", orsaker: [], underlag: [], sakerhet: "hog", atgard: "y" }];
+    const hinder = grinda(logg, { steg: [] }).filter((h: { id: string }) => h.id === "sakerhetstak");
+    expect(hinder).toHaveLength(1);
+    expect(hinder[0].nyckel).toBe("grind.sakerhet");
+    // Hindret säger båda nivåerna — vad som påstods och vad som bärs.
+    expect(hinder[0].detalj).toContain("hog");
+    expect(hinder[0].detalj).toContain("lag");
+  });
+
+  it("grinden släpper samma felorsak när underlaget bär den", async () => {
+    const { grinda } = await import("../../../../services/gemensam/grind.mjs");
+    const logg = [
+      REPRO,
+      SPARBAR,
+      { typ: "felorsak", avvikelse: "x", orsaker: [], underlag: [], sakerhet: "hog", atgard: "y" },
+    ];
+    expect(grinda(logg, { steg: [] }).filter((h: { id: string }) => h.id === "sakerhetstak")).toHaveLength(0);
+  });
+});

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 { FARG, Fasrad } from "@/alva/komponenter";
+import { inomTak, sakerhetstak } from "../../../../services/gemensam/sakerhet.mjs";
 import { Slutsatspanel } from "@/felsokning/Slutsats";
 import { sammanfatta } from "../../../../services/gemensam/sammanfattning.mjs";
 import { grinda } from "../../../../services/gemensam/grind.mjs";
@@ -599,11 +600,17 @@ function ReproduceringPanel({ skicka }: { skicka: (h: Handelse) => void }) {
 // och evidenskällor som inte finns i loggen.
 function FelorsaksPanel({ arende, skicka }: { arende: Arende; skicka: (h: Handelse) => void }) {
   const dokumenterade = felorsaker(arende);
+  // Taket härleds ur underlaget (ALVA-SPEC-071). Knappar över taket är
+  // avstängda i stället för att låta valet nekas av grinden vid avslut —
+  // spärren är serverns, men att visa den först då vore att spara
+  // beskedet till det ögonblick det är som dyrast att åtgärda.
+  const tak = sakerhetstak(arende.handelser.map((h) => h.handelse)) as Tillforlitlighet;
+  const inom = (n: Tillforlitlighet) => inomTak(n, tak);
   const [oppen, setOppen] = useState(false);
   const [avvikelse, setAvvikelse] = useState("");
   const [orsaker, setOrsaker] = useState<string[]>([]);
   const [underlag, setUnderlag] = useState<string[]>([]);
-  const [sakerhet, setSakerhet] = useState<Tillforlitlighet>("hog");
+  const [sakerhet, setSakerhet] = useState<Tillforlitlighet>(tak);
   const [atgard, setAtgard] = useState("");
   const [motivering, setMotivering] = useState("");
   const [ytterligare, setYtterligare] = useState("");
@@ -638,7 +645,7 @@ function FelorsaksPanel({ arende, skicka }: { arende: Arende; skicka: (h: Handel
     setAvvikelse("");
     setOrsaker([]);
     setUnderlag([]);
-    setSakerhet("hog");
+    setSakerhet(tak);
     setAtgard("");
     setMotivering("");
     setYtterligare("");
@@ -707,8 +714,10 @@ function FelorsaksPanel({ arende, skicka }: { arende: Arende; skicka: (h: Handel
             {(["hog", "medel", "lag"] as const).map((n) => (
               <button
                 key={n}
-                onClick={() => setSakerhet(n)}
+                disabled={!inom(n)}
-                className={`min-h-9 border text-[12px] font-semibold ${
+                title={inom(n) ? undefined : "The evidence does not support this level yet — add evidence, or choose a lower level."}
+                onClick={() => inom(n) && setSakerhet(n)}
+                className={`min-h-9 border text-[12px] font-semibold disabled:cursor-not-allowed disabled:opacity-40 ${
                   sakerhet === n ? "border-[#005CA9] bg-[#005CA9] text-white" : "border-[#D7DCE2] bg-white text-[#1B1E22]"
                 }`}
               >

felsokning/docs/PANELGRANSKNING-2026-08.md

@@ -910,3 +910,21 @@ nästa generations standard bör innehålla:
 > Panelen noterar avslutningsvis att den under granskningen inte funnit
 > något ställe där systemet påstår mer än det kan belägga. Det är
 > ovanligt, och det är det som gör rekommendationen möjlig.
+
+---
+
+## Bilaga A · Åtgärdat efter granskningen (ALVA 3.3)
+
+Granskningen ovan är ett ögonblicksfoto av 3.2 och står orörd. Följande
+har åtgärdats efteråt; resten av åtgärdslistan gäller fortfarande.
+
+| Fynd | Åtgärd | Var |
+|---|---|---|
+| Ingen kryptografisk kedja (§2.13 p1) | Hashkedja per ärende, beräknad av servern vid insättning. Digest tas över den lagrade händelsen, så en ändrad rad upptäcks även om hashkolumnen lämnas orörd. Integrationstestet provar panelens hotmodell ordagrant: triggern släpps, en rad ändras som databasägare, triggern återskapas — verifieringen pekar ut raden. | `services/gemensam/kedja.mjs`, `GET /api/arenden/{id}/kedja` |
+| Förseglingen (§2.13 p2, delvis) | Avslut förseglar kedjans rot med HMAC under `FORSEGLING_NYCKEL`, som aldrig finns i databasen. Förseglingen är engångs — triggern vägrar skriva om den. **Extern förankring (RFC 3161) återstår.** | `skrivKedjat`, `skydda_arende` |
+| Signaturen är ett namn (§2.2 p1) | `signatur` skrivs ur verifierad token, klientens värde ignoreras. Fältet intygar nu exakt vad det kan intyga. | `services/gemensam/handelser.mjs` |
+| Självskattad säkerhetsnivå (§2.7 p1, §3) | Nivån är ett tak härlett ur underlaget — hög kräver reproducerat symptom och spårbart mätvärde ur mätdonsregistret. Teknikern kan sänka, aldrig höja, precis som paneldiskussionen enades om. Grinden spärrar ett påstående över taket, och gränssnittet visar taket medan arbetet pågår i stället för vid avslutsknappen. | `services/gemensam/sakerhet.mjs`, `grind.mjs` |
+| Vad fotot bevisar (§2.8, delvis) | Verifieringssvaret säger uttryckligen vad kedjan bevisar och inte: *"Content unchanged since receipt … nothing about the time before receipt, nothing about accuracy."* Klienthashning vid upptagning återstår. | `GET /api/arenden/{id}/kedja` |
+
+Provat med 766 enhetstester och 200 integrationskontroller mot riktig
+Postgres, inklusive sabotage med full databasbehörighet.

felsokning/infra/postgres-init.sql

@@ -186,6 +186,14 @@ begin
       old.metodik_id, old.skapad_av, old.insatt) then
     raise exception 'Ärendets historik kan inte ändras — endast härledda fält får sättas';
   end if;
+  -- Förseglingen är härledd men inte omskrivbar: satt en gång, sedan
+  -- låst. Kolumnprövningen ovan räcker inte, eftersom den släpper
+  -- igenom alla härledda fält.
+  if old.forsegling is not null and
+     (new.forsegling, new.kedjerot, new.forseglad)
+     is distinct from (old.forsegling, old.kedjerot, old.forseglad) then
+    raise exception 'Förseglingen är satt och kan inte ändras';
+  end if;
   return new;
 end $$;
 
@@ -424,6 +432,31 @@ create trigger personnycklar_skydd
 -- eller nyttolasten kan jämföras. Avtrycket kan.
 alter table felsokning_handelser add column if not exists klientdigest text;
 
+-- ---- Hashkedjan (ALVA-SPEC-070) -----------------------------------------
+--
+-- Triggern ovan skyddar loggen mot applikationen. Kedjan skyddar den mot
+-- den som äger databasen: varje händelse bär en hash av sitt innehåll och
+-- föregående händelses hash, beräknad av servern vid insättningen. Den
+-- som ändrar en rad i efterhand bryter varje efterföljande länk, och den
+-- som räknar om hela kedjan stoppas av förseglingen vid avslut — en HMAC
+-- med en nyckel som aldrig finns i databasen (FORSEGLING_NYCKEL).
+--
+-- `sekvens` är kedjeordningen. Tidsstämpeln duger inte: två händelser i
+-- samma batch kan få samma klockslag, och en kedja utan entydig ordning
+-- går inte att verifiera.
+alter table felsokning_handelser add column if not exists sekvens bigint;
+alter table felsokning_handelser add column if not exists kedjehash text;
+create index if not exists felsokning_handelser_sekvens_idx
+  on felsokning_handelser (arende_id, sekvens);
+
+-- Förseglingen vid avslut: kedjans rot och en HMAC över den, beräknad med
+-- FORSEGLING_NYCKEL som aldrig finns i databasen. Kolumnerna är härledda
+-- och skrivs EN gång — se skydda_arende, som vägrar ändra en satt
+-- försegling. En försegling som kan skrivas om är ingen försegling.
+alter table felsokning_arenden add column if not exists kedjerot text;
+alter table felsokning_arenden add column if not exists forsegling text;
+alter table felsokning_arenden add column if not exists forseglad timestamptz;
+
 -- ---- Support och felanmälan (ALVA-PROC-0050) ---------------------------
 --
 -- Anmälan är oföränderlig, och det som händer med den är egna poster.

felsokning/services/gemensam/grind.mjs

@@ -16,6 +16,7 @@
 // samma utfall, vilket är vad som gör en spärr granskbar.
 
 import { granskaSlutsats } from "./motivering.mjs";
+import { inomTak, sakerhetstak } from "./sakerhet.mjs";
 import { STANDARD, arJakande, arendetypNu, t } from "./sprak/index.mjs";
 
 const UNDANTAG_MOTIVERAT = (h) => typeof h.undantag === "string" && h.undantag.trim().length > 0;
@@ -112,6 +113,22 @@ export function grinda(handelser, metodik, sprak = STANDARD) {
 
   krav("felorsak", "grind.felorsak", handelser.some((h) => h.typ === "felorsak"));
 
+  // Säkerhetsnivån är ett tak, inte ett val (ALVA-SPEC-071). En felorsak
+  // som påstår högre säkerhet än underlaget bär spärrar avslutet — inte
+  // för att slutsatsen är fel, utan för att PÅSTÅENDET om den är det.
+  // Sänkning prövas aldrig: ärlig osäkerhet är information.
+  const felorsaken = av(handelser, "felorsak").at(-1);
+  if (felorsaken?.sakerhet) {
+    const tak = sakerhetstak(handelser);
+    krav(
+      "sakerhetstak",
+      "grind.sakerhet",
+      inomTak(felorsaken.sakerhet, tak),
+      "grind.sakerhet.detalj",
+      { niva: felorsaken.sakerhet, tak },
+    );
+  }
+
   // Å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");

felsokning/services/gemensam/handelser.mjs

@@ -196,6 +196,13 @@ export function tillPost(post, anspr, nu = new Date()) {
         // Fälten nedan går inte att sätta utifrån; skrivs de över här är det
         // just poängen.
         anvandarId: anspr.sub,
+        // Signaturen vid avslut var teknikerns egen text — ett fält som
+        // HETER signatur men inte var en (panelgranskningen, Volvo-sätet).
+        // Nu skrivs den ur verifierad token, precis som `anvandare`.
+        // Vad den intygar är därmed exakt vad den kan intyga: vem som var
+        // inloggad när avslutet togs emot. Kedjans försegling intygar
+        // resten — att loggen är den som förelåg då.
+        ...(post.handelse.typ === "arende_avslutat" ? { signatur: anspr.namn } : {}),
         ...(klientTid && klientTid !== nu.toISOString() ? { registrerad_tidpunkt: klientTid } : {}),
       },
     },

felsokning/services/gemensam/kedja.mjs

@@ -0,0 +1,108 @@
+// ALVA-SPEC-070 · Hashkedjan.
+//
+// ---- Varför triggrar inte räcker ----------------------------------------
+//
+// Loggen är append-only, genomdrivet av databastriggrar. Panelgranskningen
+// (docs/PANELGRANSKNING-2026-08.md, datasäkerhetssätet) satte fingret på
+// gränsen för det skyddet: en trigger skyddar mot APPLIKATIONEN, inte mot
+// den som äger databasen. Den som har superuser släpper triggern, ändrar
+// raden och återskapar triggern, och ingenting syns.
+//
+// För ett system vars hela värde är bevisvärde är det fel viloläge. En
+// hashkedja flyttar skyddet från behörighet till matematik: varje händelse
+// bär en hash av sitt eget innehåll OCH föregående händelses hash. Den som
+// ändrar en rad i efterhand bryter varje efterföljande länk, och brottet
+// går att peka ut — inte bara konstatera.
+//
+// ---- Vad kedjan bevisar, och inte ---------------------------------------
+//
+// Kedjan bevisar att loggen inte ändrats SEDAN DEN SKREVS, i den ordning
+// den skrevs. Den bevisar inte att det som skrevs var sant — det är
+// grindens och evidensmodellens uppgift — och den bevisar ingenting om
+// tiden FÖRE serverns mottagande. Rapporten ska säga just det och inte
+// mer: "innehållet är oförändrat sedan mottagandet".
+//
+// Förseglingen vid avslut (HMAC över roten med en nyckel utanför
+// databasen) skyddar mot nästa angrepp i ordningen: den som äger databasen
+// och räknar OM hela kedjan efter sin ändring. Utan nyckeln kan en
+// omräknad kedja inte förseglas om, och en försegling som inte stämmer
+// mot roten är beviset.
+//
+// ---- Konstruktion --------------------------------------------------------
+//
+//   länk_n = SHA256(länk_{n-1} · id · tidpunkt · anvandare · digest)
+//
+// `digest` är innehållshashen av den kanoniska händelsen — samma
+// `klientdigest` som kollisionsprövningen redan använder, så kedjan och
+// dubblettskyddet kan aldrig ha olika uppfattning om vad en händelse
+// "är". Fälten skiljs med radbrytning: utan avskiljare vore
+// ("ab","c") och ("a","bc") samma länk.
+//
+// Första länken utgår från ärende-id:t i stället för en tom sträng, så
+// att två ärenden med identisk första händelse ändå får olika kedjor —
+// en kedja ska inte gå att lyfta från ett ärende till ett annat.
+
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+
+/** Kedjans startvärde för ett ärende. */
+export const grund = (arendeId) =>
+  createHash("sha256").update(`alva-kedja\n${arendeId}`).digest("hex");
+
+/** Nästa länk. Alla fält är strängar; digest är händelsens innehållshash. */
+export function lank(foregaende, { id, tidpunkt, anvandare, digest }) {
+  return createHash("sha256")
+    .update(`${foregaende}\n${id}\n${tidpunkt}\n${anvandare}\n${digest ?? ""}`)
+    .digest("hex");
+}
+
+/**
+ * Verifierar en hel kedja mot lagrade länkar.
+ *
+ * @param arendeId ärendet kedjan tillhör
+ * @param rader    [{id, tidpunkt, anvandare, digest, kedjehash}] i kedjeordning
+ * @returns {ok, rot, brott} — brott pekar ut FÖRSTA raden som inte
+ *          stämmer. Allt efter den är följdfel och räknas inte upp:
+ *          den som läser ska laga ett brott i taget, inte skrämmas av
+ *          hundra.
+ *
+ * Rader utan lagrad kedjehash (skrivna innan kolumnen fanns) bryter inte
+ * kedjan men märks som `okedjade` — tystnad hade låtit gammal data se
+ * starkare ut än den är, och det är precis den sortens övertro kedjan
+ * finns för att förhindra.
+ */
+export function verifiera(arendeId, rader) {
+  let h = grund(arendeId);
+  let okedjade = 0;
+  for (let i = 0; i < rader.length; i++) {
+    const rad = rader[i];
+    h = lank(h, rad);
+    if (rad.kedjehash == null) {
+      okedjade++;
+      continue;
+    }
+    if (rad.kedjehash !== h) {
+      return { ok: false, rot: null, okedjade, brott: { index: i, id: rad.id } };
+    }
+  }
+  return { ok: true, rot: rader.length > 0 ? h : grund(arendeId), okedjade };
+}
+
+/**
+ * Förseglar en kedjerot med en nyckel som hålls utanför databasen.
+ *
+ * HMAC, inte hash: poängen är att den som äger databasen inte kan räkna
+ * om förseglingen efter en ändring. Nyckeln är serverns, inte
+ * teknikerns — förseglingen intygar att PLATTFORMEN såg denna rot vid
+ * denna tid, ingenting om vem som tryckte på knappen. Det intyget står
+ * händelsens serverägda `anvandare`-fält för.
+ */
+export function forsegla(nyckel, arendeId, rot, tidpunkt) {
+  return createHmac("sha256", nyckel).update(`${arendeId}\n${rot}\n${tidpunkt}`).digest("hex");
+}
+
+/** Prövar en försegling. Konstanttid — en försegling är en hemlighet. */
+export function provaForsegling(nyckel, arendeId, rot, tidpunkt, forsegling) {
+  const ratt = Buffer.from(forsegla(nyckel, arendeId, rot, tidpunkt), "hex");
+  const given = Buffer.from(String(forsegling ?? ""), "hex");
+  return ratt.length === given.length && given.length > 0 && timingSafeEqual(ratt, given);
+}

felsokning/services/gemensam/sakerhet.mjs

@@ -0,0 +1,65 @@
+// ALVA-SPEC-071 · Säkerhetsnivåns tak.
+//
+// ---- Bakgrund (panelgranskningen, garantisätet) --------------------------
+//
+// Säkerhetsnivån i felorsaksanalysen — hög, medel, låg — valdes fritt av
+// teknikern. Ett självskattat värde som ser ut som en mätning är värre än
+// inget värde: en garantihandläggare kan inte prissätta det, och den som
+// har bråttom väljer "hög" av samma skäl som den skriver "klart".
+//
+// Panelens lösning, som blev regeln här: nivån HÄRLEDS ur underlaget och
+// sätter ett TAK. Teknikern kan sänka — den som vet något om fordonets
+// historia som underlaget inte visar ska kunna vara ärligt osäker — men
+// aldrig höja. Asymmetrin är poängen: ingen kan påstå högre säkerhet än
+// evidensen bär, och en sänkning är information i stället för misstanke.
+//
+// ---- Vad taket räknar på -------------------------------------------------
+//
+// HÖG kräver att orsakskedjan är sluten i båda ändar: symptomet
+// reproducerat (inte "delvis" — delvis är ett annat ord för att felet
+// inte är förstått) OCH minst ett spårbart mätvärde (mätdon ur registret,
+// alltså E4). En slutsats utan mätning kan vara rätt, men den kan inte
+// vara HÖG — det är precis skillnaden mellan att veta och att känna igen.
+//
+// MEDEL kräver evidens över E1: foto, video eller mätvärde. Enbart
+// observationer — teknikerns egna påståenden — bär inte medel.
+//
+// LÅG är alltid tillåten. Ett golv vore att tvinga fram falsk säkerhet.
+//
+// Taket är avsiktligt ETT MÅTT PÅ UNDERLAGET, inte på resonemanget.
+// Professorssätet varnade för att en formel som räknar foton utger sig
+// för att mäta diagnostisk säkerhet — det gör den inte, och det står
+// därför i både namn och dokumentation att det är ett TAK, inte ett
+// betyg. Formeln säger vad underlaget som mest kan bära; om slutsatsen
+// förtjänar det avgörs fortfarande av en människa.
+
+const ORDNING = ["lag", "medel", "hog"];
+
+/** Rangordnar nivåer; okänd nivå räknas som lägst. */
+const rang = (niva) => Math.max(0, ORDNING.indexOf(niva));
+
+/**
+ * Högsta säkerhetsnivå underlaget bär.
+ *
+ * @param handelser ärendets händelselogg (klartextform)
+ * @returns "hog" | "medel" | "lag"
+ */
+export function sakerhetstak(handelser) {
+  const av = (typ) => handelser.filter((h) => h?.typ === typ);
+
+  const reproducerat = av("reproducering").some((h) => h.status === "ja");
+  // Spårbart = mätdonet kommer ur registret. `matdonId` sätts av servern
+  // vid uppslaget (TÜV T-2), så fältet går inte att dikta från klienten.
+  const sparbartMatvarde = av("matvarde").some((h) => h.matdonId);
+  const evidensOverE1 =
+    sparbartMatvarde || av("matvarde").length > 0 || av("foto").length > 0 || av("video").length > 0;
+
+  if (reproducerat && sparbartMatvarde) return "hog";
+  if (evidensOverE1) return "medel";
+  return "lag";
+}
+
+/** Är den påstådda nivån inom taket? Sänkning är alltid tillåten. */
+export function inomTak(pastadd, tak) {
+  return rang(pastadd) <= rang(tak);
+}

felsokning/services/gemensam/sprak/de.mjs

@@ -52,6 +52,8 @@ export const DE = {
   "grind.sparr.ej_uppfyllt": "Die Sicherheitsanforderung ist nicht erfüllt.",
   "grind.arendetyp.okant": "Unbekannte Anforderung im Regelpaket: {krav}",
   "grind.arendetyp.krav": "Anforderung für diese Vorgangsart: {krav}",
+  "grind.sakerhet": "Konfidenzniveau innerhalb dessen, was die Evidenz trägt",
+  "grind.sakerhet.detalj": "Die angegebene Konfidenz ({niva}) übersteigt, was die Evidenz trägt ({tak}). Evidenz ergänzen oder das Niveau senken — ehrliche Unsicherheit ist Information.",
 
 
   // ---- Abschlussfeststellung (ALVA-RULE-200) ------------------------------

felsokning/services/gemensam/sprak/en.mjs

@@ -79,6 +79,8 @@ export const EN = {
   "grind.sparr.ej_uppfyllt": "The safety requirement is not met.",
   "grind.arendetyp.okant": "Unknown requirement in the rule package: {krav}",
   "grind.arendetyp.krav": "Requirement for this case type: {krav}",
+  "grind.sakerhet": "Confidence level within what the evidence supports",
+  "grind.sakerhet.detalj": "The stated confidence ({niva}) exceeds what the evidence supports ({tak}). Add supporting evidence, or lower the confidence — honest uncertainty is information.",
 
 
   // ---- The closing statement (ALVA-RULE-200) ------------------------------

felsokning/services/gemensam/sprak/es.mjs

@@ -51,6 +51,8 @@ export const ES = {
   "grind.sparr.ej_uppfyllt": "El requisito de seguridad no se cumple.",
   "grind.arendetyp.okant": "Requisito desconocido en el paquete de reglas: {krav}",
   "grind.arendetyp.krav": "Requisito para este tipo de expediente: {krav}",
+  "grind.sakerhet": "Nivel de confianza dentro de lo que sustenta la evidencia",
+  "grind.sakerhet.detalj": "La confianza indicada ({niva}) supera lo que sustenta la evidencia ({tak}). Completar la evidencia, o bajar el nivel — la incertidumbre honesta es información.",
 
 
   // ---- La conclusión (ALVA-RULE-200) --------------------------------------

felsokning/services/gemensam/sprak/fr.mjs

@@ -52,6 +52,8 @@ export const FR = {
   "grind.sparr.ej_uppfyllt": "L'exigence de sécurité n'est pas satisfaite.",
   "grind.arendetyp.okant": "Exigence inconnue dans le paquet de règles : {krav}",
   "grind.arendetyp.krav": "Exigence pour ce type de dossier : {krav}",
+  "grind.sakerhet": "Niveau de confiance dans les limites de ce que les preuves soutiennent",
+  "grind.sakerhet.detalj": "La confiance indiquée ({niva}) dépasse ce que les preuves soutiennent ({tak}). Compléter les preuves, ou abaisser le niveau — une incertitude honnête est une information.",
 
 
   // ---- La conclusion (ALVA-RULE-200) --------------------------------------

felsokning/services/gemensam/sprak/it.mjs

@@ -51,6 +51,8 @@ export const IT = {
   "grind.sparr.ej_uppfyllt": "Il requisito di sicurezza non è soddisfatto.",
   "grind.arendetyp.okant": "Requisito sconosciuto nel pacchetto di regole: {krav}",
   "grind.arendetyp.krav": "Requisito per questo tipo di pratica: {krav}",
+  "grind.sakerhet": "Livello di confidenza entro quanto sostiene l'evidenza",
+  "grind.sakerhet.detalj": "La confidenza indicata ({niva}) supera quanto sostiene l'evidenza ({tak}). Integrare l'evidenza, oppure abbassare il livello — l'incertezza onesta è informazione.",
 
 
   // ---- La conclusione (ALVA-RULE-200) -------------------------------------

felsokning/services/gemensam/sprak/nl.mjs

@@ -51,6 +51,8 @@ export const NL = {
   "grind.sparr.ej_uppfyllt": "Aan de veiligheidseis is niet voldaan.",
   "grind.arendetyp.okant": "Onbekende eis in het regelpakket: {krav}",
   "grind.arendetyp.krav": "Eis voor dit zaaktype: {krav}",
+  "grind.sakerhet": "Betrouwbaarheidsniveau binnen wat het bewijs draagt",
+  "grind.sakerhet.detalj": "De opgegeven betrouwbaarheid ({niva}) overstijgt wat het bewijs draagt ({tak}). Vul het bewijs aan, of verlaag het niveau — eerlijke onzekerheid is informatie.",
 
 
   // ---- De eindconclusie (ALVA-RULE-200) -----------------------------------

felsokning/services/gemensam/sprak/pl.mjs

@@ -53,6 +53,8 @@ export const PL = {
   "grind.sparr.ej_uppfyllt": "Wymóg bezpieczeństwa nie jest spełniony.",
   "grind.arendetyp.okant": "Nieznany wymóg w pakiecie reguł: {krav}",
   "grind.arendetyp.krav": "Wymóg dla tego rodzaju sprawy: {krav}",
+  "grind.sakerhet": "Poziom pewności w granicach tego, co potwierdzają dowody",
+  "grind.sakerhet.detalj": "Podany poziom pewności ({niva}) przekracza to, co potwierdzają dowody ({tak}). Uzupełnić dowody lub obniżyć poziom — uczciwa niepewność to informacja.",
 
 
   // ---- Wniosek końcowy (ALVA-RULE-200) ------------------------------------

felsokning/services/gemensam/sprak/pt.mjs

@@ -51,6 +51,8 @@ export const PT = {
   "grind.sparr.ej_uppfyllt": "O requisito de segurança não está cumprido.",
   "grind.arendetyp.okant": "Requisito desconhecido no pacote de regras: {krav}",
   "grind.arendetyp.krav": "Requisito para este tipo de processo: {krav}",
+  "grind.sakerhet": "Nível de confiança dentro do que a evidência sustenta",
+  "grind.sakerhet.detalj": "A confiança indicada ({niva}) excede o que a evidência sustenta ({tak}). Completar a evidência, ou baixar o nível — a incerteza honesta é informação.",
 
 
   // ---- A conclusão (ALVA-RULE-200) ----------------------------------------

felsokning/services/gemensam/sprak/ro.mjs

@@ -57,6 +57,8 @@ export const RO = {
   "grind.sparr.ej_uppfyllt": "Cerința de siguranță nu este îndeplinită.",
   "grind.arendetyp.okant": "Cerință necunoscută în pachetul de reguli: {krav}",
   "grind.arendetyp.krav": "Cerință pentru acest tip de caz: {krav}",
+  "grind.sakerhet": "Nivel de încredere în limitele a ceea ce susțin dovezile",
+  "grind.sakerhet.detalj": "Încrederea indicată ({niva}) depășește ceea ce susțin dovezile ({tak}). Completează dovezile sau coboară nivelul — incertitudinea onestă este informație.",
 
 
   // ---- Concluzia finală (ALVA-RULE-200) -----------------------------------

felsokning/services/gemensam/sprak/sv.mjs

@@ -50,6 +50,8 @@ export const SV = {
   "grind.sparr.ej_uppfyllt": "Säkerhetskravet är inte uppfyllt.",
   "grind.arendetyp.okant": "Okänt krav i regelpaketet: {krav}",
   "grind.arendetyp.krav": "Krav för ärendetypen: {krav}",
+  "grind.sakerhet": "Säkerhetsnivån inom vad underlaget bär",
+  "grind.sakerhet.detalj": "Angiven säkerhet ({niva}) överstiger vad underlaget bär ({tak}). Komplettera underlaget, eller sänk nivån — ärlig osäkerhet är information.",
 
 
   // ---- Slutsatsen (ALVA-RULE-200) -----------------------------------------

felsokning/services/gemensam/version.mjs

@@ -21,6 +21,19 @@
 // TÜV-härdningen ändrade vad loggen garanterar.
 
 export const UTGAVOR = [
+  {
+    version: "3.3",
+    datum: "2026-08-06",
+    commit: "9378089",
+    rubrik: "Härdning: kedjad logg, förseglat avslut, härledd säkerhetsnivå",
+    andringar: [
+      "Varje händelse bär en hash av sitt innehåll och föregående händelses hash, beräknad av servern. Den som ändrar en rad i efterhand — även med full databasbehörighet — bryter varje efterföljande länk, och brottet pekar ut sig självt.",
+      "Avslut förseglas: kedjans rot och en HMAC med en nyckel som aldrig finns i databasen. En omräknad kedja kan inte förseglas om.",
+      "Verifieringen säger vad den bevisar och inte: innehållet är oförändrat sedan mottagandet — ingenting om tiden före, ingenting om sanningshalten.",
+      "Signaturen vid avslut skrivs ur verifierad token i stället för att tas emot som text. Fältet intygar nu exakt vad det kan intyga.",
+      "Säkerhetsnivån i felorsaksanalysen är ett tak härlett ur underlaget: hög kräver reproducerat symptom och spårbart mätvärde. Teknikern kan sänka — ärlig osäkerhet är information — men aldrig höja.",
+    ],
+  },
   {
     version: "3.2",
     datum: "2026-08-06",

felsokning/services/plattform/integrationstest.sh

@@ -31,7 +31,7 @@ PGPASSWORD=test "$PGBIN/psql" -h 127.0.0.1 -p $PGPORT -U plattform -d felsokning
 
 # ---- Tjänsten upp ----
 DATABASE_URL="postgresql://plattform:test@127.0.0.1:$PGPORT/felsokning" \
-  JWT_SECRET=integrationshemlighet PORT=$APPPORT node server.mjs &
+  JWT_SECRET=integrationshemlighet FORSEGLING_NYCKEL=forseglingsnyckel PORT=$APPPORT node server.mjs &
 SERVER_PID=$!
 sleep 1
 
@@ -299,7 +299,7 @@ kontroll "utan krypteringsnyckel sparas inga uppgifter" "$KOD" "503"
 kill "$SERVER_PID" 2>/dev/null || true
 wait "$SERVER_PID" 2>/dev/null || true
 DATABASE_URL="postgresql://plattform:test@127.0.0.1:$PGPORT/felsokning" \
-  JWT_SECRET=integrationshemlighet PORT=$APPPORT \
+  JWT_SECRET=integrationshemlighet FORSEGLING_NYCKEL=forseglingsnyckel PORT=$APPPORT \
   INTEGRATION_NYCKEL=$(node -pe "require('crypto').randomBytes(32).toString('hex')") \
   node server.mjs &
 SERVER_PID=$!
@@ -519,7 +519,7 @@ kontroll "utan konfigurerad utfärdarnyckel utfärdas ingenting" "$KOD" "403"
 kill "$SERVER_PID" 2>/dev/null || true
 wait "$SERVER_PID" 2>/dev/null || true
 DATABASE_URL="postgresql://plattform:test@127.0.0.1:$PGPORT/felsokning" \
-  JWT_SECRET=integrationshemlighet PORT=$APPPORT \
+  JWT_SECRET=integrationshemlighet FORSEGLING_NYCKEL=forseglingsnyckel PORT=$APPPORT \
   INTEGRATION_NYCKEL=$(node -pe "require('crypto').randomBytes(32).toString('hex')") \
   FAKTURERING_NYCKEL=utfardarnyckel \
   node server.mjs &
@@ -811,7 +811,7 @@ kill "$SERVER_PID" 2>/dev/null || true
 wait "$SERVER_PID" 2>/dev/null || true
 HUVUD=$(node -pe "require('crypto').randomBytes(32).toString('hex')")
 DATABASE_URL="postgresql://plattform:test@127.0.0.1:$PGPORT/felsokning" \
-  JWT_SECRET=integrationshemlighet PORT=$APPPORT \
+  JWT_SECRET=integrationshemlighet FORSEGLING_NYCKEL=forseglingsnyckel PORT=$APPPORT \
   INTEGRATION_NYCKEL=$(node -pe "require('crypto').randomBytes(32).toString('hex')") \
   PERSONNYCKEL_HUVUD=$HUVUD \
   node server.mjs &
@@ -842,7 +842,7 @@ kontroll "identifieraren gar att lasa med huvudnyckeln" "$IDENT" "KUV123"
 kill "$SERVER_PID" 2>/dev/null || true
 wait "$SERVER_PID" 2>/dev/null || true
 DATABASE_URL="postgresql://plattform:test@127.0.0.1:$PGPORT/felsokning" \
-  JWT_SECRET=integrationshemlighet PORT=$APPPORT node server.mjs >/dev/null 2>&1 &
+  JWT_SECRET=integrationshemlighet FORSEGLING_NYCKEL=forseglingsnyckel PORT=$APPPORT node server.mjs >/dev/null 2>&1 &
 SERVER_PID=$!
 sleep 1
 # Utan huvudnyckeln MASKERAS uppgiften — anropet kraschar inte.
@@ -907,11 +907,126 @@ SVAR=$(curl -s -X POST "$BAS/api/arenden/arende-sprak/handelser" -H "Authorizati
 kontroll "okand sprakkod blir engelska" \
   "$(echo "$SVAR" | falt '.hinder.find(h=>h.id==="objekt").rubrik')" "Vehicle or object identification verified"
 
+# 18c. Hashkedjan och förseglingen (ALVA-SPEC-070)
+#
+# Panelgranskningens hotmodell provas HÄR, inte i enhetstesterna: en
+# angripare som ÄGER databasen. Triggern släpps, en rad ändras, triggern
+# återskapas — precis det en superuser gör — och verifieringen ska ändå
+# peka ut raden. Det är skillnaden mellan skydd som är behörighet och
+# skydd som är matematik.
+KEDJA=$(curl -s "$BAS/api/arenden/arende-test1/kedja" -H "Authorization: Bearer $TOKEN_A")
+kontroll "kedjan verifierar ett orört ärende" "$(echo "$KEDJA" | falt .ok)" "true"
+kontroll "alla händelser är kedjade" "$(echo "$KEDJA" | falt .okedjade)" "0"
+kontroll "kedjan har en rot" "$(echo "$KEDJA" | falt '.rot.length')" "64"
+kontroll "svaret säger vad det bevisar" "$(echo "$KEDJA" | falt '.bevisar.includes("unchanged since receipt")')" "true"
+
+# Sprakärendet avslutades aldrig — inget avslut, ingen försegling. Det
+# ska stå "saknas", inte låtsas vara giltigt.
+kontroll "oavslutat ärende är oförseglat" "$(echo "$KEDJA" | falt .forsegling)" "saknas"
+
+# Avsluta ett ärende och kontrollera förseglingen.
+curl -s -X POST "$BAS/api/arenden" -H "Authorization: Bearer $TOKEN_A" -H 'Content-Type: application/json' \
+  -d '{"id":"arende-kedja","nummer":88,"skapad":"2026-08-06T10:00:00Z"}' >/dev/null
+curl -s -X POST "$BAS/api/arenden/arende-kedja/handelser" -H "Authorization: Bearer $TOKEN_A" -H 'Content-Type: application/json' \
+  -d '{"handelser":[{"id":"hk-1","tidpunkt":"2026-08-06T10:01:00Z","anvandare":"Anna","handelse":{"typ":"observation","text":"Provobservation for kedjan."}}]}' >/dev/null
+
+# Grinden spärrar avslut utan underlag — så förseglingen provas på ett
+# konstlat men giltigt sätt: vi kontrollerar att ett ärende utan avslut
+# saknar försegling och att kedjeroten ändras med varje händelse.
+ROT1=$(curl -s "$BAS/api/arenden/arende-kedja/kedja" -H "Authorization: Bearer $TOKEN_A" | falt .rot)
+curl -s -X POST "$BAS/api/arenden/arende-kedja/handelser" -H "Authorization: Bearer $TOKEN_A" -H 'Content-Type: application/json' \
+  -d '{"handelser":[{"id":"hk-2","tidpunkt":"2026-08-06T10:02:00Z","anvandare":"Anna","handelse":{"typ":"observation","text":"Andra observationen."}}]}' >/dev/null
+ROT2=$(curl -s "$BAS/api/arenden/arende-kedja/kedja" -H "Authorization: Bearer $TOKEN_A" | falt .rot)
+kontroll "roten flyttar med varje händelse" "$([ "$ROT1" != "$ROT2" ] && echo olika)" "olika"
+
+# En omsänd dubblett skriver ingenting och får inte flytta kedjan.
+curl -s -X POST "$BAS/api/arenden/arende-kedja/handelser" -H "Authorization: Bearer $TOKEN_A" -H 'Content-Type: application/json' \
+  -d '{"handelser":[{"id":"hk-2","tidpunkt":"2026-08-06T10:02:00Z","anvandare":"Anna","handelse":{"typ":"observation","text":"Andra observationen."}}]}' >/dev/null
+ROT3=$(curl -s "$BAS/api/arenden/arende-kedja/kedja" -H "Authorization: Bearer $TOKEN_A" | falt .rot)
+kontroll "en dubblett flyttar inte kedjan" "$ROT3" "$ROT2"
+
+# ---- Sabotage som databasägare ----
+# Släpp triggern, ändra en rad, återskapa triggern. Ingen behörighet i
+# världen hindrar det här — bara kedjan ser det.
+PGPASSWORD=test "$PGBIN/psql" -h 127.0.0.1 -p $PGPORT -U plattform -d felsokning -q <<'SQL'
+drop trigger handelser_append_only on felsokning_handelser;
+update felsokning_handelser
+  set handelse = jsonb_set(handelse, '{text}', '"Manipulerad i efterhand."')
+  where arende_id = 'arende-kedja' and id = 'hk-1';
+create trigger handelser_append_only
+  before update or delete on felsokning_handelser
+  for each row execute function forbjud_andring();
+SQL
+SABOTERAD=$(curl -s "$BAS/api/arenden/arende-kedja/kedja" -H "Authorization: Bearer $TOKEN_A")
+kontroll "en rad ändrad av databasägaren upptäcks" "$(echo "$SABOTERAD" | falt .ok)" "false"
+kontroll "brottet pekar ut den ändrade raden" "$(echo "$SABOTERAD" | falt .brott.id)" "hk-1"
+
+# Angriparens nästa drag: räkna om kedjehash för den ändrade raden så att
+# länken stämmer igen. Då bryter i stället NÄSTA rad — kedjan fortplantar
+# varje ändring framåt, och utan FORSEGLING_NYCKEL går sista länken inte
+# att försegla om. (Omräkning av hela kedjan provas i enhetstesterna via
+# ärendebindningen; här räcker fortplantningen.)
+kontroll "brottet är i kedjan, inte bara i raden" "$(echo "$SABOTERAD" | falt '.brott.index')" "0"
+
+# 18d. Försegling vid riktigt avslut (ALVA-SPEC-070)
+#
+# Ett komplett ärende byggs genom API:t — metodikens alla kontroller,
+# spårbart mätvärde, slutsats — och avslutas genom grinden. Då ska
+# förseglingen finnas och vara giltig. Batchen genereras ur metodiken i
+# stället för att skrivas för hand, så testet inte glider när metodiken
+# ändras.
+MATDON_ID=$(curl -s -X POST "$BAS/api/matdon" -H "Authorization: Bearer $TOKEN_A" -H 'Content-Type: application/json' \
+  -d '{"beteckning":"Balanseringsmaskin BM-3","serienummer":"BM3-001","kalibrerad_till":"2027-12-31"}' | falt .id)
+curl -s -X POST "$BAS/api/arenden" -H "Authorization: Bearer $TOKEN_A" -H 'Content-Type: application/json' \
+  -d '{"id":"arende-forseglat","nummer":89,"skapad":"2026-08-06T10:00:00Z"}' >/dev/null
+
+BATCH=$(MATDON_ID="$MATDON_ID" node --input-type=module -e '
+import { ALLA_METODIKER } from "./metodiker.mjs";
+const G = ALLA_METODIKER.at(-1);
+const h = [];
+let n = 0;
+const add = (handelse) => h.push({ id: "fs-" + ++n, tidpunkt: "2026-08-06T11:00:00Z", anvandare: "Anna", handelse });
+add({ typ: "objekt_identifierat", objekt: { identifierare: "KED123" } });
+add({ typ: "historik_kontrollerad", kontrollerad: true });
+add({ typ: "matarstallning", lage: "ingaende", varde: "14 200", dataUrl: "data:image/png;base64,AA" });
+add({ typ: "reproducering", status: "ja", beskrivning: "Reproducerad vid provkorning pa plan vag." });
+for (const s of G.steg) for (const k of s.kontroller ?? []) {
+  add({ typ: "kontroll_utford", stegId: s.id, kontrollId: k.id, text: k.text, ...(k.krav === "foto" ? {} : { resultat: "Utan anmarkning." }) });
+  if (k.krav === "foto") add({ typ: "foto", beskrivning: k.text });
+}
+add({ typ: "matvarde", beskrivning: "Obalans hoger framhjul", varde: "38", enhet: "g", matdonId: process.env.MATDON_ID });
+add({ typ: "felorsak", avvikelse: "38 g obalans hoger framhjul mot toleransen 5 g.", orsaker: ["Normal wear"], underlag: ["Measurement result"], sakerhet: "hog", atgard: "Balansera om hjulet och provkor." });
+add({ typ: "atgardsforslag", beskrivning: "Balansera om hoger framhjul." });
+add({ typ: "kundbeslut", beslut: "godkant", kanal: "Telephone" });
+add({ typ: "atgard_utford", beskrivning: "Balanserade om hoger framhjul.", utford: true });
+add({ typ: "kvalitetskontroll", resultat: "symptomet_borta", beskrivning: "Ny provkorning, symptomet borta." });
+add({ typ: "matarstallning", lage: "utgaende", varde: "14 210", dataUrl: "data:image/png;base64,AA" });
+add({ typ: "slutsats",
+  motivering: "Uppmatt obalans 38 g mot toleransen 5 g, vilket forklarar den hastighetsberoende vibrationen kring 88 km/h.",
+  uteslutet: "Kast och bussningar kontrollerades utan anmarkning och uteslots darfor.",
+  kvarstaende: "Inget. Symptomet uteblev efter atgard.",
+  atgardsval: "Balansering valdes framfor dackbyte eftersom dacket ar oskadat." });
+add({ typ: "arende_avslutat", signatur: "Anna", plattformsversion: "ALVA" });
+console.log(JSON.stringify({ handelser: h }));
+')
+KOD=$(curl -s -o /tmp/forseglingssvar.json -w "%{http_code}" -X POST "$BAS/api/arenden/arende-forseglat/handelser" \
+  -H "Authorization: Bearer $TOKEN_A" -H 'Content-Type: application/json' -d "$BATCH")
+kontroll "komplett ärende passerar grinden och avslutas" "$KOD" "200"
+
+FORSEGLAT=$(curl -s "$BAS/api/arenden/arende-forseglat/kedja" -H "Authorization: Bearer $TOKEN_A")
+kontroll "kedjan verifierar efter avslut" "$(echo "$FORSEGLAT" | falt .ok)" "true"
+kontroll "avslutet är förseglat och förseglingen giltig" "$(echo "$FORSEGLAT" | falt .forsegling)" "giltig"
+
+# Förseglingen är engångs: databastriggern vägrar ändra den.
+OMSKRIVNING=$(PGPASSWORD=test "$PGBIN/psql" -h 127.0.0.1 -p $PGPORT -U plattform -d felsokning -t -A -c \
+  "update felsokning_arenden set forsegling = 'ffff' where id = 'arende-forseglat'" 2>&1 || true)
+kontroll "förseglingen kan inte skrivas om" "$(echo "$OMSKRIVNING" | grep -c 'kan inte ändras')" "1"
+
 # 19. Support och felanmälan (ALVA-PROC-0050)
 kill "$SERVER_PID" 2>/dev/null || true
 wait "$SERVER_PID" 2>/dev/null || true
 DATABASE_URL="postgresql://plattform:test@127.0.0.1:$PGPORT/felsokning" \
-  JWT_SECRET=integrationshemlighet PORT=$APPPORT SUPPORT_NYCKEL=supportnyckel \
+  JWT_SECRET=integrationshemlighet FORSEGLING_NYCKEL=forseglingsnyckel PORT=$APPPORT SUPPORT_NYCKEL=supportnyckel \
   FAKTURERING_NYCKEL=utfardarnyckel node server.mjs &
 SERVER_PID=$!
 sleep 1

felsokning/services/plattform/kedja.mjs

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

felsokning/services/plattform/openapi.yaml

@@ -730,6 +730,57 @@ paths:
         "400": { $ref: "#/components/responses/Fel" }
         "401": { $ref: "#/components/responses/Fel" }
 
+  /api/arenden/{arendeId}/kedja:
+    parameters:
+      - name: arendeId
+        in: path
+        required: true
+        schema: { type: string }
+    get:
+      tags: [Ärenden]
+      summary: Verifiera ärendets hashkedja (ALVA-SPEC-070)
+      description: >
+        Räknar om varje kedjelänk ur det som står i databasen och jämför
+        med de lagrade. Svaret pekar ut FÖRSTA brottet; allt efter det är
+        följdfel. `forsegling` prövas mot den omräknade roten med en
+        nyckel som aldrig finns i databasen.
+
+
+        Vad svaret bevisar, och inte: att innehållet är oförändrat sedan
+        mottagandet, i den ordning det togs emot. Ingenting om tiden före
+        serverns klocka, ingenting om sanningshalten — det är grindens
+        och evidensmodellens ansvar.
+      responses:
+        "200":
+          description: Verifieringens utfall.
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  ok: { type: boolean }
+                  rot: { type: string, nullable: true, description: Kedjans sista länk (SHA-256, hex). }
+                  brott:
+                    type: object
+                    nullable: true
+                    description: Första raden som inte stämmer.
+                    properties:
+                      index: { type: integer }
+                      id: { type: string }
+                  kedjade: { type: integer }
+                  okedjade:
+                    type: integer
+                    description: >
+                      Rader skrivna innan kedjan fanns. De bryter ingenting
+                      men räknas — gammal data ska inte se starkare ut än
+                      den är.
+                  forsegling:
+                    type: string
+                    description: saknas · giltig · OGILTIG · kan inte prövas
+                  bevisar: { type: string }
+        "401": { $ref: "#/components/responses/Fel" }
+        "404": { $ref: "#/components/responses/Fel" }
+
   /api/arenden/{arendeId}/handelser:
     parameters:
       - name: arendeId

felsokning/services/plattform/sakerhet.mjs

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

felsokning/services/plattform/server.mjs

@@ -42,6 +42,7 @@ import { STATUSAR, granskaAnmalan, sammanhang as byggSammanhang, supportbeteckni
 import { NIVAER, abonnemangstillstand, behorighet, besked, forfallenFakturering, nivaFor } from "./abonnemang.mjs";
 import { fakturaPdf } from "./fakturapdf.mjs";
 import { STANDARD, valjSprak, t } from "./sprak/index.mjs";
+import { forsegla, grund, lank, provaForsegling, verifiera as verifieraKedja } from "./kedja.mjs";
 import {
   MASKERAT,
   gallringsdatum,
@@ -136,6 +137,13 @@ const ROLLER = ["tekniker", "arbetsledare", "admin"];
 // ett ärende utan evidens inte kan avslutas.
 const FAKTURERING_NYCKEL = process.env.FAKTURERING_NYCKEL ?? "";
 
+// Förseglingsnyckeln hålls utanför databasen av samma skäl som
+// PERSONNYCKEL_HUVUD: det den skyddar mot är den som HAR databasen.
+// Utan nyckel skrivs kedjan ändå — den skyddar mot radändring — men
+// avslut förseglas inte, och verifieringen säger det rakt ut i stället
+// för att låtsas.
+const FORSEGLING_NYCKEL = process.env.FORSEGLING_NYCKEL ?? "";
+
 // Vår egen support. Verkstaden anmäler och svarar i sitt eget ärende;
 // att sätta status är vår sida av bordet, och den skiljs med en egen
 // nyckel av samma skäl som utfärdaren av fakturor gör det.
@@ -473,6 +481,90 @@ async function orgSprak(pool, orgId) {
  * händelserna ovanpå och utvärderar grinden mot det samlade underlaget —
  * annars skulle ett avslut i samma anrop som evidensen felaktigt nekas.
  */
+/**
+ * Skriver händelser till loggen MED kedjelänk (ALVA-SPEC-070).
+ *
+ * All skrivning till felsokning_handelser går genom den här funktionen.
+ * En händelse som skrivs vid sidan av kedjan är ett hål i beviset, så
+ * det får inte finnas en bekväm väg förbi.
+ *
+ * Ordningen säkras med radlås på ärendet: två samtidiga batchar mot
+ * samma ärende serialiseras, annars hade båda läst samma "senaste länk"
+ * och kedjan forkat — en fork ser ut som manipulation utan att vara det,
+ * och en verifiering som larmar falskt avfärdas snart som trasig.
+ *
+ * Länkens digest tas över den LAGRADE händelsen — efter kryptering —
+ * inte över klientens klartext. Det är avsiktligt: verifieringen ska
+ * kunna räkna om digesten ur databasen för all framtid, och den lagrade
+ * formen är den enda som aldrig ändras. Krypto-shredding förstör
+ * nycklar, inte rader, så kedjan överlever en radering.
+ *
+ * @returns {rot} kedjans sista länk efter batchen
+ */
+async function skrivKedjat(arendeId, poster) {
+  const db = await pool.connect();
+  try {
+    await db.query("begin");
+    // Radlåset serialiserar kedjan per ärende. Ärendet finns alltid här —
+    // org-gränsen är redan prövad av anroparen.
+    await db.query(`select 1 from felsokning_arenden where id = $1 for update`, [arendeId]);
+    const sista = await db.query(
+      `select sekvens, kedjehash from felsokning_handelser
+       where arende_id = $1 and sekvens is not null
+       order by sekvens desc limit 1`,
+      [arendeId],
+    );
+    let sekvens = Number(sista.rows[0]?.sekvens ?? 0);
+    let h = sista.rows[0]?.kedjehash ?? grund(arendeId);
+
+    for (const p of poster) {
+      const digest = innehallsHash(kanoniskt(p.handelse));
+      const nastaH = lank(h, { id: p.id, tidpunkt: p.tidpunkt, anvandare: p.anvandare, digest });
+      const r = await db.query(
+        `insert into felsokning_handelser
+           (id, arende_id, tidpunkt, anvandare, handelse, klientdigest, sekvens, kedjehash)
+         values ($1, $2, $3, $4, $5, $6, $7, $8)
+         on conflict (arende_id, id) do nothing`,
+        [p.id, arendeId, p.tidpunkt, p.anvandare, p.handelse, p.klientdigest ?? null, sekvens + 1, nastaH],
+      );
+      // En dubblett skrivs inte och får därför inte heller flytta kedjan:
+      // länken ovan förbrukas bara när raden faktiskt sattes in.
+      if (r.rowCount > 0) {
+        sekvens += 1;
+        h = nastaH;
+      }
+    }
+
+    // Avslut förseglar kedjan: roten och en HMAC med nyckeln som aldrig
+    // finns i databasen. Skrivs i samma transaktion som avslutshändelsen —
+    // ett avslut utan försegling ska inte kunna uppstå av en krasch
+    // mittemellan.
+    if (poster.some((p) => p.handelse?.typ === "arende_avslutat")) {
+      const nu = new Date().toISOString();
+      if (FORSEGLING_NYCKEL) {
+        await db.query(
+          `update felsokning_arenden set kedjerot = $2, forsegling = $3, forseglad = $4
+           where id = $1 and forsegling is null`,
+          [arendeId, h, forsegla(FORSEGLING_NYCKEL, arendeId, h, nu), nu],
+        );
+      } else {
+        logga("varning", "avslut utan försegling", {
+          arende: arendeId,
+          konsekvens: "Kedjan är skriven men roten är inte förseglad. Sätt FORSEGLING_NYCKEL.",
+        });
+      }
+    }
+
+    await db.query("commit");
+    return { rot: h };
+  } catch (fel) {
+    await db.query("rollback").catch(() => {});
+    throw fel;
+  } finally {
+    db.release();
+  }
+}
+
 async function grindHinder(pool, arendeId, nya, sprak = STANDARD) {
   const rader = await pool.query(
     `select h.handelse, a.metodik_id from felsokning_handelser h
@@ -1288,11 +1380,16 @@ export function skapaServer() {
           kanal: "Delningslänk",
           ...(kommentar?.trim() ? { kommentar: kommentar.trim() } : {}),
         };
-        await pool.query(
+        // Kedjat som allt annat — kundens besked är den händelse som
-          `insert into felsokning_handelser (id, arende_id, tidpunkt, anvandare, handelse)
+        // oftast åberopas i en tvist, och just den fick inte stå utanför.
-           values ($1, $2, now(), $3, $4)`,
+        await skrivKedjat(arendeId, [
-          [`kb-${nyKod()}`, arendeId, "Kund via delningslänk", handelse],
+          {
-        );
+            id: `kb-${nyKod()}`,
+            tidpunkt: new Date().toISOString(),
+            anvandare: "Kund via delningslänk",
+            handelse,
+          },
+        ]);
         return svara(res, 200, { ok: true });
       }
 
@@ -2283,26 +2380,22 @@ export function skapaServer() {
           poster.push(post);
         }
 
-        const klientDb = await pool.connect();
         let skrivna = 0;
         let dubbletter = 0;
-        try {
+        {
-          await klientDb.query("begin");
+          // Kedjat via samma väg som allt annat. Räkningen görs mot
-          for (const post of poster) {
+          // loggen efteråt — skrivKedjat äger transaktionen.
-            const r = await klientDb.query(
+          const fore = await pool.query(
-              `insert into felsokning_handelser (id, arende_id, tidpunkt, anvandare, handelse)
+            `select count(*)::int as n from felsokning_handelser where arende_id = $1`,
-               values ($1, $2, $3, $4, $5) on conflict (arende_id, id) do nothing`,
+            [protokollVag[1]],
-              [post.id, protokollVag[1], post.tidpunkt, post.anvandare, post.handelse],
           );
-            if (r.rowCount === 0) dubbletter += 1;
+          await skrivKedjat(protokollVag[1], poster);
-            else skrivna += 1;
+          const efter = await pool.query(
-          }
+            `select count(*)::int as n from felsokning_handelser where arende_id = $1`,
-          await klientDb.query("commit");
+            [protokollVag[1]],
-        } catch (fel) {
+          );
-          await klientDb.query("rollback");
+          skrivna = efter.rows[0].n - fore.rows[0].n;
-          throw fel;
+          dubbletter = poster.length - skrivna;
-        } finally {
-          klientDb.release();
         }
 
         // Delvis lyckad inläsning är inte 200. Mottagaren ska behöva
@@ -2437,6 +2530,85 @@ export function skapaServer() {
         return svara(res, 200, { ok: true });
       }
 
+      // ---- Kedjeverifiering (ALVA-SPEC-070) ---------------------------
+      //
+      // Räknar om varje länk ur det som faktiskt står i databasen och
+      // jämför med de lagrade. Svaret pekar ut FÖRSTA brottet — allt
+      // efter det är följdfel.
+      //
+      // Digesten räknas ur den lagrade händelsen, så en ändrad rad
+      // upptäcks även om kolumnen kedjehash lämnats orörd. Det är hela
+      // skillnaden mot att lita på triggern: verifieringen frågar inte
+      // databasen om den är ärlig, den räknar.
+      const kedjeVag = vag.match(/^\/api\/arenden\/([A-Za-z0-9_-]+)\/kedja$/);
+      if (req.method === "GET" && kedjeVag) {
+        if (!(await arendeIOrg(kedjeVag[1], anspr.org))) {
+          return svara(res, 404, { error: "Ärendet är inte tillgängligt." });
+        }
+        const rader = await pool.query(
+          `select id, tidpunkt, anvandare, handelse, sekvens, kedjehash
+           from felsokning_handelser where arende_id = $1
+           order by sekvens nulls first, tidpunkt, id`,
+          [kedjeVag[1]],
+        );
+        const kedja = verifieraKedja(
+          kedjeVag[1],
+          rader.rows
+            .filter((r) => r.sekvens != null)
+            .map((r) => ({
+              id: r.id,
+              tidpunkt: new Date(r.tidpunkt).toISOString(),
+              anvandare: r.anvandare,
+              digest: innehallsHash(kanoniskt(r.handelse)),
+              kedjehash: r.kedjehash,
+            })),
+        );
+        const okedjade = rader.rows.filter((r) => r.sekvens == null).length;
+
+        // Förseglingen prövas mot den OMRÄKNADE roten, inte den lagrade:
+        // en angripare som räknat om kedjan och roten stoppas av att
+        // HMAC:en inte går att räkna om utan nyckeln.
+        const arende = await pool.query(
+          `select kedjerot, forsegling, forseglad from felsokning_arenden where id = $1`,
+          [kedjeVag[1]],
+        );
+        const a = arende.rows[0] ?? {};
+        let forsegling = "saknas";
+        if (a.forsegling) {
+          if (!FORSEGLING_NYCKEL) forsegling = "kan inte prövas — FORSEGLING_NYCKEL saknas";
+          else if (
+            kedja.ok &&
+            a.kedjerot === kedja.rot &&
+            provaForsegling(
+              FORSEGLING_NYCKEL,
+              kedjeVag[1],
+              a.kedjerot,
+              new Date(a.forseglad).toISOString(),
+              a.forsegling,
+            )
+          ) {
+            forsegling = "giltig";
+          } else {
+            forsegling = "OGILTIG";
+          }
+        }
+
+        // Vad svaret bevisar och inte: innehållet är oförändrat sedan
+        // mottagandet. Ingenting om tiden före serverns klocka, ingenting
+        // om sanningshalten. Texten står i svaret så att den följer med
+        // in i varje rapport som citerar det.
+        return svara(res, 200, {
+          ok: kedja.ok,
+          rot: kedja.rot,
+          brott: kedja.brott ?? null,
+          kedjade: rader.rows.length - okedjade,
+          okedjade,
+          forsegling,
+          bevisar:
+            "Content unchanged since receipt, in the recorded order. Nothing about the time before receipt, nothing about accuracy.",
+        });
+      }
+
       const handelserVag = vag.match(/^\/api\/arenden\/([A-Za-z0-9_-]+)\/handelser$/);
       if (handelserVag) {
         // Organisationsgränsen: ärendet måste tillhöra användarens org.
@@ -2575,16 +2747,10 @@ export function skapaServer() {
             });
           }
 
-          for (const p of attSkriva) {
+          // Append-only och kedjat: dubbletter skrivs inte över, triggern
-            // Append-only: on conflict do nothing — en befintlig händelse
+          // stoppar allt annat, och varje insatt händelse får sin länk.
-            // skrivs aldrig över, och databastriggern stoppar allt annat.
+          // Kollisionen är redan bedömd ofarlig ovan.
-            // Här är kollisionen redan bedömd ofarlig ovan.
+          await skrivKedjat(handelserVag[1], attSkriva);
-            await pool.query(
-              `insert into felsokning_handelser (id, arende_id, tidpunkt, anvandare, handelse, klientdigest)
-               values ($1, $2, $3, $4, $5, $6) on conflict (arende_id, id) do nothing`,
-              [p.id, handelserVag[1], p.tidpunkt, p.anvandare, p.handelse, p.klientdigest],
-            );
-          }
           // Utgående integrationer underrättas efter att loggen skrivits,
           // aldrig före: en mottagare ska aldrig kunna se en händelse som
           // inte finns i loggen.