task-pipeline-skill 1.99.0 → 1.99.1

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+## v1.99.1 (2026-10-21)
+
+Guards: 530 → **530**; property checks 15 → **15**. No negative was added: the new cases
+are regression tests in `test/audit_regressions/diet_retro_budget.py`.
+
+**`retro_budget.py` reads an older retro's floor and migrates it** (B-149, from sshlg-skills
+B-244). That retro writes its standing instructions as a numbered list and its run stamps as
+`- **date: title** ...` narrative items beside a table. `check` printed `standing 0/10 rows`
+for ten instructions, and `migrate` answered `nothing to move` on a 103,737-byte floor with 89
+stamps, so stage 10's byte budget could never pass there.
+
+- `check` counts numbered-list standing instructions and list stamps, measures each item
+  whole and names it (`standing row #6`, `stamp 2026-09-06 (list)`).
+- `migrate` rotates the oldest stamps past the cap of ten, ordered by their date and never by
+  position, verbatim into the quarter's archive (a table row travels under its table's
+  header); keeps a long list item's bold rule and its `*(Retire ...)*` trigger and moves the
+  rest; keeps a long list stamp's bold title; and, only over budget, moves the Run stamps
+  section's loose prune paragraphs. Every move leaves a `sha256:` pointer that `verify` proves.
+- Edge rules from two review rounds: a lead of several bold spans stays whole and a date-only
+  lead refuses by name; a same-day tie follows its own block's direction; a paragraph holding
+  a heading stays in the floor; the script's own pointer notes never move again, so a floor
+  still over budget is left alone by the next run; a table's header leaves only with the rows
+  this run rotated; a list marker, a quote, a rule or a `*(` note ends an item; a rule still
+  over 600 characters after its story moved is reported, never moved again.
+- On a copy of the sshlg-skills retro: 103,737 bytes to 6,446, every pointer proved, no
+  non-blank line lost, the text outside the floor unchanged.
+- Tests: `test/audit_regressions/diet_retro_budget.py` gains seventeen cases. Each failed on the
+  1.99.0 script (it crashed with no archive to read) or on a reviewed intermediate version.
+
 ## v1.99.0 (2026-10-21)
 
 Guards: 448 → **530**; property checks 15 → **15**. There are 82 new negatives in

package/SKILL-CARD.md

