diff --git a/FASSUNGEN.txt b/FASSUNGEN.txt
index 55b3fc1..331864d 100644
--- a/FASSUNGEN.txt
+++ b/FASSUNGEN.txt
@@ -21,6 +21,96 @@
 
 
 ════════════════════════════════════════════════════════════════════════════════
+ Fassung vom 22. August 2026,
+ zuletzt geändert durch die am 22. August 2026 vorgenommenen Änderungen
+════════════════════════════════════════════════════════════════════════════════
+
+Zwei Mängel, die die vorangegangene Fassung aufgedeckt, aber nicht behoben hatte,
+wiegen schwerer als alles sonst Offene: Sie führen zu einem falschen Ergebnis,
+ohne es anzuzeigen. Ein Befehl gilt als angewandt, der Wortlaut des Zielgesetzes
+weicht gleichwohl von der amtlichen Nachfassung ab, und der Abschnitt „Manuell
+prüfen“ schweigt. Damit war das Leitprinzip des Erzeugnisses — niemals
+stillschweigend zu verwerfen — an dieser Stelle verfehlt.
+
+Bei ihrer Behebung hat sich ergeben, dass die beiden Mängel nicht nebeneinander
+standen, sondern eine Ursache teilten: die fehlende Einrückung. Sie ist im
+kanonischen Klartext nicht Schmuck, sondern trägt die Gliederung; wer sie
+verliert, verliert die Zugehörigkeit einer Zeile zu ihrer Einheit.
+
+
+Artikel 1
+Einrückung bei der Neufassung einer Aufzählungseinheit
+
+(1) Die Neufassung einer Nummer oder eines Buchstabens (BefehlAnwender.
+    wendeNeufassungAn) setzt den neuen Wortlaut fortan auf die Einrückung der
+    Einheit, an deren Stelle er tritt; bislang begann er in Spalte 0. Es gilt
+    damit dasselbe wie bei der Ersetzung einer solchen Einheit.
+
+(2) Der Grund ist folgender: Der Zeilenblock einer Aufzählungsmarke
+    (StellenAufloeser.zeilenBlock) reicht so weit, wie tiefer eingerückt wird.
+    Eine in Spalte 0 gesetzte Zeile nimmt daher den gesamten Rest des Absatzes
+    als ihre Kindzeilen an. Der nachfolgende Befehl „Nach Nr. 4 werden die
+    folgenden Nrn. 5 bis 7 eingefügt“ trat deshalb hinter die letzte Nummer des
+    Absatzes statt hinter die Nr. 4 — er galt als angewandt, stand aber falsch.
+
+(3) Die Neufassung eines Satzes oder Halbsatzes bleibt unberührt; ihr Bereich
+    beginnt mitten in der Zeile und trägt keine Einrückung.
+
+
+Artikel 2
+Heilung des Weißraums nach einer Streichung
+
+(1) Die Streichung von Wörtern (BefehlAnwender.wendeStreichungAn) heilte den
+    zurückbleibenden Weißraum bislang über den gesamten Zieltext; dieser ist bei
+    einer Stelle ohne Fein-Komponente der ganze Absatz. Sie fraß dabei die
+    Einrückung der Aufzählungszeilen: Aus den zwei Leerzeichen vor jeder Marke
+    wurde eines.
+
+(2) Geheilt wird fortan allein die Naht der Streichung (heileNaht): Aus zwei
+    Leerzeichen wird eines, vor einem Satzzeichen bleibt keines. Traf die
+    Streichung den Zeilenanfang, so ist der Weißraum vor der Naht Einrückung und
+    bleibt unangetastet.
+
+
+Artikel 3
+Weichen des leeren Platzhalters
+
+Vergibt ein eingefügter Block eine Bezeichnung, die ein leerer Platzhalter der
+Altfassung noch hält („7. (aufgehoben)“), so weicht dieser. Es ist dieselbe
+Regel, die schon bei der Umnummerierung auf eine weggefallene Bezeichnung gilt,
+und so zeigt es auch die amtliche Nachfassung. Verdrängt wird dabei nur ein
+Platzhalter, niemals ein Wortlaut; ein Platzhalter, den kein Befehl anrührt,
+bleibt stehen.
+
+
+Artikel 4
+Zwischenraum hinter der Aufzählungsmarke
+
+Im Satz des Gesetzblatts steht zwischen der Marke einer Aufzählungszeile und
+ihrem Text die Tabulatorspalte des Setzers. Der kanonische Klartext kennt dort
+ein einzelnes Leerzeichen. Die Aufbereitung eines Zitats (normalisiereZitatText)
+führt den Zwischenraum künftig auf dieses zurück; andernfalls trügen gerade die
+neu gesetzten Zeilen ein anderes Satzbild als die unberührten.
+
+
+Artikel 5
+Nachweis
+
+(1) Der Akzeptanztest des BayJG (EndToEndTest.bayJgGvblAcceptance) hielt die
+    beiden Mängel bislang ausdrücklich fest. Die betreffenden Zusicherungen
+    werden umgekehrt: Der eingefügte Block steht zwischen der Nr. 4 und der
+    Nr. 8, der Platzhalter ist gewichen, die Einrückung besteht fort.
+
+(2) Art. 56 Abs. 1 des Bayerischen Jagdgesetzes gleicht damit in Aufbau und
+    Wortlaut der amtlichen Nachfassung (BayJG.pdf); die Gegenprobe ist Zeile für
+    Zeile geführt worden.
+
+(3) Hinzu treten drei Prüfungen der zugrunde liegenden Regeln
+    (BefehlAnwenderTest). Der Gesamtbestand beträgt nunmehr 315 Prüfungen; keine
+    der gepinnten Zahlen der übrigen Belegfälle hat sich geändert.
+
+
+════════════════════════════════════════════════════════════════════════════════
  Fassung vom 16. August 2026,
  zuletzt geändert durch die am 16. August 2026 vorgenommenen Änderungen
 ════════════════════════════════════════════════════════════════════════════════
