fix: address CodeRabbit review findings on web allowlist and markdown

- config.py: reject `allowed_domains` entries that are dots-only (would
  normalize to empty → silently unrestricted) and any entry containing
  whitespace (newlines previously slipped past the space/tab check).
- tools/web/_allowlist.py: strip trailing dots when normalizing entries so
  `example.com.` matches `example.com` hosts.
- tools/web/search.py + ui/shell/tool_renderers/web.py: emit a structured
  `returned_results=0` signal on the all-filtered path and have the search
  renderer prefer it, so an all-filtered result reports "0 results" instead of
  misreading the prose notice as one result.
- ui/shell/components/markdown.py: prefix rebuilt table rows with the captured
  delimiter-line indent so normalization never promotes an indented table to
  top level (defensive; the guard already bails on non-empty indent today).
- agents/default/system.md: reword the code-fence guidance to use inline code
  spans for language names (markdownlint MD038).
- Tests: reject `.`/whitespace allowlist entries, trailing-dot entry matching,
  and an all-results-filtered renderer regression; refresh the default-agent
  system-prompt snapshot.

Author: elkaix

src/pythinker_code/agents/default/system.md

@@ -267,7 +267,7 @@ Your responses are rendered as Markdown in a terminal. Emit well-formed Markdown
 
 - **Tables:** put the header row on its own line, the `|---|---|` delimiter row on the immediately following line (no blank line between them), and one row per line. Never glue a table onto adjacent prose (e.g. `Findings| Col |`) and never cram multiple rows onto one line. Leave a blank line before and after the table.
 - Prefer a short bullet list over a table when there are only a few items or any cell is long; reserve tables for genuinely tabular data with short cells.
-- **Code fences are for code only.** Use triple-backtick blocks (tagged with the language, e.g. ```python, ```toml) solely for source, config, or commands — one snippet per block. Never wrap a prose report, finding list, checklist, or ASCII box in a fence to align or frame it; write it as normal Markdown (headings, bullets, tables) so it renders cleanly.
+- **Code fences are for code only.** Use triple-backtick blocks tagged with a language (for example, `python` or `toml`) solely for source, config, or commands — one snippet per block. Never wrap a prose report, finding list, checklist, or ASCII box in a fence to align or frame it; write it as normal Markdown (headings, bullets, tables) so it renders cleanly.
 - **Status icons sparingly.** A check/cross/dot can mark a single headline result, but do not prefix every line with one. Use plain words for severity and outcomes (e.g. `High`, `PASS`, `0 findings`). The terminal renders icons as calm monochrome glyphs only outside code fences — another reason not to box reports.
 
 # Ultimate Reminders

src/pythinker_code/config.py

@@ -240,7 +240,12 @@ def _validate_allowed_domains(cls, value: list[str] | None) -> list[str] | None:
                     "Remove it, or omit allowed_domains entirely to leave web access "
                     "unrestricted."
                 )
