mcp-gee-sweet 0.7.0.dev82__tar.gz → 0.7.0.dev84__tar.gz

{mcp_gee_sweet-0.7.0.dev82 → mcp_gee_sweet-0.7.0.dev84}/.claude/commands/merge-pr.md

@@ -10,4 +10,5 @@ Merge the current branch's PR and clean up its worktree. Uses `--admin` only to
 5. Clean up the local worktree:
    - If this session created the current worktree (i.e. it got here via `/start-worktree` or `/next-issue` earlier in this same session), use `ExitWorktree` with `action: "remove"`.
    - Otherwise (worktree predates this session), fall back to manual cleanup from the main checkout: `git worktree remove <path>`, then `git branch -d <branch>`, then `git worktree prune`.
-6. Report a summary: the merge commit, the now-merged PR URL, and confirmation the worktree was removed.
+6. Update the roadmap: from the main checkout on `develop`, `git pull` then check `docs/roadmap.md` for a checkbox line referencing the issue(s) this PR closes (search by issue number). If found, check it off (`- [ ]` → `- [x]`) and append `(PR <number>)` in the existing style (e.g. `(PR #280)`) — see recent `- [x]` entries for the exact convention. If the roadmap has no line item for this issue (not every ticket is roadmap-tracked — chores, follow-up defects, etc.), skip this step silently. Commit directly to `develop` (`docs(roadmap): check off #<issue> (PR <number>)`) and push — `develop`'s branch protection has `enforce_admins: false`, so a direct push by the repo owner is allowed for this kind of small, reversible, docs-only change; don't open a separate PR for it.
+7. Report a summary: the merge commit, the now-merged PR URL, confirmation the worktree was removed, and whether the roadmap was updated.

{mcp_gee_sweet-0.7.0.dev82 → mcp_gee_sweet-0.7.0.dev84}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-gee-sweet
-Version: 0.7.0.dev82
+Version: 0.7.0.dev84
 Summary: MCP server for Google Workspace — Sheets, Drive, Docs, and Calendar. 60+ tools for AI clients.
 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.7.0.dev82 → mcp_gee_sweet-0.7.0.dev84}/docs/design/docs-ast-pipeline.md

