test: close the gaps the self-review surfaced

Four targeted regression tests, each justified by what it would catch:

1. test_should_swallow_placeholder_clear_error_on_strict_adapter
   (test_thread_faithful.py)
   Closes the meaningful gap: the try/except wrap added in 8dd34d1
   for adapters like Telegram that reject whitespace-only edit_message
   was untested. Mock adapter now raises ValueError when the
   placeholder-clear " " edit comes through; the test asserts (a)
   thread.post() returns a SentMessage instead of propagating, (b)
   exactly one clear attempt was made (no retry loop), and (c) the
   warn log fires with the exact expected message.

   Mutation-tested: narrowing the `except Exception` to
   `except RuntimeError` makes this test fail, confirming the swallow
   path is actually exercised.

2. test_should_rebind_adapter_when_data_is_already_a_channelimpl
   (test_channel_faithful.py)
   Symmetric with the ThreadImpl rebind regression in
   test_serialization.py. ChannelImpl.from_json had the same
   early-return-skips-rebinding bug fix in 1ce9cbf, but no test was
   added for the channel path.

3. test_strips_gchat_custom_link_with_balanced_parens_in_url
   (test_gchat_format_extended.py)
   Pins the plain-text-extraction behavior for URLs containing `)`.
   Worked already because the strip regex stops at `|`/`>`, but a
   future regex tweak could regress this without failing any other
   test.

4. test_gchat_multiple_custom_links_in_one_paragraph
   (test_gchat_format_extended.py)
   Asserts the exact (text, link, text, link, text, link, text)
   sequence for a paragraph with three `<url|text>` tokens. Catches
   off-by-one errors in the placeholder-substitution split logic
   that would otherwise pass single-link tests but produce wrong
   ordering or dropped fragments.

3450 tests pass.

https://claude.ai/code/session_01XE1bMoQ5BjCvgi1iLGKKhG

Author: claude

tests/test_channel_faithful.py

@@ -669,6 +669,30 @@ def test_should_sync_adapter_name_when_explicit_adapter_is_bound(self):
         assert channel.adapter.name == "teams"
         assert channel.to_json()["adapterName"] == "teams"
 
+    def test_should_rebind_adapter_when_data_is_already_a_channelimpl(self):
+        """Idempotent path: when ``data`` is already a ChannelImpl (e.g. revived
+        via ``object_hook``), passing an explicit ``adapter=`` must still rebind
+        it — an early-return shortcut would leave ``_adapter`` stale. Symmetric
+        with the ThreadImpl regression in test_serialization.py."""
+        from chat_sdk.testing import create_mock_adapter as _create
+
+        first = _create("slack")
+        second = _create("teams")
+        original = ChannelImpl.from_json(
+            {
+                "_type": "chat:Channel",
+                "id": "C123",
+                "adapter_name": "slack",
+                "is_dm": False,
+            },
+            first,
+        )
+        rebound = ChannelImpl.from_json(original, second)
+
+        # Rebind applied even though data was already a ChannelImpl:
+        assert rebound.adapter.name == "teams"
+        assert rebound.to_json()["adapterName"] == "teams"
+
 
 # ===========================================================================
 # deriveChannelId (tested in channel.test.ts alongside ChannelImpl)

tests/test_gchat_format_extended.py

@@ -127,6 +127,45 @@ def _walk(node: object) -> None:
         _walk(ast)
         assert link_urls == ["https://example.com"]
 