@@ -12,7 +12,7 @@ harmless.
 |---|---|
 | **Purpose** | Runs a substantial task through ten gated delivery stages — intake grill, docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs+registers, acceptance — refusing to advance until each gate passes |
 | **Owner** | ssheleg ([github.com/ssheleg/task-pipeline](https://github.com/ssheleg/task-pipeline)) |
-| **Version** | 1.99.0 |
+| **Version** | 1.99.1 |
 | **Surface** | Claude Code (filesystem skill + plugin) and the vercel `skills` CLI. **Not** uploaded to the Skills API; custom Skills do not sync across surfaces |
 | **Dependencies** | None required. Optional: `context7` (MCP), `figma` (MCP), super-ux, agent-sync, graphify, obsidian-wiki, and **one of two browser channels** — `playwright` (CLI or MCP) or `chrome-devtools` (MCP); either satisfies the browser step and neither is required. The engine is WebKit (Safari) first; `chrome-devtools` is Chrome-only, a stated exception. Every stage's doctrine ships in-repo; user-facing stage 3 requires a valid scenario artifact; super-ux is preferred, with equivalent-provider and inline-fallback paths under the provider contract |
 | **Evaluation status** | Suite authored, 5 categories. One recorded run, **self-observed by the author**; **zero blind runs on zero of three models** — the split, and the numbers, live in [`evals/RESULTS.md`](evals/RESULTS.md) and are computed by `evals/run.py` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.99.0",
+  "version": "1.99.1",
   "description": "Full-cycle delivery pipeline for coding agents: a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine ships inside the skill — no companion plugin required. This package is the installer CLI.",
   "bin": {
     "task-pipeline": "bin/task-pipeline.js"

package/plugins/task-pipeline/.claude-plugin/plugin.json

@@ -3,7 +3,7 @@
   "name": "task-pipeline",
   "displayName": "Task Pipeline",
   "description": "Runs a substantial task through a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine is built into the skill — no companion plugin required — with typed auto/judgment/manual gates, a frozen requirement spine that closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a proportional short path for small changes, a loop guard whose ceilings stop and record a blocker, and stage-3 tracks for what a product does, how it sounds and how it looks. Two modes need no task: `checkup` (what is unverified) and `setup` (audit existing docs); a third, `waves`, takes the whole board and closes it in waves that each finish in one pass. Retro insights can publish upstream as issues, opt-in and redacted.",
-  "version": "1.99.0",
+  "version": "1.99.1",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/skills/task-pipeline/references/retrospective.md

@@ -205,6 +205,10 @@ narrative are how a capped list grows anyway.
   `Because`) **verbatim** into the quarter's archive, each block carrying the sha256 of
   its text, and leaves a pointer; `retro_budget.py verify` proves every pointer. An
   instruction still over 600 characters after its story moved is rewritten by hand.
+  An older retro whose standing instructions are a numbered list and whose stamps are
+  `- **date: title**` items is read the same way: the item keeps its bold rule and its
+  `*(Retire ...)*` trigger, a stamp keeps its title, stamps past the cap rotate out by date,
+  and, over budget, the Run stamps section's loose prune paragraphs move.
 - **A prune that retires nothing writes its count into the stamp row**, as
   `prune: 0 retired`, and no paragraph. Repeated "nothing to prune" notes were a
   measured share of the floor.

package/plugins/task-pipeline/skills/task-pipeline/scripts/retro_budget.py

@@ -15,7 +15,9 @@ on 2026-10-20 across ~50 projects the floor ran from ~3k to ~76k tokens, one of
         moves narrative out of the floor VERBATIM into the archive, each block
         carrying the sha256 of the text it holds, and leaves a pointer in its place:
         a stamp row over the stamp limit keeps Date, Topic and Commit; a standing row
-        over the row limit loses its `Because` cell. Without --write it prints the
+        over the row limit loses its `Because` cell; a standing instruction written as
+        a numbered list item keeps its bold rule and its `*(Retire ...)*` trigger; the
+        oldest run stamps past the cap of ten rotate out whole. Without --write it prints the
         plan and writes nothing. Exit 0 when the floor is then within budget, 1 when a
         row is still over (an instruction too long to shorten by moving its story:
         rewrite it by hand), 2 could not measure.
@@ -95,41 +97,133 @@ def header_cols(lines, i):
     return len(cells(lines[k]))
 
 
+ITEM = re.compile(r"^(\d+)\.\s")
+BULLET = re.compile(r"^[-*]\s")
+DATE = re.compile(r"(\d{4}-\d{2}-\d{2})")
+
+
+def list_items(lines, span, marker=ITEM):
+    """(start, end) line spans of numbered list items inside a span, end exclusive.
+
+    An older retro writes its standing instructions as `N. **rule** ...` paragraphs, not
+    the template's table. An item runs until the next item, or the first non-indented,
+    non-blank line (a vacancy note, a heading's prose); trailing blank lines are not part
+    of it. Reading such a floor as zero rows was B-244 in sshlg-skills."""
+    out = []
+    start, end = span
+    i = start
+    while i < end:
+        if not marker.match(lines[i]):
+            i += 1
+            continue
+        j = i + 1
+        while j < end and not marker.match(lines[j]) and (
+                not lines[j].strip() or lines[j].startswith((" ", "\t"))
+                # a lazy continuation: unindented text directly under the item's last line,
+                # unless it opens something of its own (a list, a rule, a note, a table)
+                or (lines[j - 1].strip() and not lines[j].startswith(("|", "#", "*("))
+                    and not ITEM.match(lines[j]) and not BULLET.match(lines[j])
+                    and not re.match(r"^(?:[+]\s|>|\d+\)\s)", lines[j])
+                    and not re.match(r"^(?:-{3,}|\*{3,}|_{3,})\s*$", lines[j]))):
+            j += 1
+        k = j
+        while k > i + 1 and not lines[k - 1].strip():
+            k -= 1
+        out.append((i, k))
+        i = j
+    return out
+
+
+def stamp_date(lines, sp):
+    """The date a run stamp was written: a table row's Date cell, or the first date in a
+    list stamp's opening line. None when it has none (the stamp cannot be ordered)."""
+    if lines[sp[0]].startswith("|"):
+        c = cells(lines[sp[0]])
+        m = re.match(r"\s*(\d{4}-\d{2}-\d{2})", c[0]) if c else None
+    else:
+        m = DATE.search(lines[sp[0]])
+    return m.group(1) if m else None
+
+
+LEAD = re.compile(r"^(?:[-*]|\d+\.)\s+((?:\*\*.+?\*\*\s*)+)")
+ONLY_DATE = re.compile(r"^(?:\*\*\s*\(?\d{4}-\d{2}-\d{2}\)?\s*\*\*\s*)+$")
+RETIRE = re.compile(r"\*\((Retire.*?)\)\*")
+
+
+def lead_of(lines, sp):
+    """The item's leading bold spans, verbatim (`**(date)** **rule.**` keeps both), or None
+    when there are none or they hold only a date: the rule must survive in the floor."""
+    m = LEAD.match(" ".join(l.strip() for l in lines[sp[0]:sp[1]]))
+    if not m or ONLY_DATE.match(m.group(1).strip()):
+        return None
+    return m.group(1).strip()
+
+
+def loose_prose(lines, span, taken):
+    """Paragraphs of a section that are neither table lines nor list stamps: [(start, end)]."""
+    out, start, end = [], span[0] + 1, span[1]
+    i = start
+    while i < end:
+        if i in taken or not lines[i].strip() or lines[i].startswith("|"):
+            i += 1
+            continue
+        j = i
+        while j < end and j not in taken and lines[j].strip() and not lines[j].startswith("|"):
+            j += 1
+        # This script's own pointer notes are not prose: moving them again on the next
+        # run would make migrate rewrite an over-budget floor forever.
+        if not any(POINTER.search(l) for l in lines[i:j]):
+            out.append((i, j))
+        i = j
+    return out
+
+
 def measure(text, budget=BUDGET, row=ROW, stamp=STAMP):
     lines, spans = sections(text)
     floor = "\n".join(lines[spans[STANDING][0]:spans[STANDING][1]]) + "\n" + \
             "\n".join(lines[spans[STAMPS][0]:spans[STAMPS][1]])
     nbytes = len(floor.encode("utf-8"))
-    std = table_rows(lines, spans[STANDING])
-    stm = table_rows(lines, spans[STAMPS])
+    std = [(i, i + 1) for i in table_rows(lines, spans[STANDING])]
+    form = "table"
+    if not std:
+        std = list_items(lines, spans[STANDING])
+        form = "numbered list" if std else "table"
+    # A run stamp is a table row or, in an older retro, a `- **date — title** ...` item.
+    stm = [(i, i + 1) for i in table_rows(lines, spans[STAMPS])] + \
+        list_items(lines, spans[STAMPS], BULLET)
+    stm.sort()
+    width = lambda sp: len("\n".join(lines[sp[0]:sp[1]]))
     over = []
     if nbytes > budget:
         over.append("floor is %d bytes, over the budget of %d" % (nbytes, budget))
-    for i in std:
-        if len(lines[i]) > row:
-            over.append("standing row %s is %d chars, over %d"
-                        % ((cells(lines[i]) or ["?"])[0], len(lines[i]), row))
-    for i in stm:
-        if len(lines[i]) > stamp:
-            c = cells(lines[i])
-            over.append("stamp %s %s is %d chars, over %d"
-                        % (c[0] if c else "?", c[2] if len(c) > 2 else "", len(lines[i]), stamp))
+    for sp in std:
+        if width(sp) > row:
+            label = (cells(lines[sp[0]]) or ["?"])[0] if form == "table" \
+                else "#" + ITEM.match(lines[sp[0]]).group(1)
+            over.append("standing row %s is %d chars, over %d" % (label, width(sp), row))
+    for sp in stm:
+        if width(sp) > stamp:
+            c = cells(lines[sp[0]]) if lines[sp[0]].startswith("|") else []
+            label = "%s %s" % (c[0], c[2] if len(c) > 2 else "") if c \
+                else "%s (list)" % (stamp_date(lines, sp) or "undated")
+            over.append("stamp %s is %d chars, over %d" % (label.strip(), width(sp), stamp))
     if len(std) > CAP:
         over.append("%d standing rows, over the cap of %d" % (len(std), CAP))
     if len(stm) > CAP:
         over.append("%d run stamps, over the cap of %d" % (len(stm), CAP))
     return {
         "bytes": nbytes, "tokens": nbytes // 4, "budget": budget,
-        "standing": len(std), "standing_max": max([len(lines[i]) for i in std] or [0]),
-        "stamps": len(stm), "stamps_max": max([len(lines[i]) for i in stm] or [0]),
+        "standing": len(std), "standing_max": max([width(sp) for sp in std] or [0]), "form": form,
+        "stamps": len(stm), "stamps_max": max([width(sp) for sp in stm] or [0]),
         "over": over, "lines": lines, "spans": spans, "std": std, "stm": stm,
     }
 
 
 def summary(m, row=ROW, stamp=STAMP):
-    return ("retro floor: %d bytes · ~%d tokens (bytes/4) · budget %d · standing %d/%d rows, "
+    return ("retro floor: %d bytes · ~%d tokens (bytes/4) · budget %d · standing %d/%d rows%s, "
             "largest %d/%d · stamps %d/%d, largest %d/%d"
-            % (m["bytes"], m["tokens"], m["budget"], m["standing"], CAP, m["standing_max"], row,
+            % (m["bytes"], m["tokens"], m["budget"], m["standing"], CAP,
+               " (numbered list)" if m.get("form") == "numbered list" else "", m["standing_max"], row,
                m["stamps"], CAP, m["stamps_max"], stamp))
 
 
@@ -177,9 +271,92 @@ def cmd_migrate(a):
     archive = a.archive or default_archive(a.retro)
     rel = os.path.relpath(os.path.abspath(archive),
                           os.path.dirname(os.path.abspath(a.retro))).replace(os.sep, "/")
-    moved = []
-    for i in m["stm"]:
-        if len(lines[i]) <= a.stamp:
+    moved = []      # (first line, last line exclusive, replacement lines, block, label)
+    head = m["spans"][STAMPS][0]
+    notes = []      # pointer lines inserted under the Run stamps heading
+    rotated = set()
+    if len(m["stm"]) > CAP:
+        # The cap rotates the OLDEST stamps out whole (references/retrospective.md, *The
+        # stamp table is capped at ten*). Oldest is read from the date, never from the
+        # position: tables and lists are written both ways round.
+        # A same-day tie is broken by position, the way its own block is written: a list
+        # written newest-first and a table written oldest-first can sit side by side.
+        def block_of(sp):
+            if not lines[sp[0]].startswith("|"):
+                return "list"
+            k = sp[0]
+            while k > 0 and lines[k - 1].startswith("|"):
+                k -= 1
+            return k
+        blocks = {}
+        for n, sp in enumerate(m["stm"]):
+            blocks.setdefault(block_of(sp), []).append((n, stamp_date(lines, sp)))
+        newest_first, votes = {}, []
+        for key, seq in blocks.items():
+            ds = [d for _, d in seq]
+            down = sum(1 for x, y in zip(ds, ds[1:]) if x and y and x > y)
+            up = sum(1 for x, y in zip(ds, ds[1:]) if x and y and x < y)
+            newest_first[key] = None if down == up else down > up
+            if newest_first[key] is not None:
+                votes.append(newest_first[key])
+        # A block whose dates show no direction takes the section's; with no evidence
+        # anywhere, newest first, the template's order.
+        fallback = sum(votes) * 2 >= len(votes) if votes else True
+        for key in newest_first:
+            if newest_first[key] is None:
+                newest_first[key] = fallback
+        dated = [(stamp_date(lines, sp), -n if newest_first[block_of(sp)] else n, sp)
+                 for n, sp in enumerate(m["stm"])]
+        if any(d is None for d, _, _ in dated):
+            print("migrate: a run stamp carries no YYYY-MM-DD date; rotate the stamps by hand")
+        else:
+            rotated = set(sp for _, _, sp in sorted(dated)[:len(dated) - CAP])
+            # A rotated table row travels under its table's header, so the archive keeps
+            # a table and the header of a table emptied by the rotation is not lost.
+            parts, headed = [], set()
+            for sp in m["stm"]:
+                if sp not in rotated:
+                    continue
+                if lines[sp[0]].startswith("|"):
+                    k = sp[0]
+                    while k > 0 and lines[k - 1].startswith("|"):
+                        k -= 1
+                    if k not in headed:
+                        headed.add(k)
+                        parts.append("\n".join(lines[k:k + 2]))
+                parts.append("\n".join(lines[sp[0]:sp[1]]))
+            text = "\n".join(parts)
+            for k in headed:
+                j = k + 2
+                while j < len(lines) and lines[j].startswith("|"):
+                    j += 1
+                if all((r, r + 1) in rotated for r in range(k + 2, j)):
+                    moved.append((k, k + 2, [], None, None))   # archived above, with its rows
+            h, b = block("stamps", "%d oldest rotated" % len(rotated), text)
+            for sp in rotated:
+                moved.append((sp[0], sp[1], [], None, None))
+            notes.append(("Rotated out: %d oldest run stamps, verbatim in %s sha256:%s"
+                          % (len(rotated), rel, h[:12]), b, "%d oldest run stamps rotated" % len(rotated)))
+    for sp in m["stm"]:
+        i = sp[0]
+        if sp in rotated or len("\n".join(lines[sp[0]:sp[1]])) <= a.stamp:
+            continue
+        if not lines[i].startswith("|"):
+            # A list stamp keeps its bold title; the narrative moves.
+            item = "\n".join(lines[sp[0]:sp[1]])
+            title = lead_of(lines, sp)
+            if not title:
+                print("migrate: the %s stamp has no **bold** title to keep; shorten it by hand"
+                      % (stamp_date(lines, sp) or "undated"))
+                continue
+            h, b = block("stamp", stamp_date(lines, sp) or "undated", item)
+            ptr = " moved: %s sha256:%s" % (rel, h[:12])
+            t = title
+            if len("- %s%s" % (t, ptr)) > a.stamp:
+                inner = re.sub(r"\*\*", "", t)
+                t = "**%s…**" % inner[:max(8, a.stamp - len("- ****…") - len(ptr))].rstrip()
+            moved.append((sp[0], sp[1], ["- %s%s" % (t, ptr)], b,
+                          "stamp %s (list)" % (stamp_date(lines, sp) or "undated")))
             continue
         c = cells(lines[i])
         if len(c) < 3:
@@ -197,22 +374,69 @@ def cmd_migrate(a):
         if len(new) > a.stamp:
             keep = max(8, len(topic) - (len(new) - a.stamp) - 1)
             new = row_of(topic[:keep].rstrip() + "…")
-        moved.append((i, new, b, "stamp %s %s" % (c[0], c[2])))
-    for i in m["std"]:
-        if len(lines[i]) <= a.row:
+        moved.append((i, i + 1, [new], b, "stamp %s %s" % (c[0], c[2])))
+    if m["bytes"] > a.budget:
+        # Prune paragraphs between the stamps were a measured share of the floor
+        # (*A prune that retires nothing writes its count into the stamp row*): over
+        # budget, every loose paragraph of the Run stamps section moves, verbatim.
+        taken = set(k for s0, s1 in m["stm"] for k in range(s0, s1))
+        prose = loose_prose(lines, m["spans"][STAMPS], taken)
+        # verify ends an archive block at a blank line before a heading, so a paragraph
+        # holding a heading stays in the floor rather than moving unprovable.
+        held = [pp for pp in prose if any(re.match(r"^#{1,6} ", l) for l in lines[pp[0]:pp[1]])]
+        for p0, _ in held:
+            print("migrate: a heading inside Run stamps stays in the floor: %s" % lines[p0][:60])
+        prose = [pp for pp in prose if pp not in held]
+        if prose:
+            text = "\n\n".join("\n".join(lines[p0:p1]) for p0, p1 in prose)
+            h, b = block("stamps prose", "%d paragraphs" % len(prose), text)
+            for p0, p1 in prose:
+                moved.append((p0, p1, [], None, None))
+            notes.append(("Moved out: %d loose paragraphs, verbatim in %s sha256:%s"
+                          % (len(prose), rel, h[:12]), b, "%d prose paragraphs" % len(prose)))
+    if notes:
+        moved.append((head + 1, head + 1, sum([["", n] for n, _, _ in notes], []), None, None))
+        for n, b, label in notes:
+            moved.append((head + 1, head + 1, [], b, label))
+    for s0, s1 in m["std"]:
+        item = "\n".join(lines[s0:s1])
+        if len(item) <= a.row:
             continue
-        c = cells(lines[i])
+        # Already migrated and still too long: its story is gone, the rule itself is the
+        # length. Moving the pointer again would rewrite the floor on every run.
+        if POINTER.search(item):
+            continue
+        if m["form"] == "numbered list":
+            # Keep the rule (its bold lead) and its retire-when trigger; the story moves.
+            flat = " ".join(l.strip() for l in lines[s0:s1])
+            num = ITEM.match(lines[s0]).group(1)
+            lead = lead_of(lines, (s0, s1))
+            retire = RETIRE.findall(flat)
+            if not lead:
+                print("migrate: standing #%s opens with no **bold** rule (or only a date); "
+                      "rewrite it by hand" % num)
+                continue
+            h, b = block("standing", "#" + num, item)
+            new = "%s. %s%s story: %s sha256:%s" % (
+                num, lead, (" *(%s)*" % retire[-1]) if retire else "", rel, h[:12])
+            if not retire:
+                print("migrate: standing #%s carries no *(Retire ...)* trigger; add one by hand" % num)
+            moved.append((s0, s1, [new], b, "standing #%s story" % num))
+            continue
+        c = cells(lines[s0])
         if len(c) < 5:
             continue
         h, b = block("standing", c[0], c[4])
         c[4] = "story: %s sha256:%s" % (rel, h[:12])
-        moved.append((i, "| " + " | ".join(c) + " |", b, "standing %s Because" % c[0]))
+        moved.append((s0, s1, ["| " + " | ".join(c) + " |"], b, "standing %s Because" % c[0]))
     if not moved:
         print(summary(m, a.row, a.stamp))
         print("migrate: nothing to move")
         return 1 if m["over"] else 0
-    for i, new, _, label in moved:
-        print("migrate: %s -> %s (%d -> %d chars)" % (label, rel, len(lines[i]), len(new)))
+    for s0, s1, new, _, label in moved:
+        if label:
+            print("migrate: %s -> %s%s" % (label, rel, "" if s0 == s1 else " (%d -> %d chars)" % (
+                len("\n".join(lines[s0:s1])), len("\n".join(new)))))
     if not a.write:
         print("migrate: dry run, nothing written (pass --write)")
         return 0
@@ -224,10 +448,25 @@ def cmd_migrate(a):
                      "text they hold; the floor keeps a pointer to it.\n"
                      % os.path.basename(archive)[:-3])
     with open(archive, "a", encoding="utf-8") as fh:
-        for _, _, b, _ in moved:
-            fh.write(b)
-    for i, new, _, _ in moved:
-        lines[i] = new
+        for _, _, _, b, _ in moved:
+            if b:
+                fh.write(b)
+    # Rebuild from the bottom so earlier spans keep their indices.
+    for s0, s1, new, _, _ in sorted(moved, key=lambda x: (x[0], x[1]), reverse=True):
+        lines[s0:s1] = new
+    # Removed stamps leave their blank separators behind: within Run stamps, one blank
+    # line between blocks is enough. Only a run that removed something tidies, so a
+    # table retro that only had a row shortened keeps its bytes (1.99.0 behaviour).
+    removed = any(s0 != s1 and not new for s0, s1, new, _, _ in moved)
+    _, sp2 = sections("\n".join(lines))
+    a0, a1 = sp2[STAMPS]
+    seg = lines[a0:a1]
+    kept = []
+    for k, line in enumerate(seg):
+        if removed and not line.strip() and kept and not kept[-1].strip():
+            continue
+        kept.append(line)
+    lines[a0:a1] = kept
     tmp = a.retro + ".tmp"
     with open(tmp, "w", encoding="utf-8") as fh:
         fh.write("\n".join(lines))