@@ -338,3 +338,17 @@ Cells with no `Table` in `children` are still filled in one bulk batch by `_buil
 - Text before, between, and after any number of nested tables in one cell renders in true source order, at any nesting depth.
 - The "one level of nesting only" and "no colspan/rowspan/col_widths inside nested tables" limitations from the original #92 design are otherwise unchanged — this rewrite only touches content ordering, not those structural features.
 - Tested with `tests/test_docs_tables.py`'s `TestFillNestedCellContent`, which drives the real algorithm against a small in-memory Docs-API simulator (`FakeDoc`/`Para`/`TableNode` in that file) that actually applies `insertText`/`insertTable` mutations and re-derives indices — chosen over hand-computed index fixtures because this much re-fetch/recursion logic is easy to get subtly wrong in a way a fixture can't catch (and did, twice, during development).
+
+---
+
+## Nested table colspan/rowspan (#109)
+
+**Date:** 2026-07-08
+
+Nested tables produced a correctly-sized shell but never merged cells with `colspan`/`rowspan` > 1 — `_fill_table_fully` (the per-nested-table fill helper introduced in the rewrite above) only ran the plain-cell bulk fill, with no equivalent of the outer-table merge phase (`fill_tables` phase 2).
+
+Fix: `_fill_table_fully` now checks the nested `ast_table` for any cell with `colspan > 1 or rowspan > 1` and, if found, builds and executes `mergeTableCells` requests via the existing `_build_merge_requests` (unchanged — it already operated generically on any `doc_table`/`ast_table` pair, nested or not) before re-fetching and running the bulk fill. This exactly mirrors `fill_tables`'s own phase 1→2→3 order, just scoped to one nested table.
+
+`col_widths` on nested tables remains unsupported — out of scope for #109, not addressed here.
+
+Tested in `tests/test_docs_tables.py`'s `TestNestedTableMerges`, extending the same `FakeDoc` simulator with a no-op `mergeTableCells` handler (the real Docs API doesn't shift indices or delete content on merge — covered cells stay physical, just skipped by the existing phantom-cell mapping — so the simulator has nothing to mutate; the tests instead assert the merge request's shape and its position in batch order relative to the fill).

{mcp_gee_sweet-0.7.0.dev82 → mcp_gee_sweet-0.7.0.dev84}/docs/qa/tests/docs.md

@@ -1038,6 +1038,25 @@ These test the HTML→AST→Docs API pipeline introduced in Phase 2 (#87). All u
 
 ---
 
+### TC-DOC90: `colspan`/`rowspan` inside a nested table now merges correctly (issue #109) ⚠️ destructive
+
+**Background:** Nested tables produced a correctly-sized shell but silently ignored `colspan`/`rowspan` on their own cells — no `mergeTableCells` request was ever emitted for them, unlike outer-table cells (TC-DOC34/36/37). Fixed by having `_fill_table_fully` run the same merge phase for a nested table's own cells that `fill_tables` already runs for the outer table.
+
+**Prompt**
+> "Write this HTML to doc {DOC_ID}: `<table><tr><td><table><tr><td colspan=\"2\">Header</td></tr><tr><td>A</td><td>B</td></tr></table></td></tr></table>`"
+
+**Checks**
+- Call succeeds with no API error
+- `get_doc_structure` shows the outer table (1 row × 1 col) with cell [0,0] text empty (holds the nested table, not text)
+- 🔍 Visual check: nested table renders with "Header" spanning both columns of the top row, and "A"/"B" as two separate cells in the second row — not four ungrouped cells
+
+**Cleanup:** write fixture content back
+
+**Result (2026-07-09) ✅ PASS**
+`write_doc_content` succeeded. `get_doc_structure` showed the outer table (1 row × 1 col) with cell [0,0] text empty. Playwright screenshot confirmed the nested table rendered with "Header" spanning both columns of the top row and "A"/"B" as two separate cells below — the merge applied correctly. (Unrelated observation: the fixture doc had leftover header/footer text visible in the render and in `get_doc_content`'s plain-text export but not in `get_doc_structure` — headers/footers aren't part of the body map that tool returns; pre-existing fixture-doc state from an earlier header/footer test, untouched by `write_doc_content`, not a regression from this PR.) Fixture content restored per cleanup step.
+
+---
+
 ### TC-DOC52: `get_doc_theme` scans body paragraph styles
 **Note:** `get_doc_theme` reads explicit per-paragraph and per-run styles from the document body. It returns data for AI-generated docs (where styles are set explicitly on runs); for standard docs whose styles are fully inherited from named style defaults it returns an empty dict.
 

{mcp_gee_sweet-0.7.0.dev82 → mcp_gee_sweet-0.7.0.dev84}/docs/roadmap.md