diff --git a/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java b/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java
index 32350ff..73745a6 100644
--- a/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java
+++ b/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java
@@ -716,10 +716,11 @@
                 return TextErgebnis.fehler(
                     "„" + befehl.woerter() + "“ kommt " + anzahl + "-mal vor.");
               }
+              int naht = text.indexOf(befehl.woerter());
               return TextErgebnis.ok(
-                  text.replace(befehl.woerter(), "")
-                      .replaceAll("  +", " ")
-                      .replaceAll(" ([,;.])", "$1"));
+                  heileNaht(
+                      text.substring(0, naht) + text.substring(naht + befehl.woerter().length()),
+                      naht));
             }));
   }
 
@@ -833,7 +834,27 @@
       return angewandt(befehl, norm.enbez());
     }
 
-    // Neufassung eines Satzes / einer Nummer / eines Buchstabens: Bereich ersetzen.
+    // Neufassung einer Nummer / eines Buchstabens: Der neue Wortlaut tritt an die Stelle der
+    // alten Einheit — und zwar auf deren Einrückung. Ohne sie stünde die neugefasste Zeile in
+    // Spalte 0, und der Zeilenblock ihrer Marke reichte fortan bis ans Absatzende, weil er so
+    // weit reicht, wie tiefer eingerückt wird (StellenAufloeser.zeilenBlock): ein späterer
+    // Befehl „Nach Nr. 4 werden die folgenden Nrn. 5 bis 7 eingefügt“ träte dann hinter die
+    // letzte Nummer des Absatzes statt hinter die Nr. 4.
+    if (feinsteIstAufzaehlung(befehl.stelle())) {
+      return bearbeiteBereich(
+          normen,
+          befehl,
+          (text, bereich) ->
+              TextErgebnis.ok(
+                  text.substring(0, bereich.von())
+                      + rueckeZitatEin(
+                          normalisiereZitatText(befehl.neuerText()),
+                          einrueckungVon(text, bereich.von()))
+                      + text.substring(bereich.bis())));
+    }
+
+    // Neufassung eines Satzes / Halbsatzes: Bereich ersetzen. Eine Einrückung gibt es hier
+    // nicht — der Bereich beginnt mitten in der Zeile.
     return bearbeiteText(
         normen, befehl, text -> TextErgebnis.ok(normalisiereZitatText(befehl.neuerText())));
   }
@@ -1105,10 +1126,19 @@
                 // Der Einfügeblock darf mehrere Einheiten enthalten („die Nummern 4a bis 4c“);
                 // jede Aufzählungszeile des Zitats bleibt eine eigene Zeile.
                 var block = rueckeZitatEin(normalisiereZitatText(befehl.text()), einrueckung);
