mcp-gee-sweet 0.9.6.dev136__tar.gz → 0.9.6.dev140__tar.gz

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/.claude/team-roles/dev.md

@@ -47,7 +47,7 @@ Branch naming for this slot always puts `<name>` as the **second** `/`-separated
 Friction Dev (Ash/Jay) typically hits after finishing a ticket, and where it goes — see `/retro` for the general ticket-vs-command-decision split. Each entry is the rule; the incident behind it is in [`role-file-history.md`](../../docs/decisions/role-file-history.md#devmd).
 
 - **Design/architecture surprises** — an existing pattern didn't generalize the way expected mid-implementation (a sibling function skipped a step this one needed, a helper needed restructuring to fit a new case). If it's about how future Devs should approach similar work, that's a command decision: add a note to `CLAUDE.md` or a `docs/design/` snapshot, through the Bob gate above. If it's legitimate follow-up scope not worth doing in the current PR, it goes through step 6's follow-up triage, not straight to a ticket.
-- **Take the generalized fix when QA's send-back names a root cause** (e.g. "X is a scalar, not a stack"), not just a symptom list, even when it's more work than patching the listed cases. A narrower patch leaves the same defect class reachable one level up and costs another QA round (PR #369 took three).
+- **Take the generalized fix when QA's send-back names a root cause** (e.g. "X is a scalar, not a stack"), not just a symptom list, even when it's more work than patching the listed cases. A narrower patch leaves the same defect class reachable one level up and costs another QA round (PR #369 took three). **The limit:** when the generalized fix would replace the mechanism the ticket builds on with a new one (a new state model for the module, not a fix inside it), and the ticket didn't ask for that, ask the user how far to take it before building it: the replacement, or a fix for each finding inside the existing mechanism with the root cause filed as a ticket. The findings get fixed either way. Not asking turned a tag-mapping ticket into a six-round rewrite of `html_parser.py`'s inline styling (PR #1316).
 - **Verify QA's suggested code against the actual invariant before adopting it; a correct diagnosis can come with a wrong fix.** When a change touches a state flag that gates several conditions (`_tag_depth`, `_table_depth`, `_block_tag`, or equivalents), grep every read-site of the flag and compare the conditions by hand before opening the PR. Running the suite isn't enough (PR #406).
 - **Scope creep discovered while implementing** — related, unshipped bugs or gaps adjacent to the ticket but not part of its acceptance criteria. Don't fold them into the current PR; triage them through step 6's follow-up rule, which files a ticket only under a named bar.
 - **Stale or missing `CLAUDE.md` guidance** for a pattern you just hit: fix `CLAUDE.md`, through the Bob gate above, not a direct push.

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/.claude/team-roles/qa.md

@@ -30,11 +30,13 @@ Find the partner Dev's open PR by matching the branch's second `/`-separated seg
      There is no "non-blocking" heading. "Small," "narrow," "low priority," and "doesn't block `qa-approved`" describe a `send-back`; they aren't reasons to file. Kai's `/merge-pr` step 2 reads this list and won't merge a PR whose comments file a ticket without a `bar N:` reason, or drop a finding for its size or priority.
 
      The four bars:
-     1. **Maintainer/product decision.** A real design or scope call the Dev can't make: it changes user-facing behavior, trades off cost or risk only the maintainer can accept, or sets precedent beyond this PR. Test: if you sent it back now, could the Dev pick a reasonable option and ship it? If yes, it isn't bar 1. Several valid ways to implement a fix is not a bar-1 reason.
+     1. **Maintainer/product decision.** A real design or scope call the Dev can't make: it changes user-facing behavior, trades off cost or risk only the maintainer can accept, or sets precedent beyond this PR. Test: if you sent it back now, could the Dev pick a reasonable option and ship it? If yes, it isn't bar 1. Several valid ways to implement a fix is not a bar-1 reason. A root cause whose fix replaces the mechanism the ticket builds on with a new one (a new state model for the module, not a fix inside it), beyond what the ticket asks, *is* bar 1: the Dev could build it, but whether this PR should is the maintainer's call (PR #1316).
      2. **Outside this PR's diff.** For this triage, "inside the diff" means every file the diff modifies, plus every function that code the diff adds or changes calls directly (name the call in the finding). A finding inside the diff is a `send-back` unless bar 1, 3, or 4 applies. That includes a function the diff doesn't touch, as long as the finding has behavior impact (the value test below); one in an untouched function with no behavior impact is `dropped: … — no behavior impact outside the changed functions`. #993, #994, and #990 were filed under bar 2 and should have been send-backs. Bar 2 covers only the rest: a file the diff doesn't modify and the PR's code doesn't call (e.g. #904), a sweep across call sites outside those files (e.g. #737's 6+ untouched call sites), or a fix that "Check other open PRs" below defers because another open PR changes the same file. When the same pattern also appears elsewhere, only the elsewhere part qualifies. **Value test:** being outside the diff is why it can't be fixed now, not why it deserves a ticket. File only if it has behavior impact, meaning an observed failure or a concrete path to wrong output, a crash, a hang, a leak, or misleading output. A refactor, deduplication, or readability finding with no behavior impact is `dropped: … — outside this diff, no behavior impact` (#908 was this case). So is a statement in root `CLAUDE.md`, `.claude/team-roles/*.md`, or `.claude/commands/*.md` that the PR made stale: it's guidance for agents, not tool behavior, and "an agent might follow it" isn't a concrete path (#1014).
      3. **Needs infrastructure or access** this pass doesn't have.
      4. **A pre-existing defect inside the diff (as bar 2 defines it), whose fix would move code to another thread or change what awaits what.** A short fix like that opens new races for the next round to find (PR #867). A pre-existing defect whose fix doesn't change threading or await order is a `send-back`.
 
+     **Stop the loop when each fix breaks the same mechanism again.** A finding is a regression from the last fix when it reproduces at this round's head but not at the previous round's `<short-sha>`. If this round finds one, and the previous round also found one from its fix, both in the same mechanism, don't send it back again. Follow step 7 with two changes: the verdict on the first line is the literal text `escalated` (`## QA round <N> (<Name>) @ <short-sha>: escalated`), with `<mechanism> regressed in rounds <N-1> and <N>` as the comment's second line, and don't run `/notify-partner`. Then end the turn with `Waiting on you:` asking the user whether to continue, cut the PR back to the ticket's scope, or redesign. Nothing is filed until the user decides. PR #1316 ran six rounds this way before the user stepped in.
+
      **Search before filing.** Run `gh issue list --state open --search "<function or file name> <symptom>"` right before `gh issue create`. If an open issue already describes the same defect (same code path and same failure, not just a shared keyword), comment the new evidence there instead of filing. Do the same when an open issue's planned fix would also fix this finding, even if it describes a different symptom: read the design or "possible fix" section of every hit, not just its title (#906 was already covered by #873's design and was closed into it). Put the issue you commented on in the finding line: `ticket — bar N: <reason> (commented on #<issue>)`. Classify a filed ticket `enhancement` (or `defect` only if a failure was actually observed). History of this rule: `docs/decisions/decision-review-finding-ticket-bar.md`.
 
      **Name the cell and the chain in every ticket you file.** The ticket body states its impact × reach cell (`kai.md` "Version labels", e.g. `wrong/narrow`) and, if the issue this PR closes was itself filed from an earlier PR's review, which root defect the chain starts from and how many follow-ups precede the new one. Kai sets the version label from those two lines (`kai.md`'s chain stop rule). Neither changes this triage: a finding inside the diff is still a `send-back`, however long its chain.

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/CLAUDE.md

@@ -87,6 +87,7 @@ Each entry below says what a module owns and the invariants a future edit could
     - A block inside a list item (#1094) is that block's own node with `list_depth`/`list_path` naming the item, from `_list_item_fields`, which every non-item leaf construction (and a top-level `Table`, at `</table>`) must pass. The item is the one whose later segment is open, else the innermost `<li>` frame on `_block_stack` whose list ids are exactly the ones open now (each `_BlockFrame` records the interrupted block's `_block_lists`), so a block loose in a list nested in the item isn't the item's. "Open now" is the open block's own `_block_lists`, not the live `_list_ids`, since a block left open until its list's `</ul>` is flushed after the pop (PR #1301 QA round 1). The walk skips a non-matching `<li>` frame instead of stopping at it: an unclosed item in a nested list leaves its frame behind after the `</ul>` (PR #1301 QA round 2). Match by ids, never by depth: a stale frame from a closed list has the depth of a later list (PR #1301 QA round 3). A resumed `<li>` segment (text after a nested list, quote, code block, paragraph or rule) is therefore a `Paragraph` inside the item, never a new `BulletItem`. A heading that opens an `<li>` (`- # Title`) is the item's own text: `BulletItem.heading_level`, the item emitted at the heading's close and its later segment resumed. Its tag stays on `_li_heading_tags` until that `</hN>`, so the end tag is consumed even when a nested block interrupted the item first; never let it reach the inline end-tag path, which would decrement `_tag_depth` for a start tag that never incremented it.
     - In a table cell, a whitespace run holding a line break is dropped at a segment's start (the cell's start, or just after a nested table). At the end of the text so far it's held as runs with their own style and link (`_cell_held_runs`), and written only if content follows in the same segment, which ends at a nested `<table>` or `</td>` (#1073). Nothing inside a cell's `<pre>` is trimmed (`_cell_pre_depth`). Everything else in a cell parses as it did before; collapsing every source line break merged a cell's `<p>`s and `<pre>` lines (PR #1215 QA round 2), and whether a newline in cell text should collapse is #1221 (`docs/design/image-conversion.md`).
     - `_interrupt_open_block` drops trailing whitespace holding a line break from the outgoing segment's unflushed source text: markdown-it writes `<li>a\n<ul>` for every nested block, and the `\n` would become an empty paragraph (#1116). A `<br>` goes into the run buffer as `_LineBreak`, never a bare `"\n"`, so that trim leaves it. A resumed segment likewise drops the line break at its start (`handle_data`), keeping an authored `&nbsp;`. Neither trim runs in `<pre>` (`_in_pre`), where the break and indentation are the code's. An `<hr>` in any open block, outside `<pre>` and inline tags, interrupts and resumes it: after text, in a resumed segment, in a fresh `<li>` (an empty bullet, #1075), and in a fresh block with no text, whose empty first segment emits nothing, so `<p><hr></p>` is the rule alone (#1096).
+    - Inline tags map to `Run` fields: `<s>`/`<strike>`/`<del>` (and GFM `~~x~~`, which markdown-it writes as `<s>`) to `strikethrough`, `<sub>`/`<sup>` to `baseline_offset` (innermost open one wins; a close pops only its own kind), `<mark>` to a yellow `background_color` (#1231). Each new tag shares `<s>`'s open/close/reset sites, so on malformed input it behaves exactly as `<s>` does (`TestNewInlineTagsMatchStrikeOnMalformedInput`). Making that match a browser is #1329; don't special-case one tag ahead of it.
     - Known gap: a resumed block's genuine trailing `&nbsp;` is dropped (#444).
   - `docs/emitter.py` — AST→Docs API requests, plus the multi-phase table fill (nested tables, cell styling). [History](docs/design/module-history.md#toolsdocsemitterpy). Invariants:
     - Bullet depth is encoded as leading `"\t"` on each paragraph's text, and `createParagraphBullets` computes levels only within one call. So each top-level list gets exactly one call over its whole range, nested lists of either type included; one call per paragraph creates separate lists and breaks numbering. `_bullet_lists` (#1072) returns each top-level list with the lists nested in it that aren't merged into it: every list of the other type, and a same-type list that follows another sublist under the same item (which restarts). A top-level list's range spans every item nested in it, a trailing nested list's too, or that list's tabs go unconsumed. Each of those is then taken back out, parent before child (`_top_list_requests`: delete its bullets, zero its indent, re-insert its tabs, anchor-wrap it with its own preset), so the outer list keeps counting past it. A `createParagraphBullets` range containing an already-listed paragraph joins the unlisted ones to that paragraph's list (confirmed live), so the outer call can't come last. A range whose preceding paragraph is in a same-preset list joins that list too (confirmed live, #1241), so a nested list's anchor wrap puts a barrier paragraph before its anchor (`barrier=True`). Each `BulletItem` carries `list_path`, the ids of its enclosing `<ul>`/`<ol>` lists (`html_parser._push_list`), captured when its block segment opens (`_block_lists`), since an unclosed `<li>` is flushed after `</ul>` pops. An open list that doesn't enclose an item is closed first (`_encloses`), and a shallower item rejoins the block's first list only from a list enclosing it (`_rejoins_root`), so two adjacent same-type lists stay two Docs lists at any depth; an item without ids groups by depth and type alone. A nested list re-inserts and re-consumes its own tabs, so each item's tabs are consumed once, net.

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcp-gee-sweet
-Version: 0.9.6.dev136
+Version: 0.9.6.dev140
 Summary: MCP server for Google Workspace — Sheets, Drive, Docs (HTML or Markdown), Calendar, and Gmail.
 Project-URL: Homepage, https://github.com/khuisman/mcp-gee-sweet
 Project-URL: Bug Tracker, https://github.com/khuisman/mcp-gee-sweet/issues

mcp_gee_sweet-0.9.6.dev140/docs/decisions/decision-html-error-recovery.md

@@ -0,0 +1,143 @@
+# Decision: How `html_to_ast` Recovers From Malformed HTML
+
+**Date:** 2026-11-01
+**Status:** proposed. The maintainer picks an option; this doc records the evidence and a lean.
+**Tracking:** #1329 (the bundled defects below)
+**Snapshot commit:** `develop` at `730b7dc7`; PR #1316 at `589d3991`
+
+## Background
+
+`tools/docs/html_parser.py` turns HTML into the Docs AST. It subclasses the standard
+library's `html.parser.HTMLParser`, which is a *tokenizer*: it reports start tags, end tags
+and text, in order, and nothing else. It builds no tree and does no error recovery. What a
+browser does with `<p><b>x</p>`, a stray `</b>`, `<sup>a<sub>b</sup>c</sub>`, or a cell with no
+`</td>` is the HTML Standard's *tree construction* stage (§13.2.6: the stack of open elements,
+the list of active formatting elements, the adoption agency algorithm, implied end tags).
+`html_to_ast` does that job itself, by hand, in event handlers.
+
+Malformed HTML reaches the parser two ways only. Markdown never produces it: markdown-it
+writes well-formed HTML for everything it parses. It arrives through raw HTML a user writes
+inside Markdown (markdown-it's `html=True` passes it through) and through
+`content_format="html"`.
+
+### What PR #1316 showed
+
+#1231 asked for `<del>`, `<sub>`/`<sup>` and `<mark>` to map onto `Run` fields the emitter
+already writes. Round 0 (`f8a25f82`) was +91 lines in `html_parser.py`, and every TC-MD503
+case rendered correctly live. QA's code review then found parser-state edge cases with
+unbalanced tags, and the fix for those became a rewrite of how inline styling is tracked.
+Six QA rounds followed:
+
+| Round | `html_parser.py` change | QA result |
+|---|---|---|
+| 0 | +91 / −2 | 8 findings: new tags' scope across cells, items and tables; one regression |
+| 1 | +199 / −149, one inline-tag stack | all fixed; 2 new regressions, 7 more findings |
+| 2 | +115 / −91, reopen queue, links on the stack | all fixed; 3 new regressions (one content loss) |
+| 3 | +80 / −36, cross-scope close fallback | all fixed; 2 new regressions (one quadratic), 4 older defects |
+| 4 | +186 / −96, constant-time stack | all fixed; 3 paths still quadratic |
+| 5 | +142 / −76, indexed stack | all fixed; 3 new regressions (quadratic, `<th>` bold, content loss) |
+
+The PR stood at +1,093 / −180 overall. Each round fixed every named finding and introduced
+new ones in the same mechanism. The pieces it added are pieces of the Standard's algorithm
+under other names: scope markers, a list of active formatting elements reopened in the
+next block, a cap of 3 identical reopened entries (the Standard's "Noah's Ark" clause), an
+`<a>` that closes an open `<a>`. Rebuilding that algorithm piece by piece, driven by
+adversarial review inputs, has no natural end point.
+
+## The defects on `develop` today
+
+These are reproduced with `html_to_ast` on `develop` (static, unit-level; no Docs API call).
+The "browser" column is the tree html5lib and lexbor build.
+
+| Input | `develop` | Browser | Kind |
+|---|---|---|---|
+| `<table><tr><td>a<td>b</table><p>after</p>` | table lost, only "after" | 2-cell table | content loss |
+| `<table><tr><td>a</td><tr><td>b</td></table>…` | table lost | 2-row table | content loss |
+| `<p>a</p></table><p>b</p>c` | only "a" | "a", "b", "c" | content loss |
+| `<p><b>a</p>bare` | "bare" dropped | "bare" kept | content loss |
+| `<p><s>a</p></s><p>b</p>` | "b" struck | "b" plain | styling |
+| `<table><tr><td><s>a</td><td>b</td>…` | "b" struck | "b" plain | styling |
+| `<p><b>a</p><table><tr><td>x</td>…` | "x" bold | "x" plain | styling |
+| `<b><p>x</b></p>` | "x" plain | "x" bold | styling |
+
+Two behaviors that look like leaks match a browser and aren't defects:
+`<p><s>a</p><p>b</p>` strikes "b", and `<p><a href="1">x</p><p>y</p>` links "y". The
+Standard reopens an unclosed formatting element in the next block.
+
+PR #1316's QA rounds list more inputs of the styling kind (misnested `<sup>`/`<sub>`, a
+list item's own `<p>`, formatting carried past a list depending on whether `</p>` came
+first). Most become reachable only once `<sub>`/`<sup>`/`<mark>` exist, and they are the
+same class.
+
+## Options
+
+### Option A: build the tree with an HTML5 parser, then walk it
+
+Parse with a library that implements the Standard's tree construction, then walk the
+finished tree to the AST. A text node's inline styles are the inline elements above it;
+its block is the nearest block ancestor. Every row in the table above comes out as the
+browser column, with no project code for recovery.
+
+Candidate libraries, checked 2026-11-01:
+
+| Library | Kind | Latest release | Adversarial input, n = 8,000 (24,000 tags) | 427 KB document |
+|---|---|---|---|---|
+| selectolax (lexbor backend) | C extension, binary wheels | 1.0.2, 2026-10-22 | 0.005 s | 0.016 s |
+| justhtml | pure Python, no runtime deps | 3.16.0, 2026-10-26 | 0.19 s | 0.20 s |
+| html5lib | pure Python, `six` + `webencodings` | 1.1, 2020-06-22 | 2.1 s (superlinear) | 0.66 s |
+
+The adversarial input is QA round 6's `'<p>' + '<b>'*n + '<i>'*n + '</b>'*n + 'x</p>'`
+(3n tags). The 427 KB document is 5,000 repetitions of
+`<p>para <b>bold</b> <a href='uN'>link</a> <sup>2</sup></p><ul><li>item N</li></ul>`,
+well-formed. Each time is one parse in a scratch environment.
+
+html5lib is the reference implementation but unmaintained and superlinear on adversarial
+input. selectolax is the fast, maintained choice; it adds a compiled dependency (precedent:
+Pillow, `decision-pillow-image-dependency.md`). justhtml avoids a compiled dependency but is
+young.
+
+**Pros:** correct by construction; deletes most of the hand-written state. Many of
+`html_parser.py`'s invariants in `CLAUDE.md` exist only because the parser sees tags one at
+a time (resumed segments, `_block_stack` frames, stale frames matched by list ids, the
+inline-tag-depth bare-text rule) and become plain tree structure.
+**Cons:** a rewrite of a ~1,400-line module with a long incident history. Output on
+malformed input changes to the browser's, so tests that pin `develop`'s behavior change.
+Some current rules are deliberate departures that a walker has to keep, for example
+#994's href-less `<a name>` inside a link. A new runtime dependency.
+
+### Option B: a planned, hand-written recovery model
+
+Decide which recovery rules this parser supports, write them down, and implement them as a
+design rather than finding by finding.
+
+**Pros:** no dependency; the rule set can be smaller than a browser's.
+**Cons:** a model good enough to stop the review findings converges on the Standard's
+algorithm, which is what PR #1316 was doing. Adversarial review keeps finding the gap
+between the written model and a browser.
+
+### Option C: fix content loss only, and document the rest
+
+Fix the four content-loss rows. Accept wrong styling on malformed input as a known
+limitation in `docs/known-limitations.md`, and stop treating a styling difference on
+malformed input as a review send-back.
+
+**Pros:** smallest change; content is the part a user can't recover by restyling.
+Malformed input is rare in practice (not reachable from plain Markdown).
+**Cons:** the parser stays non-browser on malformed input; reviews need the stated bar to
+hold.
+
+## Lean
+
+**A, with selectolax, if a compiled dependency is acceptable; C otherwise.** B ends up
+reimplementing the Standard by hand. C is cheap and can ship first: its four fixes are
+independent of the inline-styling code, and Option A would later replace them.
+
+The choice is the maintainer's, because A adds a runtime dependency and changes output on
+malformed input.
+
+## Decided alongside: #1231 scope
+
+PR #1316 stops. #1231 ships as round 0's tag mapping only, on `develop`'s existing
+inline-styling mechanism: a new tag behaves on malformed input exactly as `<s>` does on
+`develop`. That is the review bar. A difference on malformed input that `<s>` also has is
+this decision's ticket, not a send-back.

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/docs/decisions/index.md

@@ -33,3 +33,4 @@ Point-in-time records of specific decisions — context, alternatives, and reaso
 | [Role-File History](role-file-history.md) | 2026-10-08 | record | Incident history behind the rules in `dev.md`, `qa.md`, `aziz.md`, `kai.md`, and `bob.md`, moved there verbatim by #849 so each role file keeps only its rules |
 | [Impact × Reach Triage](decision-impact-reach-triage.md) | 2026-10-13 | decided | One impact × reach rubric places every defect/hygiene ticket in a version, on every triage path (replaces #995's from-review-only rule); hygiene never gets its own release label; a follow-up chain stops gating the release after its second follow-up; QA and Dev answer four seam questions each pass (#1024) |
 | [HTTP Socket Timeout](decision-http-socket-timeout.md) | 2026-10-24 | decided | `thread_http`'s per-thread transport gets the two settings googleapiclient's `build_http()` gives every `build()`-built client and a bare `httplib2.Http()` lacked (#1129): a per-socket-operation timeout (`HTTP_TIMEOUT_SECONDS`, default googleapiclient's 60 s) so a silently dead connection can't hang a call, with a timeout error that says whether a write may have landed; and 308 removed from redirect codes, which had failed every resumable upload over 100 MB. Connect-only timeout and TCP keepalive considered and rejected |
+| [HTML Error Recovery](decision-html-error-recovery.md) | 2026-11-01 | proposed | `html_to_ast` hand-builds the HTML Standard's tree-construction recovery on a tokenizer; PR #1316 spent six QA rounds rebuilding it piece by piece. Options: an HTML5 parser library (lean: selectolax), a planned hand-written model, or content-loss fixes only. #1231 ships as the tag mapping alone, bar "behaves like `<s>` on `develop`" |

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/docs/decisions/role-file-history.md

@@ -60,6 +60,10 @@ Friction Dev (Ash/Jay) typically hits after finishing a ticket, and where it goe
 
 - **QA sends a fix back with an explicit root-cause diagnosis (not just a symptom list)** — e.g. "X is a scalar, not a stack" alongside the reported gaps. Take the generalized fix implied by that diagnosis immediately, even though it's more work than patching the specific cases QA listed. A narrower patch that only covers the reported cases tends to leave the same defect class reachable one level up, costing a full extra QA round-trip to rediscover — confirmed on PR #369 (issue #335): round 1 fixed only `<ul>`/`<ol>` interrupting a `<li>`; round 2 found `<pre>`/`<table>`/`<p>` had the identical bug; the fix generalized to "any block tag interrupting a `<li>`" but stayed keyed on `_block_tag == "li"` specifically; round 3 found *any* open block (headings, paragraphs) had the same bug one level up again, plus a correctness bug in the interim stack itself. Three rounds to reach the fix round 2's own diagnosis ("`_block_tag` is a scalar, not a stack") already pointed at.
 
+### The generalized fix's limit: a new mechanism the ticket didn't ask for (2026-11-01)
+
+PR #1316 (#1231) followed the PR #369 rule above to its failure case. Kit's round-1 root cause on a tag-mapping ticket implied replacing `html_parser.py`'s inline-styling counters with a new inline-tag stack, and Jay built it in the PR. The stack took five more rounds, each fixing the named findings and regressing elsewhere in it, before the user closed the PR in favor of round 0's +91-line scope (details under `qa.md`'s 2026-11-01 entry). PR #369's generalization stayed inside the existing mechanism; #1316's replaced it. The rule now asks the user before building a replacement the ticket didn't ask for.
+
 ### QA's root-cause diagnosis can be correct while its suggested code is still wrong — verify before adopting,…
 
 - **QA's root-cause diagnosis can be correct while its suggested code is still wrong — verify before adopting, don't paste it in as-is.** Distinct from the PR #369 entry above: that one is about not narrowing a correct diagnosis's *scope*; this is about not trusting a correct diagnosis's *literal suggested fix* without checking it against the actual invariant. PR #406 (issue #401 follow-up) hit this twice in one PR: a reused flag that pattern-matched the fix used at sibling call sites didn't actually distinguish the two cases the diagnosis conflated, and a second, unrelated sibling check nearby had the same gap with no test covering it at all — so "run the full suite," round 1's own fix, wouldn't have caught round 2 either. Fix: when a change touches a state flag that gates multiple conditions (`_tag_depth`, `_table_depth`, `_block_tag`, or equivalents elsewhere), grep every read-site of that flag and diff the conditions against each other by hand before opening the PR — a search-and-compare step, not a "run tests and trust it" one.
@@ -302,6 +306,14 @@ PR #1006 (#989, lane B) took seven rounds, and `qa.md` changed under it twice. K
 
 On 2026-10-28, four docs-only QA PRs (#1270, #1271, #1274, #1276, none of them a lane Dev's) were waiting at once. Kit reviewed #1270 and sent it back. That bound the session to #1270, so #1274, a results-only PR in the same `docs/qa/` tree, needed a fresh Kit session, and Kit would have to `/clear` again for Jay's next PR. The rule's reason (#843) is the cost of carrying a finished review's context into every later turn. A `docs/qa/` PR changes no code the slot's server runs, so a reset to its branch can't leave the server running stale code. The maintainer asked for the exception. It's scoped by path, never by diff size (#1271 is `docs/qa/`-only at an 87 KB patch): every changed path under `docs/qa/`, never the partner Dev's PR, judged on each head before resetting to it, so a QA-docs PR that later adds code is re-classified. A session that has reset to any PR's branch still needs `/clear` before a partner or code PR (Bob's prompt-QA round 1).
 
+### Bar 1 for a mechanism-replacing root cause, and stopping a regressing loop (2026-11-01)
+
+PR #1316 (#1231, lane B) was a tag-mapping ticket: map `<del>`, `<sub>`/`<sup>` and `<mark>` onto `Run` fields. Round 0 was +91 lines and rendered every TC-MD503 case correctly live. Kit's round-1 review found parser-state edge cases on unbalanced tags, and its finding 8 named the root cause (per-tag counters can't tell which tag an end tag closes) with a general fix: one inline-tag stack. Bar 1's test ("could the Dev pick a reasonable option and ship it?") said yes, so it was a send-back, and `dev.md`'s PR #369 rule told Jay to take the generalized fix.
+
+The stack was a new state model for `html_parser.py`, and every later round rewrote it: +199, +115, +80, +186 and +142 lines. Each round fixed every named finding and introduced new regressions in the same mechanism (content loss found in QA rounds 3 and 6, quadratic time in QA rounds 4 to 6). Each rewrite also pulled more of `develop`'s older malformed-input defects inside the diff, where bar 2 makes them send-backs. The user stepped in after round 6, and the PR was closed on 2026-11-01 in favor of round 0's scope, with the recovery question moved to `docs/decisions/decision-html-error-recovery.md` (#1329). What it was rebuilding by hand was the HTML Standard's tree-construction algorithm.
+
+Two rules came out of it, from Joy's retro: bar 1 now covers a root cause whose fix replaces the mechanism the ticket builds on, and step 3 escalates to the user when two rounds in a row each find a regression the previous fix introduced in the same mechanism. Neither adds a ticket path: the escalation files nothing until the user decides, so `decision-review-finding-ticket-bar.md`'s send-back default stands.
+
 ## `rio.md`
 
 ### Why a non-lane QA role exists

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/docs/design/markdown-support.md

@@ -175,7 +175,10 @@ another registered tool), passing `content_format` through to `_to_doc_requests`
 | `# Heading 1` | `<h1>` | `Heading(level=1)` | HEADING_1 paragraph style |
 | `**bold**` | `<strong>` | `Run(bold=True)` | bold text run |
 | `*italic*` | `<em>` | `Run(italic=True)` | italic text run |
-| `~~strikethrough~~` | none: stays literal text (`_md_to_html` loads no strikethrough extension, and `html_parser.py` maps `<s>`/`<strike>` but not `<del>`) | `Run` with the tildes in its text | literal `~~strikethrough~~` — not implemented, #1077 |
+| `~~strikethrough~~` | `<s>` (GFM strikethrough) | `Run(strikethrough=True)` | struck-through text run (#1077) |
+| `<s>`, `<strike>`, `<del>` (inline HTML) | passed through | `Run(strikethrough=True)` | struck-through text run (#1077) |
+| `<sub>`, `<sup>` (inline HTML) | passed through | `Run(baseline_offset="SUBSCRIPT"/"SUPERSCRIPT")`; the innermost open tag wins | subscript / superscript text run (#1119) |
+| `<mark>` (inline HTML) | passed through | `Run(background_color=` yellow `)` | yellow-highlighted text run (#1119) |
 | `[text](url)` | `<a href=...>` | `Run(link_url=...)` | hyperlink |
 | bare `https://url` | `<a href=...>` (autolink extension) | `Run(link_url=...)` | hyperlink — disable via `autolink_urls=False` |
 | `[![alt](src)](url)` | `<a href=...><img ...></a>` | `Image(link_url=...)` | linked inline image (#977) |

mcp_gee_sweet-0.9.6.dev140/docs/qa/fixtures/md/state/inline-scope.md

@@ -0,0 +1,18 @@
+### IS-01 — strike
+
+~~x~~ and <del>y</del>; <s>h<del>i</del>j</s>k.
+
+### IS-02 — sub and sup
+
+H<sub>2</sub>O, mc<sup>2</sup>. <sup>a<sub>b</sub>c</sup>d
+
+### IS-03 — highlight
+
+A <mark>**hi**</mark> there.
+
+### IS-04 — table cells
+
+| one | two |
+|---|---|
+| <sup>x</sup> ~~y~~ <mark>z</mark> | <mark>w</mark> |
+| plain | plain |

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/docs/qa/tests/docs_markdown.md

@@ -1342,6 +1342,29 @@ What our converter tells the caller about the conversion, and the link targets i
 
 ---
 
+## Inline styles
+
+How our converter (EP-1 to EP-4 and EP-8) renders inline styling tags.
+
+### TC-MD503: Inline strike, sub/sup and highlight ⚠️ destructive
+**Prompt**
+**Playwright: required**
+> Render `docs/qa/fixtures/md/state/inline-scope.md` through EP-1 to EP-4 and EP-8 (#1231). Also run TC-MD116's HT-01, HT-02 and HT-07 through EP-1 to EP-4 and EP-8: #1077's and #1119's done-when. Two runs, with an on-screen check.
+
+**Checks**
+- IS-01: "x" (`~~`) and "y" (`<del>`) struck, " and " plain; "h", "i" and "j" struck (`<del>` inside `<s>`), "k." not.
+- IS-02: the "2" in "H2O" subscript, the "2" in "mc2" superscript, the rest of that text normal; in "abcd", "a" and "c" superscript, "b" subscript, "d" normal.
+- IS-03: "hi" highlighted yellow and bold, the text around it plain.
+- IS-04: in the body row, "x" superscript, "y" struck, "z" highlighted, the spaces between them plain; the second cell's "w" highlighted; the last row's cells plain.
+- `get_doc_as_markdown` on each Doc keeps the strikes as `~~…~~` (it has no syntax for sub/sup or highlight, so those read back as plain text).
+- Malformed input (unclosed or misnested tags) isn't in this case: the new tags behave as `<s>` does there, which the unit tests pin, and browser-matching recovery is #1329.
+
+**Result (2026-11-01, PR #1332 @ eb304470, Kit) ✅ PASS — 10/10 case×EP cells pass (`inline-scope.md` and TC-MD116's HT-01/02/07, each through EP-1 to EP-4 and EP-8), in both runs. Every check was read from the stored text styles (`strikethrough`, `baselineOffset`, `backgroundColor` 1/1/0) and the two runs' read-backs are identical. Seen on screen (Playwright): IS on EP-1 (Run 1) and EP-3 (Run 2), HT on EP-8 (Run 1). `get_doc_as_markdown` gives `~~x~~ and ~~y~~; ~~hij~~k.` and plain sub/sup/highlight text, as expected.**
+
+**Result (2026-11-01, PR #1332 round 2 @ 8fd9f042, after the `develop` merge bringing #1326, Kit) ✅ PASS — 10/10 cells, one run through EP-1 to EP-4 and EP-8. The stored-style read-back is identical to round 1's, so the round-1 on-screen checks still apply; no new screenshots.**
+
+---
+
 ## Known gaps and not-applicable
 
 - **Insert Markdown at an index:** no tool does this (see "Entry points").

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/docs/roadmap.md

@@ -413,7 +413,7 @@ Feature set and fill set by the maintainer 2026-10-18, under the release-scoping
 - [ ] **Bundle:** Markdown/HTML line breaks — one PR closing [#1093](https://github.com/khuisman/mcp-gee-sweet/issues/1093) (soft break), [#1117](https://github.com/khuisman/mcp-gee-sweet/issues/1117) (hard break) and [#1091](https://github.com/khuisman/mcp-gee-sweet/issues/1091) (`<br>` in prose), html_parser cluster; after PR #1228. Bundled 2026-10-25 (maintainer) ([#1230](https://github.com/khuisman/mcp-gee-sweet/issues/1230))
 - [x] A fenced code block or second paragraph inside a list item breaks the list — html_parser cluster; fence half may fold into #1116 ([#1094](https://github.com/khuisman/mcp-gee-sweet/issues/1094)) (PR #1301)
 - [x] Adjacent blocks run together: separate quotes merge, consecutive code blocks merge, quotes have no spacing — lane B, after #1056 ([#1098](https://github.com/khuisman/mcp-gee-sweet/issues/1098)) (PR #1199)
-- [ ] A thematic break (`---`) renders as an empty paragraph — lane A ([#1096](https://github.com/khuisman/mcp-gee-sweet/issues/1096))
+- [x] A thematic break (`---`) renders as an empty paragraph — lane A ([#1096](https://github.com/khuisman/mcp-gee-sweet/issues/1096)) (PR #1326)
 - [ ] GFM table column alignment is ignored ([#1095](https://github.com/khuisman/mcp-gee-sweet/issues/1095))
 - [x] A table takes on the style of the paragraph that follows it ([#1097](https://github.com/khuisman/mcp-gee-sweet/issues/1097)) (PR #1201)
 - [x] Drive's native Markdown import (EP-5 to EP-7) renders differently from our converter — ornithomimus scope: document EP-5 to EP-7 as Drive's engine; routing is #1113 ([#1101](https://github.com/khuisman/mcp-gee-sweet/issues/1101)) (PR #1270)
@@ -575,6 +575,11 @@ Fill candidates moved from v0.9.3 and the decision-needed backlog on 2026-10-18.
 - [ ] `upload_local_file(convert=True)`: a `name=` without an extension errors instead of falling back to `local_path`'s extension. `loud/narrow`; the drop-`.md`-from-the-Doc-name half split out to #1309 ([#1307](https://github.com/khuisman/mcp-gee-sweet/issues/1307))
 - [ ] **Bundle:** `get_doc_as_markdown` list-item export — one PR closing [#1314](https://github.com/khuisman/mcp-gee-sweet/issues/1314) (item under a numbered item indented 2 spaces, short of the parent's content column; found in #1144's live check), [#1323](https://github.com/khuisman/mcp-gee-sweet/issues/1323) (empty first sub-item reads back as a setext underline) and [#1324](https://github.com/khuisman/mcp-gee-sweet/issues/1324) (empty item holding only a block exports with a blank line, splitting the list); the last two from PR #1322's review. All `wrong/narrow`, observed. Bundled 2026-10-31 (maintainer) ([#1325](https://github.com/khuisman/mcp-gee-sweet/issues/1325))
 
+**Triaged in 2026-11-01**
+
+- [ ] An `<hr>` inside a table cell is dropped (raw HTML only; a cell has no paragraph to carry the rule). `wrong/rare`; from PR #1326 ([#1327](https://github.com/khuisman/mcp-gee-sweet/issues/1327))
+- [ ] `html_to_ast` loses content and mis-styles malformed HTML. Pre-existing; the recovery approach (A: HTML5 parser library, B: hand-written model, C: content-loss fixes only) is `decision-needed`, decided when this fill is set. See `docs/decisions/decision-html-error-recovery.md` (PR #1330); #1328 closed into it. From PR #1316 ([#1329](https://github.com/khuisman/mcp-gee-sweet/issues/1329))
+
 ### velociraptor — Parity 1 _(queued, label [`planned: velociraptor`](https://github.com/khuisman/mcp-gee-sweet/issues?q=is%3Aissue+label%3A%22planned%3A+velociraptor%22); gets a number when it goes in flight)_
 
 Queued after _ankylosaurus_ (maintainer, 2026-10-24): the first parity release. The maintainer sets its feature set and locks its fill when it opens.

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/src/mcp_gee_sweet/tools/docs/html_parser.py

@@ -6,7 +6,19 @@ import html as html_module
 from dataclasses import dataclass, replace
 from html.parser import HTMLParser
 
-from .ast import BulletItem, Cell, DocNode, Heading, Image, NamedBlock, Paragraph, Row, Run, Table
+from .ast import (
+    BulletItem,
+    Cell,
+    DocNode,
+    Heading,
+    Image,
+    NamedBlock,
+    Paragraph,
+    RGBColor,
+    Row,
+    Run,
+    Table,
+)
 
 _BLOCK_TAGS = {"h1", "h2", "h3", "h4", "h5", "h6", "p", "li"}
 _NAMED_BLOCK_STYLES = {"title": "TITLE", "subtitle": "SUBTITLE"}
@@ -14,7 +26,12 @@ _HEADING_TAGS = {"h1", "h2", "h3", "h4", "h5", "h6"}
 _INLINE_BOLD = {"b", "strong"}
 _INLINE_ITALIC = {"i", "em"}
 _INLINE_UNDERLINE = {"u"}
-_INLINE_STRIKE = {"s", "strike"}
+_INLINE_STRIKE = {"s", "strike", "del"}  # <del> strikes too (#1077)
+# <sub>/<sup> set the run's baselineOffset; the innermost open one wins (#1119).
+_INLINE_BASELINE = {"sub": "SUBSCRIPT", "sup": "SUPERSCRIPT"}
+# <mark> highlights its text in yellow, a browser's default <mark> color (#1119).
+_INLINE_MARK = "mark"
+_MARK_RGB = (1.0, 1.0, 0.0)
 # HTML void elements: never get a matching close tag from Python's stdlib
 # HTMLParser unless the source text itself self-closes them ("<img ... />"),
 # since HTMLParser has no built-in HTML5 void-element awareness. Excluded from
@@ -262,6 +279,9 @@ class _AstParser(HTMLParser):
         self._italic_depth = 0
         self._underline_depth = 0
         self._strike_depth = 0
+        self._mark_depth = 0
+        # One entry per open <sub>/<sup>, innermost last (#1119).
+        self._baseline_stack: list[str] = []
         self._code_depth = 0  # inline <code> nesting; ignored inside <pre>
         self._link_url: list[str] = []  # stack of href values
         # href values of <a> tags opened with no block or table cell around them.
@@ -321,6 +341,8 @@ class _AstParser(HTMLParser):
             italic=True if self._italic_depth > 0 else None,
             underline=True if self._underline_depth > 0 else None,
             strikethrough=True if self._strike_depth > 0 else None,
+            background_color=RGBColor(*_MARK_RGB) if self._mark_depth > 0 else None,
+            baseline_offset=self._baseline_stack[-1] if self._baseline_stack else None,
             link_url=self._link_url[-1] if self._link_url else None,
             font_family="Courier New" if (self._in_pre or self._code_depth > 0) else None,
         )
@@ -482,6 +504,8 @@ class _AstParser(HTMLParser):
         self._italic_depth = 0
         self._underline_depth = 0
         self._strike_depth = 0
+        self._mark_depth = 0
+        self._baseline_stack = []
         self._code_depth = 0
         self._link_url = []
         # The cleared hrefs' anchors no longer own an entry to pop.
@@ -489,6 +513,17 @@ class _AstParser(HTMLParser):
             None if pushed == "block" else pushed for pushed in self._anchor_pushes
         ]
 
+    def _close_baseline(self, offset: str):
+        """Pop the innermost open <sub>/<sup> of this kind (#1119).
+
+        A close with no open tag of its kind pops nothing, as `<s>`'s depth never
+        goes below 0, so `<sup>a</sub>b` keeps "b" superscript.
+        """
+        for i in range(len(self._baseline_stack) - 1, -1, -1):
+            if self._baseline_stack[i] == offset:
+                del self._baseline_stack[i]
+                return
+
     def _emit_block_node(
         self, tag: str, runs: list[Run | Image], *, preserve_if_empty: bool = False
     ):
@@ -988,6 +1023,10 @@ class _AstParser(HTMLParser):
                 self._underline_depth += 1
             elif tag in _INLINE_STRIKE:
                 self._strike_depth += 1
+            elif tag in _INLINE_BASELINE:
+                self._baseline_stack.append(_INLINE_BASELINE[tag])
+            elif tag == _INLINE_MARK:
+                self._mark_depth += 1
             elif tag == "a":
                 href = attr_dict.get("href", "")
                 if href:
@@ -1229,6 +1268,10 @@ class _AstParser(HTMLParser):
                 self._underline_depth = max(0, self._underline_depth - 1)
             elif tag in _INLINE_STRIKE:
                 self._strike_depth = max(0, self._strike_depth - 1)
+            elif tag in _INLINE_BASELINE:
+                self._close_baseline(_INLINE_BASELINE[tag])
+            elif tag == _INLINE_MARK:
+                self._mark_depth = max(0, self._mark_depth - 1)
             elif tag == "a":
                 self._close_anchor()
             elif tag == "code" and not self._in_pre:

{mcp_gee_sweet-0.9.6.dev136 → mcp_gee_sweet-0.9.6.dev140}/tests/test_docs_core.py

@@ -12,6 +12,7 @@ from mcp_gee_sweet.tools.docs.ast import (
     Image,
     NamedBlock,
     Paragraph,
+    RGBColor,
     Row,
     Run,
     Table,
@@ -431,6 +432,144 @@ class TestHtmlToAst:
         assert nodes[0].style_type == "TITLE"
 
 
+def _styled(runs: list, text: str) -> Run:
+    """The one run whose text is `text`."""
+    (run,) = [r for r in runs if isinstance(r, Run) and r.text == text]
+    return run
+
+
+class TestInlineStrikeBaselineHighlight:
+    """#1231: `<del>`/`~~x~~` strike, `<sub>`/`<sup>` baseline, `<mark>` highlight."""
+
+    @pytest.mark.parametrize("tag", ["s", "strike", "del"])
+    def test_strike_tags(self, tag):
+        nodes = html_to_ast(f"<p>a <{tag}>x</{tag}> b</p>")
+        assert _styled(nodes[0].runs, "x").strikethrough is True
+        assert _styled(nodes[0].runs, " b").strikethrough is None
+
+    def test_markdown_tildes_strike(self):
+        nodes = html_to_ast(_md_to_html("a ~~x~~ b\n"))
+        assert _styled(nodes[0].runs, "x").strikethrough is True
+
+    def test_strike_combines_with_other_styles(self):
+        nodes = html_to_ast(_md_to_html("***~~x~~***\n"))
+        run = _styled(nodes[0].runs, "x")
+        assert (run.bold, run.italic, run.strikethrough) == (True, True, True)
+
+    def test_sub_and_sup(self):
+        nodes = html_to_ast("<p>H<sub>2</sub>O mc<sup>2</sup>.</p>")
+        assert [(r.text, r.baseline_offset) for r in nodes[0].runs] == [
+            ("H", None),
+            ("2", "SUBSCRIPT"),
+            ("O mc", None),
+            ("2", "SUPERSCRIPT"),
+            (".", None),
+        ]
+
+    def test_innermost_baseline_wins(self):
+        nodes = html_to_ast("<p><sup>a<sub>b</sub>c</sup>d</p>")
+        assert [(r.text, r.baseline_offset) for r in nodes[0].runs] == [
+            ("a", "SUPERSCRIPT"),
+            ("b", "SUBSCRIPT"),
+            ("c", "SUPERSCRIPT"),
+            ("d", None),
+        ]
+
+    def test_mark_highlights(self):
+        nodes = html_to_ast("<p>a <mark><b>hi</b></mark> b</p>")
+        run = _styled(nodes[0].runs, "hi")
+        assert run.bold is True
+        bg = run.background_color
+        assert (bg.red, bg.green, bg.blue) == (1.0, 1.0, 0.0)
+        assert _styled(nodes[0].runs, " b").background_color is None
+
+    def test_mark_runs_do_not_share_a_color_object(self):
+        nodes = html_to_ast("<p><mark>a<b>b</b></mark></p>")
+        a, b = nodes[0].runs
+        assert a.background_color == b.background_color
+        assert a.background_color is not b.background_color
+
+    def test_del_inside_s_keeps_strike_after_del_closes(self):
+        nodes = html_to_ast("<p><s>a<del>b</del>c</s>d</p>")
+        assert [(r.text, r.strikethrough) for r in nodes[0].runs] == [
+            ("a", True),
+            ("b", True),
+            ("c", True),
+            ("d", None),
+        ]
+
+    def test_in_table_cell(self):
+        nodes = html_to_ast(_md_to_html("| h |\n|---|\n| <sup>x</sup> ~~y~~ <mark>z</mark> |\n"))
+        children = nodes[0].rows[1].cells[0].children
+        assert _styled(children, "x").baseline_offset == "SUPERSCRIPT"
+        assert _styled(children, "y").strikethrough is True
+        assert _styled(children, "z").background_color is not None
+
+    def test_requests_carry_the_styles(self):
+        requests, _ = _to_doc_requests(
+            "~~s~~ H<sub>2</sub>O x<sup>2</sup> <mark>m</mark>", "markdown"
+        )
+        styles = [r["updateTextStyle"]["textStyle"] for r in requests if "updateTextStyle" in r]
+        assert {"strikethrough": True} in styles
+        assert {"baselineOffset": "SUBSCRIPT"} in styles
+        assert {"baselineOffset": "SUPERSCRIPT"} in styles
+        assert {
+            "backgroundColor": {"color": {"rgbColor": {"red": 1.0, "green": 1.0, "blue": 0.0}}}
+        } in styles
+
+
+# The Run field and value each inline tag sets (#1231).
+_INLINE_TAG_FIELDS = {
+    "s": ("strikethrough", True),
+    "del": ("strikethrough", True),
+    "mark": ("background_color", RGBColor(1.0, 1.0, 0.0)),
+    "sub": ("baseline_offset", "SUBSCRIPT"),
+    "sup": ("baseline_offset", "SUPERSCRIPT"),
+}
+
+
+class TestNewInlineTagsMatchStrikeOnMalformedInput:
+    """#1231's review bar: on malformed input each new tag carries its style exactly
+    where `<s>` carries strikethrough. Making either match a browser is #1329."""
+
+    _INPUTS = (
+        "<p><T>a</p><p>b</p>",
+        "<h2><T>a</h2><p>b</p>",
+        "<ul><li><T>a</li><li>b</li></ul>",
+        "<ul><li><T><p>a</p>b</T></li></ul><p>c</p>",
+        "<table><tr><td><T>a</td><td>b</td></tr></table><p>c</p>",
+        "<table><tr><td><T>a<table><tr><td>x</td></tr></table>b</T></td></tr></table>",
+        "<p><T>a</p></T><p>b</p>",
+        "<p><T>a</b>b</T>c</p>",
+        "<pre><T>a</pre><p>b</p>",
+    )
+
+    @classmethod
+    def _texts(cls, nodes) -> list[Run]:
+        """Every Run in document order, table cells included."""
+        out = []
+        for node in nodes:
+            if isinstance(node, Run):
+                out.append(node)
+            elif isinstance(node, Table):
+                for row in node.rows:
+                    for cell in row.cells:
+                        out.extend(cls._texts(cell.children))
+            elif hasattr(node, "runs"):
+                out.extend(cls._texts(node.runs))
+        return out
+
+    def _styled_texts(self, html: str, tag: str) -> list[tuple[str, bool]]:
+        field, value = _INLINE_TAG_FIELDS[tag]
+        runs = self._texts(html_to_ast(html.replace("T>", f"{tag}>")))
+        return [(r.text, getattr(r, field) == value) for r in runs]
+
+    @pytest.mark.parametrize("tag", ["del", "mark", "sub", "sup"])
+    @pytest.mark.parametrize("html", _INPUTS)
+    def test_same_carry_as_s(self, html, tag):
+        assert self._styled_texts(html, tag) == self._styled_texts(html, "s")
+
+
 class TestLooseListItemKeepsItsBullet:
     """#1111: python-markdown wraps a *loose* list item's text in its own `<p>`
     (so any list with a blank line between items), and the parser treated that