tsugite-cli 0.12.0__tar.gz → 0.12.2__tar.gz

{tsugite_cli-0.12.0 → tsugite_cli-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.12.0
+Version: 0.12.2
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE

{tsugite_cli-0.12.0 → tsugite_cli-0.12.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.12.0"
+version = "0.12.2"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"

{tsugite_cli-0.12.0 → tsugite_cli-0.12.2}/tests/core/test_agent.py

@@ -207,6 +207,35 @@ async def test_agent_format_error_loop_bails_early():
     assert len(agent.memory.steps) <= 3
 
 
+@pytest.mark.asyncio
+async def test_agent_format_error_preserves_content_blocks_on_step():
+    """When the LLM emits content blocks but no code fence, the step should still carry them."""
+
+    agent = TsugiteAgent(
+        model_string="openai:gpt-4o-mini",
+        tools=[],
+        instructions="",
+        max_turns=5,
+    )
+
+    format_error = (
+        "Thought: writing without code\n\n" '<content name="reply">Stopped before creating anything.</content>'
+    )
+    _patch_provider(
+        agent,
+        side_effect=[
+            _mock_response(format_error),
+            _mock_response("```python\nfinal_answer('done')\n```"),
+        ],
+    )
+
+    await agent.run("Some task")
+
+    format_error_step = agent.memory.steps[0]
+    assert format_error_step.code == ""
+    assert format_error_step.content_blocks == {"reply": "Stopped before creating anything."}
+
+
 @pytest.mark.asyncio
 async def test_agent_format_error_resets_on_valid_code():
     """Test format error counter resets when model produces valid code."""
@@ -428,6 +457,54 @@ final_answer(42)
     assert "final_answer(42)" in parsed.code
 
 
+@pytest.mark.asyncio
+async def test_agent_parse_response_prose_only():
+    """Prose without a Thought: prefix or code block should be captured as thought."""
+    agent = TsugiteAgent(
+        model_string="openai:gpt-4o-mini",
+        tools=[],
+        instructions="",
+        max_turns=5,
+    )
+
+    parsed = agent._parse_response_from_text("You're welcome!")
+    assert parsed.thought == "You're welcome!"
+    assert parsed.code == ""
+
+
+@pytest.mark.asyncio
+async def test_agent_parse_response_prose_with_code_no_prefix():
+    """Prose preceding a code block (no Thought: prefix) should still be captured."""
+    agent = TsugiteAgent(
+        model_string="openai:gpt-4o-mini",
+        tools=[],
+        instructions="",
+        max_turns=5,
+    )
+
+    parsed = agent._parse_response_from_text(
+        "Sure thing.\n\n```python\nx = 1\nfinal_answer(x)\n```"
+    )
+    assert parsed.thought == "Sure thing."
+    assert "x = 1" in parsed.code
+    assert "final_answer(x)" in parsed.code
+
+
+@pytest.mark.asyncio
+async def test_agent_parse_response_code_only():
+    """A code-only response (no prose) should still yield empty thought."""
+    agent = TsugiteAgent(
+        model_string="openai:gpt-4o-mini",
+        tools=[],
+        instructions="",
+        max_turns=5,
+    )
+
+    parsed = agent._parse_response_from_text("```python\nfoo()\n```")
+    assert parsed.thought == ""
+    assert parsed.code == "foo()"
+
+
 @pytest.mark.asyncio
 async def test_agent_model_kwargs():
     """Test that model_kwargs are correctly filtered for reasoning models."""
@@ -675,9 +752,9 @@ def test_tool_execution_no_task_warnings():
     )
 
     assert "Task pending" not in filtered_stderr, f"Unexpected Task pending warning:\n{stderr_output}"
-    assert "Task exception was never retrieved" not in filtered_stderr, (
-        f"Unexpected Task exception warning:\n{stderr_output}"
-    )
+    assert (
+        "Task exception was never retrieved" not in filtered_stderr
+    ), f"Unexpected Task exception warning:\n{stderr_output}"
 
 
 def test_tool_exception_propagation_from_async():
@@ -727,6 +804,6 @@ def test_tool_exception_propagation_from_async():
         line for line in stderr_output.split("\n") if "failing_tool" in line or "never retrieved" in line
     )
 
-    assert "exception was never retrieved" not in filtered_stderr.lower(), (
-        f"Exception handling broken:\n{stderr_output}"
-    )
+    assert (
+        "exception was never retrieved" not in filtered_stderr.lower()
+    ), f"Exception handling broken:\n{stderr_output}"