-                return TextErgebnis.ok(
+                var neuerText =
                     befehl.vorher()
                         ? text.substring(0, position) + block + "\n" + text.substring(position)
-                        : text.substring(0, position) + "\n" + block + text.substring(position));
+                        : text.substring(0, position) + "\n" + block + text.substring(position);
+                // Vergibt der Block eine Bezeichnung, die ein leerer Platzhalter der Altfassung
+                // noch hält („7. (aufgehoben)“), so weicht dieser: Zwei Einheiten gleicher
+                // Bezeichnung kann es nicht geben, und Inhalt geht dabei nicht verloren. Es ist
+                // dieselbe Regel, die schon bei der Umnummerierung auf eine weggefallene
+                // Bezeichnung gilt, und so zeigt es die amtliche Nachfassung.
+                for (var marke : platzhalterMarken(block, befehl.ebene())) {
+                  neuerText = entferneWeggefallenenPlatzhalter(neuerText, marke);
+                }
+                return TextErgebnis.ok(neuerText);
               });
     };
   }
@@ -1421,6 +1451,36 @@
     };
   }
 
+  private static final Pattern LEERER_PLATZHALTER =
+      Pattern.compile("\\((?:weggefallen|gegenstandslos|aufgehoben)\\)");
+
+  /**
+   * Die Aufzählungsmarken, die ein eingefügter Block vergibt („5.“, „6.“, „7.“) — ohne solche, die
+   * er selbst als leeren Platzhalter führt, denn ein Platzhalter verdrängt keinen Platzhalter.
+   */
+  private static List<String> platzhalterMarken(String block, Ebene ebene) {
+    var muster =
+        switch (ebene) {
+          case NUMMER -> NUMMER_MARKER;
+          case BUCHSTABE -> BUCHSTABE_MARKER;
+          default -> null;
+        };
+    if (muster == null) {
+      return List.of();
+    }
+    var marken = new ArrayList<String>();
+    var marker = muster.matcher(block);
+    while (marker.find()) {
+      int zeilenEnde = block.indexOf('\n', marker.end());
+      var rest = block.substring(marker.end(), zeilenEnde < 0 ? block.length() : zeilenEnde);
+      if (LEERER_PLATZHALTER.matcher(rest.strip()).matches()) {
+        continue;
+      }
+      marken.add(marker.group(1) + (ebene == Ebene.BUCHSTABE ? ")" : "."));
+    }
+    return marken;
+  }
+
   /**
    * Entfernt die weggefallene Aufzählungszeile mit der gegebenen Marke — die soeben umbenannte
    * Zeile bleibt stehen, weil nur ein leerer Platzhalter getroffen wird.
@@ -1812,6 +1872,50 @@
                     || k instanceof Stelle.BuchstabeNr);
   }
 
+  /**
+   * Wahr, wenn die feinste Komponente der Stelle eine Aufzählungseinheit ist (Nummer/Buchstabe).
+   */
+  private static boolean feinsteIstAufzaehlung(Stelle stelle) {
+    var komponenten = stelle.komponenten();
+    if (komponenten.isEmpty()) {
+      return false;
+    }
+    var feinste = komponenten.get(komponenten.size() - 1);
+    return feinste instanceof Stelle.NummerNr || feinste instanceof Stelle.BuchstabeNr;
+  }
+
+  /**
+   * Heilt den Weißraum an der Stelle, an der eine Streichung Text herausgenommen hat: Aus zwei
+   * Leerzeichen wird eines, vor einem Satzzeichen bleibt keines. Geheilt wird ausdrücklich nur die
+   * Naht und nicht der ganze Zieltext — dieser ist bei einer Stelle ohne Fein-Komponente der
+   * gesamte Absatz, und eine Heilung über ihn hinweg fräße die Einrückung der Aufzählungszeilen:
+   * Aus den zwei Leerzeichen vor jeder Marke würde eines. Traf die Streichung den Zeilenanfang, so
+   * ist der Weißraum vor der Naht Einrückung und bleibt unangetastet.
+   */
+  private static String heileNaht(String text, int naht) {
+    int von = naht;
+    while (von > 0 && text.charAt(von - 1) == ' ') {
+      von--;
+    }
+    int bis = naht;
+    while (bis < text.length() && text.charAt(bis) == ' ') {
+      bis++;
+    }
+    if (bis == von) {
+      return text;
+    }
+    if (von == 0 || text.charAt(von - 1) == '\n') {
+      return text.substring(0, naht) + text.substring(bis);
+    }
+    if (bis < text.length() && ",;.".indexOf(text.charAt(bis)) >= 0) {
+      return text.substring(0, von) + text.substring(bis);
+    }
+    if (bis - von == 1) {
+      return text;
+    }
+    return text.substring(0, von) + " " + text.substring(bis);
+  }
+
   private static @Nullable String labelVon(Stelle stelle) {
     for (var komponente : stelle.komponenten().reversed()) {
       if (komponente instanceof Stelle.NummerNr n) {
@@ -1969,6 +2073,11 @@
   private static final Pattern AUFZAEHLUNGSZEILE =
       Pattern.compile("^(\\d+[a-z]?\\.|[a-z]{1,3}\\))\\s.*");
 
+  // Der Zwischenraum zwischen der Aufzählungsmarke und ihrem Text: im Gesetzblattsatz steht dort
+  // die Marken-Tabulatorspalte, im kanonischen Klartext ein einzelnes Leerzeichen.
+  private static final Pattern MARKEN_ZWISCHENRAUM =
+      Pattern.compile("^(\\d+[a-z]?\\.|[a-z]{1,3}\\))[ \\t]+");
+
   private static String normalisiereZitatText(String text) {
     var zeilen = text.split("\n");
     var sb = new StringBuilder();
@@ -1978,7 +2087,7 @@
     // Stellenauflösung sie als Kindzeilen der Einheit erkennt.
     var fortsetzungsEinzug = "";
     for (var zeile : zeilen) {
-      var gestutzt = zeile.strip();
+      var gestutzt = MARKEN_ZWISCHENRAUM.matcher(zeile.strip()).replaceFirst("$1 ");
       if (gestutzt.isEmpty()) {
         continue;
       }
diff --git a/src/main/resources/sampledata/Landesrecht-Beispiele.adoc b/src/main/resources/sampledata/Landesrecht-Beispiele.adoc
index 4de907f..d0242fc 100644
--- a/src/main/resources/sampledata/Landesrecht-Beispiele.adoc
+++ b/src/main/resources/sampledata/Landesrecht-Beispiele.adoc
@@ -232,16 +232,18 @@
   angefasst — ein Sammelheft mit mehreren Verkündungen, also zugleich ein Test der Artikel-/
   Verkündungsauswahl.
 . *Berlin, ganzseitenbreite Rahmen* (XY-Cut) — die letzte offene Layout-Frage, siehe „Noch offen“.
-. *Stellung eines eingefügten Blocks* — seit die Umnummerierungs-Kaskade des BayJG aufgeht, ist
-  dies der sichtbare Rest an Art. 56: „Nach Nr. 4 werden die folgenden Nrn. 5 bis 7 eingefügt“ gilt
-  als angewandt, der Block tritt aber ans Ende des Absatzes statt hinter die Nr. 4, und der leere
-  Platzhalter „7. (aufgehoben)“ bleibt zwischen den Nrn. 9 und 10 stehen. Beides ist im
-  Akzeptanztest festgehalten, damit es nicht unbemerkt bleibt.
+
+*Erledigt:* Die _Stellung eines eingefügten Blocks_ war der letzte sichtbare Rest an Art. 56 des
+BayJG. Ursache war nicht die Einfügung selbst, sondern die Neufassung der Nr. 4 einen Punkt zuvor:
+Sie setzte ihren Wortlaut ohne Einrückung, worauf der Zeilenblock dieser Marke bis ans Absatzende
+reichte — er reicht so weit, wie tiefer eingerückt wird. Art. 56 Abs. 1 gleicht seither in Aufbau
+und Wortlaut der amtlichen Nachfassung; der Akzeptanztest prüft das.
 
 Regressionsschutz: `./mvnw verify` prüft die bestehenden Belegfälle mit. Gepinnt ist dabei nicht
 überall dieselbe Art von Zahl — für UWG, AGG und ProdHaftG, dass *kein* Befehl manuell bleibt; für
 das BayJG die 154 erkannten Befehle, die vollständige Anwendung und den Wortlaut des
-Bußgeldkatalogs an drei Stellen; für Sachsen,
+Bußgeldkatalogs — dort auch Aufbau und Einrückung, weil an ihnen die Stellung eingefügter Blöcke
+hängt; für Sachsen,
 Niedersachsen und die vier NRW-Artikel die vollständige Anwendung bis auf das eine benannte
 Residuum im WDR-Gesetz; für Schleswig-Holstein, Berlin und Hessen die vollständige *Erkennung*
 (dort 21 Befehle). Wer eine dieser Zahlen
diff --git a/src/test/java/eu/mulk/aendggner/EndToEndTest.java b/src/test/java/eu/mulk/aendggner/EndToEndTest.java
index 865afe6..fe0ab21 100644
--- a/src/test/java/eu/mulk/aendggner/EndToEndTest.java
+++ b/src/test/java/eu/mulk/aendggner/EndToEndTest.java
@@ -271,8 +271,9 @@
     //        vorrücken, ihre Begleitänderungen aber an ihrer Dokumentstelle bleiben — die Wortfolge
     //        „schriftliche“ etwa steht erst nach dem vorangehenden Punkt nur noch einmal im
     //        Artikel und ist damit eindeutig.
-    //    „Kein Rest“ heißt: jeder Befehl hat gegriffen. Es heißt nicht, dass die Norm in allem der
-    //    amtlichen Nachfassung gleicht — was daran noch fehlt, steht weiter unten an Art. 56.
+    //    „Kein Rest“ heißt zunächst nur: jeder Befehl hat gegriffen. Dass Art. 56 Abs. 1 darüber
+    //    hinaus in Aufbau und Wortlaut der amtlichen Nachfassung gleicht, prüfen die
+    //    Zusicherungen weiter unten.
     var anwendung = BefehlAnwender.anwenden(gesetz, parseErgebnis.befehle());
     assertThat(anwendung.protokoll()).hasSameSizeAs(parseErgebnis.befehle());
     var manuellPfade =
@@ -298,16 +299,24 @@
     // Abs. 2 Nr. 12 Buchst. b führt ihre Marke allein auf der Zeile — sie ist trotzdem auflösbar.
     assertThat(art56.absaetze().get(1).text()).contains("(§ 2 Abs. 3 BJagdG)");
 
-    // Offen bleibt an dieser Norm eine Frage, die mit der Reihenfolge nichts zu tun hat und schon
-    // vorher so stand: Der eingefügte Block „Nach Nr. 4 werden die folgenden Nrn. 5 bis 7
-    // eingefügt“ landet am Ende des Absatzes statt hinter der Nr. 4, und der leere Platzhalter
-    // „7. (aufgehoben)“ der Altfassung bleibt zwischen den Nrn. 9 und 10 stehen. Beides ist hier
-    // festgehalten, damit es nicht unbemerkt bleibt — der Befehl gilt als angewandt, die Stellung
-    // seines Blocks ist aber falsch.
-    assertThat(katalog).contains("7. (aufgehoben)");
-    assertThat(katalog.indexOf("5.\t den Verboten des Art. 29 Abs. 2"))
-        .as("die eingefügten Nrn. 5 bis 7 stehen (noch) hinter der Nr. 16")
-        .isGreaterThan(katalog.indexOf("16."));
+    // Der Block aus „Nach Nr. 4 werden die folgenden Nrn. 5 bis 7 eingefügt“ steht an seinem Platz
+    // — zwischen der Nr. 4 und der Nr. 8 — und nicht mehr am Ende des Absatzes. Dass er dort
+    // landete, lag an der Neufassung der Nr. 4 einen Punkt zuvor: Sie setzte ihren Wortlaut ohne
+    // Einrückung, worauf der Zeilenblock der Nr. 4 bis ans Absatzende reichte (er reicht so weit,
+    // wie tiefer eingerückt wird).
+    assertThat(katalog.indexOf("  5. den Verboten des Art. 29 Abs. 2"))
+        .as("die eingefügten Nrn. 5 bis 7 stehen zwischen der Nr. 4 und der Nr. 8")
+        .isGreaterThan(katalog.indexOf("  4. entgegen Art. 29 Abs. 1"))
+        .isLessThan(katalog.indexOf("  8. entgegen Art. 31 Abs. 2"));
+    // Der leere Platzhalter „7. (aufgehoben)“ der Altfassung weicht dem eingefügten Block, weil
+    // dieser dieselbe Bezeichnung vergibt — dieselbe Regel wie bei der Umnummerierung auf eine
+    // weggefallene Bezeichnung. Verdrängt wird dabei nur ein Platzhalter, nie ein Wortlaut: Der
+    // Platzhalter „1. (aufgehoben)“ des Abs. 2, den kein Befehl anrührt, bleibt unberührt stehen.
+    assertThat(katalog).doesNotContain("(aufgehoben)");
+    assertThat(art56.absaetze().get(1).text()).contains("1. (aufgehoben)");
+    // Die Einrückung der Aufzählungszeilen übersteht die Streichungen des Hefts: Sie wird nicht
+    // mehr von der Leerzeichen-Heilung mitgenommen, die nur noch die Naht der Streichung glättet.
+    assertThat(katalog).contains("\n  12. ohne Begleitung").doesNotContain("\n 12. ");
 
     // Art. 29a Abs. 5 trägt nach der Kaskade die neue Behördenbezeichnung und den eingefügten Satz.
     var art29a = anwendung.neu().norm("Art. 29a").orElseThrow();
diff --git a/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java b/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
index 7e7da85..212a037 100644
--- a/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
+++ b/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
@@ -1192,6 +1192,102 @@
         .isEqualTo("Zweck dieses Gesetzes ist die Erprobung, auch in Teilen,.");
   }
 
+  /**
+   * Ein Katalog, wie ihn das Stammgesetz führt: Aufzählungszeilen auf zwei Leerzeichen, darunter
+   * ein weggefallener Platzhalter.
+   */
+  private static Gesetz katalog() {
+    return new Gesetz(
+        "TestG",
+        "Gesetz zur Erprobung",
+        "Testgesetz",
+        List.of(
+            new Norm(
+                "§ 1",
+                "Zweck",
+                null,
+                List.of(
+                    new Absatz(
+                        "1",
+                        "Erprobt wird, wer\n"
+                            + "  1. Befehle erkennt,\n"
+                            + "  2. Befehle schriftlich anwendet,\n"
+                            + "  3. (weggefallen)\n"
+                            + "  4. Ergebnisse prüft.")),
+                false)),
+        List.of());
+  }
+
+  /**
+   * Die Neufassung einer Nummer setzt ihren Wortlaut auf die Einrückung der alten Einheit. Ohne sie
+   * stünde die Zeile in Spalte 0 und der Zeilenblock ihrer Marke reichte bis ans Absatzende — ein
+   * nachfolgender Einfügebefehl träte dann an die falsche Stelle.
+   */
+  @Test
+  void neufassungEinerNummerBehaeltDieEinrueckung() {
+    var befehl =
+        new Neufassung(
+            stelle(new Stelle.Paragraph("1"), new Stelle.AbsatzNr("1"), new Stelle.NummerNr("2")),
+            "2. Befehle anwendet,",
+            PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(katalog(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(absatzText(ergebnis.neu(), "§ 1", 0))
+        .contains("\n  2. Befehle anwendet,\n")
+        .doesNotContain("\n2. ");
+  }
+
+  /**
+   * Die Heilung des Weißraums nach einer Streichung glättet die Naht und sonst nichts: Die
+   * Einrückung der Aufzählungszeilen bleibt, wie sie war.
+   */
+  @Test
+  void streichungLaesstDieEinrueckungUnberuehrt() {
+    var befehl =
+        new Streichung(
+            stelle(new Stelle.Paragraph("1"), new Stelle.AbsatzNr("1")), "schriftlich ", PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(katalog(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(absatzText(ergebnis.neu(), "§ 1", 0))
+        .isEqualTo(
+            "Erprobt wird, wer\n"
+                + "  1. Befehle erkennt,\n"
+                + "  2. Befehle anwendet,\n"
+                + "  3. (weggefallen)\n"
+                + "  4. Ergebnisse prüft.");
+  }
+
+  /**
+   * Vergibt ein eingefügter Block eine Bezeichnung, die ein leerer Platzhalter noch hält, so weicht
+   * dieser — dieselbe Regel wie bei der Umnummerierung auf eine weggefallene Bezeichnung.
+   */
+  @Test
+  void eingefuegterBlockVerdraengtDenWeggefallenenPlatzhalter() {
+    var befehl =
+        new StrukturEinfuegung(
+            stelle(new Stelle.Paragraph("1"), new Stelle.AbsatzNr("1"), new Stelle.NummerNr("2")),
+            false,
+            Ebene.NUMMER,
+            "3",
+            "3. Befehle ordnet,",
+            PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(katalog(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(absatzText(ergebnis.neu(), "§ 1", 0))
+        .isEqualTo(
+            "Erprobt wird, wer\n"
+                + "  1. Befehle erkennt,\n"
+                + "  2. Befehle schriftlich anwendet,\n"
+                + "  3. Befehle ordnet,\n"
+                + "  4. Ergebnisse prüft.");
+  }
+
   private static String absatzText(Gesetz gesetz, String enbez, int index) {
     return gesetz.norm(enbez).orElseThrow().absaetze().get(index).text();
   }