+    def test_gchat_multiple_custom_links_in_one_paragraph(self):
+        """A single paragraph with multiple `<url|text>` tokens must produce
+        the right number of link nodes in the right order, with the
+        surrounding text correctly split between them. Catches regressions
+        in the placeholder-substitution split logic (off-by-one, dropped
+        text, wrong link order)."""
+        converter = _converter()
+        ast = converter.to_ast(
+            "Contact <mailto:a@example.com|Alice>, <mailto:b@example.com|Bob>, or <https://example.com|the site>."
+        )
+
+        # Collect (text, link) sequence in document order.
+        flat: list[tuple[str, dict | str]] = []
+
+        def _walk(node: object) -> None:
+            if isinstance(node, dict):
+                ntype = node.get("type")
+                if ntype == "text":
+                    flat.append(("text", node.get("value", "")))
+                elif ntype == "link":
+                    children = node.get("children", []) or []
+                    label = "".join(c.get("value", "") for c in children if isinstance(c, dict))
+                    flat.append(("link", {"url": node.get("url", ""), "text": label}))
+                else:
+                    for child in node.get("children", []) or []:
+                        _walk(child)
+
+        _walk(ast)
+
+        assert flat == [
+            ("text", "Contact "),
+            ("link", {"url": "mailto:a@example.com", "text": "Alice"}),
+            ("text", ", "),
+            ("link", {"url": "mailto:b@example.com", "text": "Bob"}),
+            ("text", ", or "),
+            ("link", {"url": "https://example.com", "text": "the site"}),
+            ("text", "."),
+        ]
+
     def test_gchat_custom_link_parses_url_with_balanced_parens(self):
         """URLs containing `(...)` (e.g. Wikipedia-style) must round-trip
         intact. The Markdown parser doesn't implement CommonMark's balanced-
@@ -425,6 +464,17 @@ def test_strips_gchat_custom_link_to_label(self):
             == "See Example Site for details"
         )
 
+    def test_strips_gchat_custom_link_with_balanced_parens_in_url(self):
+        """The plain-text path must also strip cleanly when the URL contains
+        unescaped `)`. Regex stops at `|`/`>`, not `)`, so the label is what
+        survives — but pin it explicitly so a future regex tweak can't
+        regress this without failing the test."""
+        converter = _converter()
+        assert (
+            converter.extract_plain_text("See <https://en.wikipedia.org/wiki/Foo_(bar)|Wiki> for info")
+            == "See Wiki for info"
+        )
+
 
 # ---------------------------------------------------------------------------
 # render_postable

tests/test_thread_faithful.py

@@ -416,6 +416,55 @@ async def test_should_clear_placeholder_when_stream_is_whitespace_only(self):
         assert isinstance(final_edit[2], PostableMarkdown)
         assert final_edit[2].markdown == " "
 
+    # Python-specific regression: when the placeholder-clear edit_message(" ")
+    # raises (e.g. Telegram rejects whitespace-only content with a
+    # ValidationError), `_fallback_stream` must log + swallow the error so
+    # `thread.post()` still returns a SentMessage. The previous test pinned
+    # the happy path; this one pins the defensive try/except added in
+    # commit 8dd34d1 specifically for adapters that reject blank text.
+    @pytest.mark.asyncio
+    async def test_should_swallow_placeholder_clear_error_on_strict_adapter(self):
+        adapter = create_mock_adapter()
+        state = create_mock_state()
+        logger = MockLogger()
+
+        # Telegram's adapter raises ValidationError when text.strip() is empty.
+        # Simulate by intercepting edit_message and raising on the " " payload.
+        clear_attempts: list[PostableMarkdown] = []
+        original_edit = adapter.edit_message
+
+        async def strict_edit(thread_id: str, message_id: str, message: Any) -> RawMessage:
+            if isinstance(message, PostableMarkdown) and not message.markdown.strip():
+                clear_attempts.append(message)
+                raise ValueError("Message text cannot be empty")
+            return await original_edit(thread_id, message_id, message)
+
+        adapter.edit_message = strict_edit  # type: ignore[assignment]
+
+        thread = _make_thread(adapter, state, logger=logger)
+        # Whitespace-only stream triggers the placeholder-clear branch.
+        text_stream = _create_text_stream(["   ", "\n", "  \n"])
+
+        # Must not raise — the SDK should log and fall through to the
+        # upstream "leave placeholder visible" behavior on rejection.
+        sent = await thread.post(text_stream)
+
+        # Placeholder was posted, then exactly one clear edit was attempted
+        # (and rejected). No retry, no infinite loop.
+        assert adapter._post_calls[0] == ("slack:C123:1234.5678", "...")
+        assert len(clear_attempts) == 1
+        assert clear_attempts[0].markdown == " "
+        # The warn log fired with the expected message (asserting the exact
+        # string so a refactor that changes the log can't silently break the
+        # observability contract).
+        assert any(
+            call[0] == "fallbackStream placeholder-clear edit failed; placeholder will remain visible"
+            for call in logger.warn.calls
+        ), [c[0] for c in logger.warn.calls]
+        # Stream contract still holds — we got a SentMessage back.
+        assert sent is not None
+        assert sent.id == "msg-1"
+
     # it("should handle empty stream with disabled placeholder")
     @pytest.mark.asyncio
     async def test_should_handle_empty_stream(self):