{tsugite_cli-0.12.0 → tsugite_cli-0.12.2}/tests/daemon/test_http_adapter.py

@@ -408,6 +408,93 @@ class TestHistoryEndpoint:
         assert len(turn_data) == 1
         assert "reactions" not in turn_data[0]
 
+    def test_history_detail_attaches_content_blocks_per_message(self, client, test_token, mock_adapter, tmp_path):
+        """When detail=true, each assistant message carries its own content_blocks dict."""
+        from tsugite.history.storage import SessionStorage
+
+        session = mock_adapter.session_store.get_or_create_interactive("web-anonymous", "test-agent")
+        session_id = session.id
+        history_dir = tmp_path / "history"
+        history_dir.mkdir()
+        session_path = history_dir / f"{session_id}.jsonl"
+
+        storage = SessionStorage.create("test-agent", model="test", session_path=session_path)
+        storage.record_turn(
+            messages=[
+                {"role": "user", "content": "go"},
+                {"role": "assistant", "content": "```python\ninspect()\n```"},
+                {
+                    "role": "user",
+                    "content": '<tsugite_execution_result status="success" duration_ms="3"><output>ok</output></tsugite_execution_result>',
+                },
+                {
+                    "role": "assistant",
+                    "content": (
+                        '```python\nfinal_answer(result="done")\n```\n\n'
+                        '<content name="reply">Stopped before creating anything.</content>'
+                    ),
+                },
+            ],
+            final_answer="done",
+        )
+        session_path.rename(history_dir / f"{session_id}.jsonl")
+
+        with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+            resp = client.get(
+                "/api/agents/test-agent/history?user_id=web-anonymous&detail=true",
+                headers={"Authorization": f"Bearer {test_token}"},
+            )
+
+        assert resp.status_code == 200
+        data = resp.json()
+        turn = next(t for t in data["turns"] if t.get("user"))
+
+        # Turn-level aggregate still available for backward compat
+        assert turn.get("content_blocks") == {"reply": "Stopped before creating anything."}
+
+        # Per-message attachment is the new source of truth for rendering
+        assistant_msgs = [m for m in turn["messages"] if m.get("role") == "assistant"]
+        assert assistant_msgs[0].get("content_blocks", {}) == {}
+        assert assistant_msgs[1]["content_blocks"] == {"reply": "Stopped before creating anything."}
+
+    def test_history_detail_preserves_execution_result_with_attributes(
+        self, client, test_token, mock_adapter, tmp_path
+    ):
+        """Execution-result tags with attributes must survive the payload unmodified."""
+        from tsugite.history.storage import SessionStorage
+
+        session = mock_adapter.session_store.get_or_create_interactive("web-anonymous", "test-agent")
+        session_id = session.id
+        history_dir = tmp_path / "history"
+        history_dir.mkdir()
+        session_path = history_dir / f"{session_id}.jsonl"
+
+        observation = (
+            '<tsugite_execution_result status="success" duration_ms="12">'
+            "<output>ran</output></tsugite_execution_result>"
+        )
+        storage = SessionStorage.create("test-agent", model="test", session_path=session_path)
+        storage.record_turn(
+            messages=[
+                {"role": "user", "content": "go"},
+                {"role": "assistant", "content": "```python\nprint('hi')\n```"},
+                {"role": "user", "content": observation},
+            ],
+            final_answer="done",
+        )
+        session_path.rename(history_dir / f"{session_id}.jsonl")
+
+        with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+            resp = client.get(
+                "/api/agents/test-agent/history?user_id=web-anonymous&detail=true",
+                headers={"Authorization": f"Bearer {test_token}"},
+            )
+
+        assert resp.status_code == 200
+        turn = next(t for t in resp.json()["turns"] if t.get("user"))
+        user_msgs = [m for m in turn["messages"] if m.get("role") == "user"]
+        assert any(m.get("content") == observation for m in user_msgs)
+
 
 class TestWebUI:
     def test_serve_ui(self, client):

tsugite_cli-0.12.2/tests/e2e/test_history_code_rendering.py