@@ -95,8 +95,8 @@ No new tools. Stabilize on what Tier 1 shipped before starting Tier 2 feature wo
 ### Tier 2 — Useful for structured work, plus defects surfaced since v0.8.1 _(target: [v0.9.0](https://github.com/khuisman/mcp-gee-sweet/issues?q=is%3Aissue+label%3Av0.9))_
 
 **Defects** _(found after v0.8.1 shipped; too late for that release, don't warrant a standalone patch)_
-- [ ] Bare URLs in markdown content aren't autolinked — Python-Markdown's built-in autolink only fires on `<https://...>` or `[text](url)`, not a bare URL ([#248](https://github.com/khuisman/mcp-gee-sweet/issues/248))
-- [ ] `zip(doc_tables, ast_tables)` in `emitter.py` silently cross-pairs tables when one is skipped (zero-row/zero-col table), misapplying fill/merge/style requests to the wrong table — surfaced during #276's review ([#277](https://github.com/khuisman/mcp-gee-sweet/issues/277))
+- [x] Bare URLs in markdown content aren't autolinked — Python-Markdown's built-in autolink only fires on `<https://...>` or `[text](url)`, not a bare URL (PR #265) ([#248](https://github.com/khuisman/mcp-gee-sweet/issues/248))
+- [x] `zip(doc_tables, ast_tables)` in `emitter.py` silently cross-pairs tables when one is skipped (zero-row/zero-col table), misapplying fill/merge/style requests to the wrong table — surfaced during #276's review (PR #282) ([#277](https://github.com/khuisman/mcp-gee-sweet/issues/277))
 
 **Sheets**
 - [ ] `update_borders` — border style, width, color on a range ([#122](https://github.com/khuisman/mcp-gee-sweet/issues/122)) _(freema/mcp-gsheets)_
@@ -106,11 +106,11 @@ No new tools. Stabilize on what Tier 1 shipped before starting Tier 2 feature wo
 - [ ] `update_sheet_properties` — tab color, hide/show gridlines ([#126](https://github.com/khuisman/mcp-gee-sweet/issues/126)) _(freema/mcp-gsheets)_
 - [ ] `duplicate_sheet` — copy a sheet within the same spreadsheet ([#127](https://github.com/khuisman/mcp-gee-sweet/issues/127))
 - [ ] Partial (rich-text) hyperlinks in `update_cells` ([#89](https://github.com/khuisman/mcp-gee-sweet/issues/89))
-- [ ] `import_csv_to_sheet` — populate a spreadsheet from a local CSV file ([#187](https://github.com/khuisman/mcp-gee-sweet/issues/187))
+- [x] `import_csv_to_sheet` — populate a spreadsheet from a local CSV file (PR #272) ([#187](https://github.com/khuisman/mcp-gee-sweet/issues/187))
 
 **Calendar**
-- [ ] `create_calendar` / `update_calendar` / `delete_calendar` — calendar lifecycle ([#156](https://github.com/khuisman/mcp-gee-sweet/issues/156))
-- [ ] `add_calendar_to_list` / `remove_calendar_from_list` — subscribe/unsubscribe ([#157](https://github.com/khuisman/mcp-gee-sweet/issues/157))
+- [x] `create_calendar` / `update_calendar` / `delete_calendar` — calendar lifecycle (PR #266) ([#156](https://github.com/khuisman/mcp-gee-sweet/issues/156))
+- [x] `add_calendar_to_list` / `remove_calendar_from_list` — subscribe/unsubscribe (PR #269) ([#157](https://github.com/khuisman/mcp-gee-sweet/issues/157))
 - [ ] Calendar ACL — share a calendar with users or groups ([#158](https://github.com/khuisman/mcp-gee-sweet/issues/158))
 - [ ] `list_all_events` — query all subscribed calendars in parallel _(decision needed — also tracked in Decisions Needed)_ ([#194](https://github.com/khuisman/mcp-gee-sweet/issues/194))
 
@@ -120,7 +120,7 @@ No new tools. Stabilize on what Tier 1 shipped before starting Tier 2 feature wo
 - [ ] Comments API — list, add, resolve doc comments ([#151](https://github.com/khuisman/mcp-gee-sweet/issues/151))
 - [ ] `create_named_range` / `create_bookmark` — anchor points for internal links ([#152](https://github.com/khuisman/mcp-gee-sweet/issues/152))
 - [ ] Rowspan emitter — AST `Cell.rowspan` field exists but emitter does not yet merge rows ([#195](https://github.com/khuisman/mcp-gee-sweet/issues/195))
-- [ ] Warn/error on mixed text + nested table in same cell ([#108](https://github.com/khuisman/mcp-gee-sweet/issues/108))
+- [x] Warn/error on mixed text + nested table in same cell — shipped as the fuller `Cell.children: list[Run | Table]` ordered model, also fixing trailing-text-after-nested-table ordering ([#275](https://github.com/khuisman/mcp-gee-sweet/issues/275)) in the same PR (PR #276) ([#108](https://github.com/khuisman/mcp-gee-sweet/issues/108))
 - [ ] colspan/rowspan inside nested tables ([#109](https://github.com/khuisman/mcp-gee-sweet/issues/109))
 - [ ] `find_in_doc` — search doc text and return match locations, parallel to `find_in_spreadsheet`; removes the manual index math currently needed to retrofit links (or any style) onto text already in a doc, raised while fixing #248 ([#262](https://github.com/khuisman/mcp-gee-sweet/issues/262))
 
@@ -135,7 +135,8 @@ No new tools. Stabilize on what Tier 1 shipped before starting Tier 2 feature wo
 - [x] Drive Activity API — file change history ([#72](https://github.com/khuisman/mcp-gee-sweet/issues/72))
 
 **Infrastructure**
-- [ ] Cache reliability & configurability — runtime-configurable TTL, smarter invalidation for shared files ([#99](https://github.com/khuisman/mcp-gee-sweet/issues/99)); harden concurrent-session access — fail-open on cache read/write errors, `busy_timeout` ([#234](https://github.com/khuisman/mcp-gee-sweet/issues/234))
+- [x] Harden concurrent-session access — fail-open on cache read/write errors, `busy_timeout` (PR #280) ([#234](https://github.com/khuisman/mcp-gee-sweet/issues/234))
+- [x] Cache reliability & configurability — runtime-configurable TTL, smarter invalidation for shared files (PR #284) ([#99](https://github.com/khuisman/mcp-gee-sweet/issues/99))
 - [ ] Async tool execution — `asyncio.gather()` for parallel Google API calls; establishes the project's parallel-call pattern, which [#194](https://github.com/khuisman/mcp-gee-sweet/issues/194) should reuse rather than introducing its own `ThreadPoolExecutor` ([#183](https://github.com/khuisman/mcp-gee-sweet/issues/183))
 
 **Documentation**

{mcp_gee_sweet-0.7.0.dev82 → mcp_gee_sweet-0.7.0.dev84}/src/mcp_gee_sweet/tools/docs/emitter.py

@@ -199,24 +199,20 @@ def fill_tables(docs_service, doc_id: str, tables: list[Table]) -> None:
       3. Fill plain cells (no nested table) — insertText + updateTextStyle, high→low
       4. Fill cells with a nested table, segment by segment (see
          _fill_nested_cell_content) — text and tables in true source order,
-         recursing into any depth of further nesting
+         recursing into any depth of further nesting. Each nested table's own
+         merges are handled by _fill_table_fully, mirroring phase 2 above (#109).
       5. Emit updateTableColumnProperties for tables with col_widths
       6. If any cell has Phase 3 style fields: emit updateTableCellStyle
 
-    Nested table limitations: no colspan/rowspan or col_widths inside nested
-    tables. Text sharing a cell with one or more nested tables (#108, #275) is
-    fully supported — each run of text and each nested table renders in the
-    same order it appeared in the source, at any nesting depth.
+    Nested table limitations: no col_widths inside nested tables. colspan/
+    rowspan (#109) and text sharing a cell with one or more nested tables
+    (#108, #275) are both fully supported, at any nesting depth — each run of
+    text, merge, and nested table renders in the same order and shape it had
+    in the source.
     """
     if not tables:
         return
 
-    has_merges = any(
-        cell.colspan > 1 or cell.rowspan > 1
-        for table in tables
-        for row in table.rows
-        for cell in row.cells
-    )
     has_nested = any(
         any(isinstance(child, Table) for child in cell.children)
         for table in tables
@@ -238,14 +234,7 @@ def fill_tables(docs_service, doc_id: str, tables: list[Table]) -> None:
     doc_tables = _top_level_tables(live_doc)
 
     # Step 2: outer merges
-    if has_merges:
-        merge_requests = _build_merge_requests(doc_tables, tables)
-        if merge_requests:
-            docs_service.documents().batchUpdate(
-                documentId=doc_id, body={"requests": merge_requests}
-            ).execute()
-            live_doc = docs_service.documents().get(documentId=doc_id).execute()
-            doc_tables = _top_level_tables(live_doc)
+    doc_tables = _apply_merges(docs_service, doc_id, doc_tables, tables, _top_level_tables)
 
     # Step 3: fill plain cells (no nested table) in one bulk batch
     fill_requests = _build_fill_requests(doc_tables, tables)
@@ -552,12 +541,13 @@ def _fill_children_recursive(
 
 
 def _fill_table_fully(docs_service, doc_id: str, resolve, ast_table: Table) -> None:
-    """Fill one (typically just-inserted) table's cells: plain cells in bulk,
-    cells with a further nested table via the recursive round algorithm.
+    """Fill one (typically just-inserted) table's cells: merges first, then
+    plain cells in bulk, then cells with a further nested table via the
+    recursive round algorithm.
 
     Every nested table needs this — not just ones with further nesting — since
-    a nested table's own plain-text cells are never touched by the top-level
-    _build_fill_requests bulk pass (that only sees the outer tables list).
+    a nested table's own plain-text cells (and merges) are never touched by the
+    top-level fill_tables passes (those only see the outer tables list).
     """
     live_doc = docs_service.documents().get(documentId=doc_id).execute()
     doc_tables = resolve(live_doc)
@@ -569,6 +559,8 @@ def _fill_table_fully(docs_service, doc_id: str, resolve, ast_table: Table) -> N
         )
         return
 
+    doc_tables = _apply_merges(docs_service, doc_id, doc_tables, [ast_table], resolve)
+
     fill_requests = _build_fill_requests(doc_tables, [ast_table])
     if fill_requests:
         docs_service.documents().batchUpdate(
@@ -582,6 +574,48 @@ def _fill_table_fully(docs_service, doc_id: str, resolve, ast_table: Table) -> N
         _fill_children_recursive(docs_service, doc_id, resolve, [ast_table], _doc_tables=doc_tables)
 
 
+def _apply_merges(
+    docs_service, doc_id: str, doc_tables: list[dict], ast_tables: list[Table], resolve
+) -> list[dict]:
+    """Emit mergeTableCells for any ast_tables cell with colspan/rowspan > 1,
+    re-fetch, and return the updated doc_tables — or doc_tables unchanged if
+    nothing needed merging.
+
+    mergeTableCells doesn't shift character indices or delete content (covered
+    cells remain physical entries in the doc tree), so doc_tables — already
+    successfully resolved by the caller — is expected to resolve again right
+    after. If it doesn't, the live doc no longer matches the model used to
+    build the merge requests just executed; silently returning here would mean
+    every already-merged table renders with zero content and no operator-
+    visible signal, so raise instead of skipping the fill.
+    """
+    has_merges = any(
+        cell.colspan > 1 or cell.rowspan > 1
+        for table in ast_tables
+        for row in table.rows
+        for cell in row.cells
+    )
+    if not has_merges:
+        return doc_tables
+
+    merge_requests = _build_merge_requests(doc_tables, ast_tables)
+    if not merge_requests:
+        return doc_tables
+
+    docs_service.documents().batchUpdate(
+        documentId=doc_id, body={"requests": merge_requests}
+    ).execute()
+    live_doc = docs_service.documents().get(documentId=doc_id).execute()
+    updated = resolve(live_doc)
+    if len(updated) < len(ast_tables) or any(t is None for t in updated):
+        raise RuntimeError(
+            f"_apply_merges: table(s) vanished from doc {doc_id} immediately after "
+            "mergeTableCells, which does not itself shift indices or delete content — "
+            "refusing to silently skip the fill and leave the merged table empty."
+        )
+    return updated
+
+
 def _build_phantom_set(ast_table: Table) -> set[tuple[int, int]]:
     """Return (row, col) logical positions covered by rowspan from a cell in an earlier row."""
     phantom: set[tuple[int, int]] = set()

{mcp_gee_sweet-0.7.0.dev82 → mcp_gee_sweet-0.7.0.dev84}/tests/test_docs_tables.py

@@ -2,6 +2,8 @@
 
 from unittest.mock import MagicMock
 
+import pytest
+
 from mcp_gee_sweet.tools import docs as docs_module
 from mcp_gee_sweet.tools.docs.ast import (
     Cell,
@@ -11,6 +13,7 @@ from mcp_gee_sweet.tools.docs.ast import (
 )
 from mcp_gee_sweet.tools.docs.content import _html_to_doc_requests
 from mcp_gee_sweet.tools.docs.emitter import (
+    _apply_merges,
     _ast_cell_to_doc_cell,
     _build_fill_requests,
     _cell_para_start_for_cursor,
@@ -590,6 +593,12 @@ class FakeDoc:
             elif "insertTable" in req:
                 it = req["insertTable"]
                 self.insert_table(it["location"]["index"], it["rows"], it["columns"])
+            elif "mergeTableCells" in req:
+                # Real mergeTableCells doesn't delete content or shift indices —
+                # covered cells remain physical entries (see _physical_to_ast_indices) —
+                # so this simulator has nothing to mutate; the fill step already knows
+                # to skip covered cells based on the AST's own colspan/rowspan.
+                pass
 
     def get(self) -> dict:
         idx = 0
@@ -723,6 +732,117 @@ class TestFillNestedCellContent:
         assert doc.describe_cell(0, 0, 0) == ["Para:After"]
 
 
+# ---------------------------------------------------------------------------
+# #109 — colspan/rowspan on cells inside a nested table
+# ---------------------------------------------------------------------------
+
+
+class TestNestedTableMerges:
+    """A nested table's own cells may have colspan/rowspan > 1 — _fill_table_fully
+    must emit mergeTableCells for them, mirroring the outer-table merge phase in
+    fill_tables(), instead of silently leaving an unmerged shell (#109)."""
+
+    def _run(self, outer_cell: Cell) -> tuple[FakeDoc, list[list[dict]]]:
+        doc = FakeDoc()
+        doc.content = [TableNode(1, 1)]
+        ast_table = Table(rows=[Row(cells=[outer_cell])])
+
+        svc = MagicMock()
+        svc.documents.return_value.get.return_value.execute.side_effect = lambda: doc.get()
+
+        batches: list[list[dict]] = []
+
+        def do_batch(documentId, body):
+            batches.append(body["requests"])
+            doc.batch_update(body["requests"])
+            m = MagicMock()
+            m.execute.return_value = {}
+            return m
+
+        svc.documents.return_value.batchUpdate.side_effect = do_batch
+        _fill_nested_cell_content(svc, "doc1", [ast_table])
+        return doc, batches
+
+    def test_colspan_merge_emitted_and_only_anchor_cell_filled(self):
+        inner = _table(_row(_cell("Header", colspan=2)))
+        doc, batches = self._run(Cell(children=[inner]))
+
+        merge_reqs = [r for batch in batches for r in batch if "mergeTableCells" in r]
+        assert len(merge_reqs) == 1
+        tr = merge_reqs[0]["mergeTableCells"]["tableRange"]
+        assert tr["rowSpan"] == 1
+        assert tr["columnSpan"] == 2
+
+        nested_table = next(
+            c for c in doc.content[0].rows[0][0].content if isinstance(c, TableNode)
+        )
+        assert nested_table.rows[0][0].content[0].text == "Header"
+        assert nested_table.rows[0][1].content[0].text == ""  # colspan phantom — untouched
+
+    def test_rowspan_merge_emitted_and_only_anchor_cell_filled(self):
+        inner = _table(_row(_cell("A", rowspan=2), _cell("B")), _row(_cell("C")))
+        doc, batches = self._run(Cell(children=[inner]))
+
+        merge_reqs = [r for batch in batches for r in batch if "mergeTableCells" in r]
+        assert len(merge_reqs) == 1
+        tr = merge_reqs[0]["mergeTableCells"]["tableRange"]
+        assert tr["rowSpan"] == 2
+        assert tr["columnSpan"] == 1
+
+        nested_table = next(
+            c for c in doc.content[0].rows[0][0].content if isinstance(c, TableNode)
+        )
+        assert nested_table.rows[0][0].content[0].text == "A"
+        assert nested_table.rows[0][1].content[0].text == "B"
+        assert nested_table.rows[1][0].content[0].text == ""  # rowspan phantom — untouched
+        assert nested_table.rows[1][1].content[0].text == "C"
+
+    def test_no_merge_call_when_nested_table_has_no_spans(self):
+        inner = _table(_row(_cell("A"), _cell("B")))
+        _doc, batches = self._run(Cell(children=[inner]))
+        assert not any("mergeTableCells" in r for batch in batches for r in batch)
+
+    def test_merge_precedes_fill_in_batch_order(self):
+        # Pin the documented phase order in _fill_table_fully — merge runs (and
+        # is re-fetched) before the bulk text fill, mirroring fill_tables()'s own
+        # outer-table phase order. (The batch preceding both is the round
+        # algorithm's own insertTable for the nested table's shell.)
+        inner = _table(_row(_cell("Header", colspan=2)))
+        _doc, batches = self._run(Cell(children=[inner]))
+
+        merge_idx = next(
+            i for i, batch in enumerate(batches) if any("mergeTableCells" in r for r in batch)
+        )
+        fill_idx = next(
+            i for i, batch in enumerate(batches) if any("insertText" in r for r in batch)
+        )
+        assert merge_idx < fill_idx
+
+    def test_raises_when_table_vanishes_from_resolve_after_merge(self):
+        # mergeTableCells doesn't shift indices or delete content, so a resolve
+        # failure right after one is an anomaly, not a normal "not there yet"
+        # case — it must surface loudly rather than silently drop the fill and
+        # leave the just-merged table empty with no operator-visible signal.
+        ast_table = _table(_row(_cell("Header", colspan=2)))
+        doc_table = {
+            "tableRows": [
+                {
+                    "tableCells": [
+                        {"startIndex": 3, "content": [{"startIndex": 4}]},
+                        {"startIndex": 6, "content": [{"startIndex": 7}]},
+                    ]
+                }
+            ]
+        }
+
+        svc = MagicMock()
+        svc.documents.return_value.batchUpdate.return_value.execute.return_value = {}
+        svc.documents.return_value.get.return_value.execute.return_value = {"body": {"content": []}}
+
+        with pytest.raises(RuntimeError, match="vanished"):
+            _apply_merges(svc, "doc1", [doc_table], [ast_table], lambda _live_doc: [])
+
+
 # ---------------------------------------------------------------------------
 # #277 — a skipped degenerate table must not desync doc_tables/ast_tables
 # ---------------------------------------------------------------------------