-            if any(char in cleaned for char in "/: \t"):
+            if cleaned.strip(".") == "":
+                raise ValueError(
+                    f"Invalid allowed_domains entry {entry!r}: hostname must contain "
+                    "domain labels, not only dots."
+                )
+            if any(char.isspace() for char in cleaned) or any(char in cleaned for char in "/:"):
                 raise ValueError(
                     f"Invalid allowed_domains entry {entry!r}: use a bare hostname "
                     "like 'example.com', not a URL, path, or host:port."

src/pythinker_code/tools/web/_allowlist.py

@@ -4,7 +4,7 @@
 
 
 def _normalize(entry: str) -> str:
-    return entry.strip().lstrip(".").lower()
+    return entry.strip().strip(".").lower()
 
 
 def host_in_allowlist(host: str | None, allowed: list[str] | None) -> bool:

src/pythinker_code/tools/web/search.py

@@ -159,6 +159,9 @@ async def __call__(self, params: Params) -> ToolReturnValue:
             if dropped:
                 builder.extras(allowlist_filtered=dropped)
             if not results:
+                # Structured zero-result signal so the renderer reports "0
+                # results" instead of misreading the prose below as one result.
+                builder.extras(returned_results=0)
                 return builder.ok(
                     f"All {dropped} search result(s) were outside the configured "
                     "web allowlist and have been omitted.",

src/pythinker_code/ui/shell/components/markdown.py

@@ -404,8 +404,11 @@ def _normalize_table_block(text: str) -> str:
         tail = text[match.end() :]
 
         # The delimiter must start its own line — guards against inline ``|-|``.
-        line_prefix = head[head.rfind("\n") + 1 :]
-        if n_cols < 2 or line_prefix.strip() != "":
+        # Any leading whitespace is the table's indentation (e.g. nested under a
+        # list item); preserve it when re-emitting so we never promote an
+        # indented table to top level.
+        indent = head[head.rfind("\n") + 1 :]
+        if n_cols < 2 or indent.strip() != "":
             out += text[: match.end()]
             text = tail
             continue
@@ -457,10 +460,10 @@ def _normalize_table_block(text: str) -> str:
         # paragraph), so ensure one before emitting the header.
         if out and not out.endswith("\n\n"):
             out += "\n" if out.endswith("\n") else "\n\n"
-        out += "| " + " | ".join(header_cells) + " |\n"
-        out += "| " + " | ".join(markers) + " |\n"
+        out += f"{indent}| " + " | ".join(header_cells) + " |\n"
+        out += f"{indent}| " + " | ".join(markers) + " |\n"
         for row in data_rows:
-            out += "| " + " | ".join(row) + " |\n"
+            out += f"{indent}| " + " | ".join(row) + " |\n"
 
         remainder = "\n".join(tail_lines[consumed:])
         if not remainder.strip():

src/pythinker_code/ui/shell/tool_renderers/web.py

@@ -185,6 +185,14 @@ def _allowlist_filtered_count(result: ToolResultPayload) -> int:
     return 0
 
 
+def _explicit_result_count(result: ToolResultPayload) -> int | None:
+    """The tool's own result count, if it emitted one (preferred over text)."""
+    extras_raw = result.details.get("extras")
+    extras = cast("dict[str, object]", extras_raw) if isinstance(extras_raw, dict) else {}
+    value = extras.get("returned_results")
+    return value if isinstance(value, int) and value >= 0 else None
+
+
 def _render_search_result(
     ctx: ToolRenderContext, result: ToolResultPayload
 ) -> RenderableType | None:
@@ -203,7 +211,8 @@ def _render_search_result(
             return Group(body, fg("muted", f"... ({remaining} more lines, ctrl+o to expand)"))
         return body
 
-    count = _search_result_count(result.text)
+    explicit = _explicit_result_count(result)
+    count = explicit if explicit is not None else _search_result_count(result.text)
     summary = Text()
     summary.append("Found ", style=tui_rich_style("tool_output"))
     summary.append(str(count), style=tui_rich_style("tool_title"))

tests/core/test_default_agent.py

@@ -275,7 +275,7 @@ async def test_default_agent(runtime: Runtime):
 
 - **Tables:** put the header row on its own line, the `|---|---|` delimiter row on the immediately following line (no blank line between them), and one row per line. Never glue a table onto adjacent prose (e.g. `Findings| Col |`) and never cram multiple rows onto one line. Leave a blank line before and after the table.
 - Prefer a short bullet list over a table when there are only a few items or any cell is long; reserve tables for genuinely tabular data with short cells.
-- **Code fences are for code only.** Use triple-backtick blocks (tagged with the language, e.g. ```python, ```toml) solely for source, config, or commands — one snippet per block. Never wrap a prose report, finding list, checklist, or ASCII box in a fence to align or frame it; write it as normal Markdown (headings, bullets, tables) so it renders cleanly.
+- **Code fences are for code only.** Use triple-backtick blocks tagged with a language (for example, `python` or `toml`) solely for source, config, or commands — one snippet per block. Never wrap a prose report, finding list, checklist, or ASCII box in a fence to align or frame it; write it as normal Markdown (headings, bullets, tables) so it renders cleanly.
 - **Status icons sparingly.** A check/cross/dot can mark a single headline result, but do not prefix every line with one. Use plain words for severity and outcomes (e.g. `High`, `PASS`, `0 findings`). The terminal renders icons as calm monochrome glyphs only outside code fences — another reason not to box reports.
 
 # Ultimate Reminders

tests/tools/test_web_allowlist.py

@@ -30,6 +30,9 @@
         ("DOCS.Example.COM", ["  .Example.com "], True),
         # Trailing-dot FQDN host.
         ("docs.example.com.", ["example.com"], True),
+        # Trailing-dot allowlist *entry* matches a plain host.
+        ("docs.example.com", ["example.com."], True),
+        ("example.com", ["example.com."], True),
         # Multiple entries: match any.
         ("foo.org", ["example.com", "foo.org"], True),
         # Empty / None host with a non-empty allowlist is rejected.
@@ -53,6 +56,9 @@ def test_web_config_accepts_bare_hostnames() -> None:
         "example.com/path",  # path
         "example.com:8080",  # port
         "two words.com",  # whitespace
+        ".",  # dots-only would normalize to empty (unrestricted) — reject
+        "..",  # dots-only
+        "ex\nample.com",  # newline whitespace must be rejected too
     ],
 )
 def test_web_config_rejects_malformed_entries(bad_entry: str) -> None:

tests/ui_and_conv/test_tui_card_tool_renderers.py

@@ -928,6 +928,23 @@ def test_search_no_allowlist_indicator_when_not_filtered():
     assert "filtered to allowlist" not in rendered
 
 
+def test_search_all_results_filtered_reports_zero():
+    # When every result is dropped by the allowlist, SearchWeb emits prose plus a
+    # structured returned_results=0 signal; the renderer must prefer that count
+    # instead of misreading the one-line prose as a single result.
+    rendered = _render(
+        "SearchWeb",
+        {"query": "python"},
+        output=(
+            "All 2 search result(s) were outside the configured web allowlist "
+            "and have been omitted."
+        ),
+        details={"extras": {"allowlist_filtered": 2, "returned_results": 0}},
+    )
+    assert "Found 0 results" in rendered
+    assert "2 filtered to allowlist" in rendered
+
+
 # ---------------------------------------------------------------------------
 # Background tasks
 # ---------------------------------------------------------------------------