@@ -0,0 +1,233 @@
+"""E2E tests for step-trace rendering: code truncation, content blocks, and tool results."""
+
+from unittest.mock import patch
+
+from tsugite.history.storage import SessionStorage
+
+
+def _seed_isolated_turn(page, e2e_adapter, e2e_tmp, label, messages, final_answer="done"):
+    """Seed a fresh session (unique user) with one crafted turn and return (history_dir, user_id, session_id)."""
+    unique_user = f"web-user-{label}"
+    session = e2e_adapter.session_store.get_or_create_interactive(unique_user, "test-agent")
+    history_dir = e2e_tmp / f"history-{label}"
+    history_dir.mkdir(exist_ok=True)
+    session_path = history_dir / f"{session.id}.jsonl"
+
+    storage = SessionStorage.create("test-agent", model="test", session_path=session_path)
+    storage.record_turn(messages=messages, final_answer=final_answer)
+    return history_dir, unique_user, session.id
+
+
+def _open_progress_trace(page, user_id, session_id):
+    """Reload as `user_id`, navigate to the session, and expand the progress-done summary."""
+    page.evaluate(f"localStorage.setItem('tsugite_user_id', {user_id!r})")
+    page.goto(page.url.split("#")[0] + f"#conversations?session={session_id}")
+    page.reload()
+    page.wait_for_function("!Alpine.store('app').authRequired", timeout=5000)
+    page.wait_for_function(f"Alpine.store('app').userId === {user_id!r}", timeout=3000)
+    page.wait_for_selector(".msg.user", timeout=5000)
+    page.wait_for_selector(".msg.progress", timeout=5000)
+    summary = page.locator(".msg.progress .tool-summary").first
+    summary.click()
+
+
+def test_history_code_block_not_truncated(authenticated_page, e2e_adapter, e2e_tmp):
+    """Long code blocks must render in full on history reload, no trailing ellipsis."""
+    page = authenticated_page
+
+    long_code = "\n".join([f"line_{i} = 'x' * 80" for i in range(40)])
+    assistant_msg = f"```python\n{long_code}\n```"
+    history_dir, user_id, session_id = _seed_isolated_turn(
+        page,
+        e2e_adapter,
+        e2e_tmp,
+        "truncate",
+        messages=[
+            {"role": "user", "content": "go"},
+            {"role": "assistant", "content": assistant_msg},
+        ],
+    )
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_progress_trace(page, user_id, session_id)
+        code_details = page.locator(".msg.progress .tool-steps li details").first
+        code_details.click()
+        code_text = page.locator(".msg.progress .tool-steps li details pre code").first.text_content()
+
+    assert "line_39 = 'x'" in code_text
+    assert not code_text.endswith("...")
+    assert len(code_text) >= len(long_code)
+
+
+def test_history_content_block_renders_next_to_its_code(authenticated_page, e2e_adapter, e2e_tmp):
+    """Content blocks should appear inline with the assistant message that declared them."""
+    page = authenticated_page
+
+    history_dir, user_id, session_id = _seed_isolated_turn(
+        page,
+        e2e_adapter,
+        e2e_tmp,
+        "inline",
+        messages=[
+            {"role": "user", "content": "go"},
+            {"role": "assistant", "content": "```python\ninvestigate()\n```"},
+            {
+                "role": "user",
+                "content": '<tsugite_execution_result status="success"><output>ok</output></tsugite_execution_result>',
+            },
+            {
+                "role": "assistant",
+                "content": (
+                    '```python\nfinal_answer(result="done")\n```\n\n'
+                    '<content name="reply">Stopped before creating.</content>'
+                ),
+            },
+        ],
+    )
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_progress_trace(page, user_id, session_id)
+
+        steps = page.locator(".msg.progress .tool-steps > li")
+        step_count = steps.count()
+        # Find the index of the content block and the 2nd code step
+        cb_index = None
+        code_indices = []
+        for i in range(step_count):
+            li = steps.nth(i)
+            if li.locator("details.content-block").count() > 0:
+                cb_index = i
+            elif "code" in (li.text_content() or ""):
+                code_indices.append(i)
+
+        assert cb_index is not None, "content block should be rendered"
+        assert len(code_indices) >= 2, "both code steps should render"
+        # content block came from the 2nd code step, so it must appear immediately after it,
+        # not pushed to the end of the trace
+        assert cb_index == code_indices[1] + 1
+
+
+def test_history_tool_result_visible_between_code_steps(authenticated_page, e2e_adapter, e2e_tmp):
+    """tsugite_execution_result with attributes must render a tool_result step."""
+    page = authenticated_page
+
+    observation = (
+        '<tsugite_execution_result status="success" duration_ms="7">'
+        "<output>hello world</output></tsugite_execution_result>"
+    )
+    history_dir, user_id, session_id = _seed_isolated_turn(
+        page,
+        e2e_adapter,
+        e2e_tmp,
+        "toolresult",
+        messages=[
+            {"role": "user", "content": "go"},
+            {"role": "assistant", "content": "```python\nprint('hi')\n```"},
+            {"role": "user", "content": observation},
+            {"role": "assistant", "content": "```python\nfinal_answer('done')\n```"},
+        ],
+    )
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_progress_trace(page, user_id, session_id)
+
+        summaries = page.locator(".msg.progress .tool-steps > li details > summary")
+        labels = [summaries.nth(i).text_content() or "" for i in range(summaries.count())]
+
+    # Two code steps plus a result step in between
+    code_hits = [i for i, s in enumerate(labels) if "code" in s]
+    result_hits = [i for i, s in enumerate(labels) if "result" in s]
+    assert len(code_hits) == 2
+    assert len(result_hits) == 1
+    assert code_hits[0] < result_hits[0] < code_hits[1]
+
+
+def test_history_content_block_survives_no_code_turn(authenticated_page, e2e_adapter, e2e_tmp):
+    """A sub-turn that only emitted content blocks (no code) must still render them after reload."""
+    page = authenticated_page
+
+    history_dir, user_id, session_id = _seed_isolated_turn(
+        page,
+        e2e_adapter,
+        e2e_tmp,
+        "nocode",
+        messages=[
+            {"role": "user", "content": "go"},
+            {
+                "role": "assistant",
+                "content": '<content name="reply">Just a content block, no code.</content>',
+            },
+            {
+                "role": "user",
+                "content": '<tsugite_execution_result status="error"><error>no code</error></tsugite_execution_result>',
+            },
+            {"role": "assistant", "content": "```python\nfinal_answer('done')\n```"},
+        ],
+    )
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_progress_trace(page, user_id, session_id)
+        content_blocks = page.locator(".msg.progress .tool-steps details.content-block")
+        assert content_blocks.count() == 1
+        content_blocks.first.click()
+        pre_text = page.locator(".msg.progress .tool-steps details.content-block pre code").first.text_content()
+        assert "Just a content block, no code." in pre_text
+
+
+def test_history_prose_only_assistant_message_renders(authenticated_page, e2e_adapter, e2e_tmp):
+    """An assistant message that is prose only (no code block) must still render on reload.
+
+    Mirrors the real stored shape from _build_turn_messages: a prose-only step (thought as
+    assistant message), then the format-error observation, then the corrected final_answer
+    code step, its observation, and finally the plain-text result assistant message.
+    """
+    page = authenticated_page
+
+    history_dir, user_id, session_id = _seed_isolated_turn(
+        page,
+        e2e_adapter,
+        e2e_tmp,
+        "prose",
+        messages=[
+            {"role": "user", "content": "thanks"},
+            {"role": "assistant", "content": "You're welcome!"},
+            {
+                "role": "user",
+                "content": (
+                    '<tsugite_execution_result status="error">'
+                    "<error>Format Error: You must respond with a Python code block.</error>"
+                    "</tsugite_execution_result>"
+                ),
+            },
+            {"role": "assistant", "content": '```python\nfinal_answer("You\'re welcome!")\n```'},
+            {
+                "role": "user",
+                "content": (
+                    '<tsugite_execution_result status="success">'
+                    "<output></output></tsugite_execution_result>"
+                ),
+            },
+            {"role": "assistant", "content": "You're welcome!"},
+        ],
+        final_answer="You're welcome!",
+    )
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_progress_trace(page, user_id, session_id)
+
+        summaries = page.locator(".msg.progress .tool-steps > li details > summary")
+        labels = [summaries.nth(i).text_content() or "" for i in range(summaries.count())]
+        thought_hits = [i for i, s in enumerate(labels) if "thought" in s.lower()]
+        assert len(thought_hits) == 1, f"expected exactly one 'thought' step, got summaries: {labels}"
+
+        thought_idx = thought_hits[0]
+        result_hits = [i for i, s in enumerate(labels) if "result" in s.lower()]
+        assert result_hits, f"expected a result step, got summaries: {labels}"
+        assert thought_idx < result_hits[0], (
+            f"thought must appear before the format-error result, got: {labels}"
+        )
+
+        thought_details = page.locator(".msg.progress .tool-steps > li details").nth(thought_idx)
+        thought_details.click()
+        thought_text = thought_details.locator("pre code").first.text_content()
+        assert "You're welcome!" in thought_text

tsugite_cli-0.12.2/tests/e2e/test_markdown_rendering.py

@@ -0,0 +1,205 @@
+"""E2E tests for markdown rendering in `.msg.agent` bubbles.
+
+Written before swapping the hand-rolled renderer in `utils.js` for the `marked`
+library. Regression cases pin pre-existing behavior; the table/alignment/style
+cases drive the new behavior.
+"""
+
+from unittest.mock import patch
+
+from tsugite.history.storage import SessionStorage
+
+
+def _seed_agent_turn(e2e_adapter, e2e_tmp, label, final_answer):
+    """Seed a fresh session whose single turn has the given markdown final_answer."""
+    unique_user = f"md-user-{label}"
+    session = e2e_adapter.session_store.get_or_create_interactive(unique_user, "test-agent")
+    history_dir = e2e_tmp / f"history-{label}"
+    history_dir.mkdir(exist_ok=True)
+    session_path = history_dir / f"{session.id}.jsonl"
+
+    storage = SessionStorage.create("test-agent", model="test", session_path=session_path)
+    storage.record_turn(
+        messages=[{"role": "user", "content": "show"}],
+        final_answer=final_answer,
+    )
+    return history_dir, unique_user, session.id
+
+
+def _open_session(page, user_id, session_id):
+    page.evaluate(f"localStorage.setItem('tsugite_user_id', {user_id!r})")
+    page.goto(page.url.split("#")[0] + f"#conversations?session={session_id}")
+    page.reload()
+    page.wait_for_function("!Alpine.store('app').authRequired", timeout=5000)
+    page.wait_for_function(f"Alpine.store('app').userId === {user_id!r}", timeout=3000)
+    page.wait_for_selector(".msg.agent", timeout=5000)
+
+
+def test_markdown_regression_basic_formatting(authenticated_page, e2e_adapter, e2e_tmp):
+    """All pre-existing markdown features still render after the parser swap."""
+    page = authenticated_page
+
+    md = (
+        "# H1\n"
+        "## H2\n"
+        "### H3\n"
+        "#### H4\n\n"
+        "A paragraph with **bold**, *italic*, and `inline`.\n\n"
+        "- ul item 1\n"
+        "- ul item 2\n\n"
+        "1. ol item 1\n"
+        "2. ol item 2\n\n"
+        "> a blockquote\n\n"
+        "---\n\n"
+        "A [link](https://example.com).\n\n"
+        "```python\nprint('hello')\n```\n"
+    )
+
+    history_dir, user_id, session_id = _seed_agent_turn(e2e_adapter, e2e_tmp, "regression", md)
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_session(page, user_id, session_id)
+        agent = page.locator(".msg.agent").last
+
+        assert agent.locator("h1").count() >= 1
+        assert agent.locator("h2").count() >= 1
+        assert agent.locator("h3").count() >= 1
+        assert agent.locator("h4").count() >= 1
+
+        assert agent.locator("strong").first.text_content() == "bold"
+        assert agent.locator("em").first.text_content() == "italic"
+        assert agent.locator("code").first.text_content() == "inline"
+
+        assert agent.locator("ul > li").count() == 2
+        assert agent.locator("ol > li").count() == 2
+
+        assert agent.locator("blockquote").count() == 1
+        assert agent.locator("hr").count() == 1
+
+        link = agent.locator("a").first
+        assert link.get_attribute("href") == "https://example.com"
+
+        pre_code = agent.locator("pre code")
+        assert pre_code.count() == 1
+        assert "print('hello')" in (pre_code.first.text_content() or "")
+
+
+def test_markdown_gfm_table_renders(authenticated_page, e2e_adapter, e2e_tmp):
+    """Simple GFM table produces <table><thead><th>...<tbody><tr><td>."""
+    page = authenticated_page
+
+    md = (
+        "| Name | Score |\n"
+        "| ---- | ----- |\n"
+        "| Alice | 10 |\n"
+        "| Bob | 20 |\n"
+    )
+
+    history_dir, user_id, session_id = _seed_agent_turn(e2e_adapter, e2e_tmp, "table", md)
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_session(page, user_id, session_id)
+        agent = page.locator(".msg.agent").last
+
+        assert agent.locator("table").count() == 1
+        assert agent.locator("table thead th").count() == 2
+        assert agent.locator("table tbody tr").count() == 2
+        assert (agent.locator("table thead th").first.text_content() or "").strip() == "Name"
+        last_cell = agent.locator("table tbody tr").nth(1).locator("td").last
+        assert (last_cell.text_content() or "").strip() == "20"
+
+
+def test_markdown_gfm_table_alignment(authenticated_page, e2e_adapter, e2e_tmp):
+    """GFM alignment syntax yields text-align on th/td via inline style."""
+    page = authenticated_page
+
+    md = (
+        "| L | C | R |\n"
+        "| :--- | :---: | ---: |\n"
+        "| a | b | c |\n"
+    )
+
+    history_dir, user_id, session_id = _seed_agent_turn(e2e_adapter, e2e_tmp, "align", md)
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_session(page, user_id, session_id)
+        agent = page.locator(".msg.agent").last
+
+        ths = agent.locator("table thead th")
+        tds = agent.locator("table tbody tr").first.locator("td")
+
+        def _align(loc, i):
+            return loc.nth(i).evaluate("el => getComputedStyle(el).textAlign")
+
+        assert _align(ths, 0) in ("left", "start", "-webkit-left")
+        assert _align(ths, 1) in ("center", "-webkit-center")
+        assert _align(ths, 2) in ("right", "end", "-webkit-right")
+        assert _align(tds, 0) in ("left", "start", "-webkit-left")
+        assert _align(tds, 1) in ("center", "-webkit-center")
+        assert _align(tds, 2) in ("right", "end", "-webkit-right")
+
+
+def test_markdown_table_styling(authenticated_page, e2e_adapter, e2e_tmp):
+    """Computed CSS matches the design: no uppercase header, last row no border."""
+    page = authenticated_page
+
+    md = (
+        "| h1 | h2 |\n"
+        "| --- | --- |\n"
+        "| a | b |\n"
+        "| c | d |\n"
+    )
+
+    history_dir, user_id, session_id = _seed_agent_turn(e2e_adapter, e2e_tmp, "style", md)
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_session(page, user_id, session_id)
+        agent = page.locator(".msg.agent").last
+
+        th = agent.locator("table th").first
+        assert th.evaluate("el => getComputedStyle(el).textTransform") == "none"
+        weight = th.evaluate("el => getComputedStyle(el).fontWeight")
+        assert weight in ("600", "700", "bold"), f"unexpected th font-weight: {weight}"
+
+        last_td = agent.locator("table tbody tr").last.locator("td").first
+        border = last_td.evaluate(
+            "el => ({ style: getComputedStyle(el).borderBottomStyle, "
+            "width: getComputedStyle(el).borderBottomWidth })"
+        )
+        assert border["style"] == "none" or border["width"] == "0px", (
+            f"last row should have no bottom border; got {border}"
+        )
+
+
+def test_markdown_wide_table_scrolls_inside_bubble(authenticated_page, e2e_adapter, e2e_tmp):
+    """A wide table scrolls inside the bubble; the page itself does not overflow."""
+    page = authenticated_page
+
+    cols = 8
+    header = "| " + " | ".join(f"col{i}" for i in range(cols)) + " |\n"
+    sep = "| " + " | ".join("---" for _ in range(cols)) + " |\n"
+    row = "| " + " | ".join("very long cell content " * 3 for _ in range(cols)) + " |\n"
+    md = header + sep + row + row
+
+    history_dir, user_id, session_id = _seed_agent_turn(e2e_adapter, e2e_tmp, "wide-table", md)
+
+    page.set_viewport_size({"width": 400, "height": 800})
+
+    with patch("tsugite.daemon.adapters.http.get_history_dir", return_value=history_dir):
+        _open_session(page, user_id, session_id)
+        table = page.locator(".msg.agent table").last
+
+        dims = table.evaluate(
+            "el => ({ scrollWidth: el.scrollWidth, clientWidth: el.clientWidth })"
+        )
+        assert dims["scrollWidth"] > dims["clientWidth"], (
+            f"expected table to be horizontally scrollable; got {dims}"
+        )
+
+        page_dims = page.evaluate(
+            "() => ({ scrollWidth: document.documentElement.scrollWidth, "
+            "clientWidth: document.documentElement.clientWidth })"
+        )
+        assert page_dims["scrollWidth"] <= page_dims["clientWidth"] + 1, (
+            f"page itself should not horizontally scroll; got {page_dims}"
+        )