merge: markdown rendering, date awareness, and agent output tracking into unified branch

# Conflicts:
#	docs/superpowers/plans/2026-05-26-agent-live-tool-stream.md
#	src/pythinker_code/ui/shell/components/markdown.py
#	src/pythinker_code/ui/shell/visualize/_blocks.py
#	src/pythinker_code/ui/shell/visualize/_live_view.py
#	tests/ui/test_shell_markdown.py
#	tests/ui_and_conv/test_tool_call_block.py

Author: elkaix

src/pythinker_code/agents/default/system.md

@@ -188,7 +188,7 @@ The operating environment is not in a sandbox. Any actions you do will immediate
 
 ## Date and Time
 
-The current date and time in ISO format is `${PYTHINKER_NOW}`. This is only a reference for you when searching the web, or checking file modification time, etc. If you need the exact time, use Shell tool with proper command.
+The current date and time in ISO format is `${PYTHINKER_NOW}`. Treat this as the authoritative present — it reflects the real "now", which is later than your training data suggests. Anchor all reasoning about the current date, the year, recency, and what counts as the "latest" version or release to `${PYTHINKER_NOW}`; do not fall back on an earlier year you might assume from training. Use it as your reference when searching the web or checking file modification times. If you need the exact time, use the Shell tool with a proper command.
 
 ## Working Directory
 
@@ -261,6 +261,15 @@ Identify the skills that are likely to be useful for the tasks you are currently
 
 Only read skill details when needed to conserve the context window.
 
+# Output Formatting
+
+Your responses are rendered as Markdown in a terminal. Emit well-formed Markdown so it renders cleanly:
+
+- **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.
+- **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
 
 At any time, you should be HELPFUL, CONCISE, and ACCURATE. Be thorough in your actions — test what you build, verify what you change — not in your explanations.

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

@@ -76,6 +76,11 @@
 )
 _PRIORITY_MATRIX_SEVERITIES = ("CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO")
 _TABLE_SEPARATOR_RE = re.compile(r"^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$")
+# A GFM table delimiter run, e.g. ``|---|:--:|---|``. Two or more dashes per
+# cell keeps stray inline ``|-|`` out of the match.
+_DELIM_RUN_RE = re.compile(r"\|(?:\s*:?-{2,}:?\s*\|)+")
+# A header line: optional prose prefix, then a trailing run of pipe cells.
+_HEADER_RE = re.compile(r"^(?P<prefix>.*?)(?P<cells>(?:\|[^\n|]*)+\|)\s*$")
 
 
 __all__ = [
@@ -344,6 +349,165 @@ def _simplify_markdown_report_icons(markup: str) -> str:
     return "".join(lines)
 
 
+def _split_pipe_cells(segment: str) -> list[str]:
+    """Split a ``| a | b |`` run into stripped inner cells (drops the frame)."""
+    parts = re.split(r"(?<!\\)\|", segment)
+    if parts and parts[0].strip() == "":
+        parts = parts[1:]
+    if parts and parts[-1].strip() == "":
+        parts = parts[:-1]
+    return [part.strip() for part in parts]
+
+
+def _is_pipe_row(line: str) -> bool:
+    stripped = line.strip()
+    return stripped.startswith("|") and stripped.count("|") >= 2
+
+
+def _delimiter_markers(run: str) -> list[str]:
+    """Return per-column alignment markers (``---``, ``:---``, ``---:``, ``:---:``)."""
+    markers: list[str] = []
+    for cell in _split_pipe_cells(run):
+        left = cell.startswith(":")
+        right = cell.endswith(":")
+        if left and right:
+            markers.append(":---:")
+        elif right:
+            markers.append("---:")
+        elif left:
+            markers.append(":---")
+        else:
+            markers.append("---")
+    return markers
+
+
+def _normalize_table_block(text: str) -> str:
+    """Repair malformed GFM tables in a fence-free block of markdown.
+
+    Models occasionally glue a table header onto preceding prose, drop the
+    newline between the header and the ``|---|`` delimiter, or cram data rows
+    onto the delimiter line — markdown-it then renders the whole thing as raw
+    text. Anchored on the delimiter run, this rebuilds each region it is
+    *confident* is a table (delimiter at line start, header and data cell counts
+    both equal to the delimiter's column count) and passes everything else
+    through untouched. Well-formed tables are rebuilt to identical-rendering
+    markdown, so the pass is safe to apply unconditionally.
+    """
+    out = ""
+    while True:
+        match = _DELIM_RUN_RE.search(text)
+        if match is None:
+            return out + text
+        markers = _delimiter_markers(match.group(0))
+        n_cols = len(markers)
+        head = text[: match.start()]
+        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() != "":
+            out += text[: match.end()]
+            text = tail
+            continue
+
+        head_lines = head.split("\n")
+        while head_lines and head_lines[-1] == "":
+            head_lines.pop()
+        header_match = _HEADER_RE.match(head_lines[-1]) if head_lines else None
+        header_cells = _split_pipe_cells(header_match.group("cells")) if header_match else []
+        if header_match is None or len(header_cells) != n_cols:
+            out += text[: match.end()]
+            text = tail
+            continue
+
+        # Data rows: the same-line remainder after the delimiter plus any
+        # following pipe rows, re-chunked into rows of ``n_cols`` cells.
+        tail_lines = tail.split("\n")
+        data_segments = [tail_lines[0]] if tail_lines[0].strip() else []
+        consumed = 1
+        for line in tail_lines[1:]:
+            if _is_pipe_row(line):
+                data_segments.append(line)
+                consumed += 1
+            else:
+                break
+        data_rows: list[list[str]] = []
+        bail = False
+        for segment in data_segments:
+            cells = _split_pipe_cells(segment)
+            if not cells:
+                continue
+            if len(cells) % n_cols != 0:
+                bail = True  # ambiguous (e.g. glued rows with empty cells) — leave as-is
+                break
+            for i in range(0, len(cells), n_cols):
+                data_rows.append(cells[i : i + n_cols])
+        if bail:
+            out += text[: match.end()]
+            text = tail
+            continue
+
+        preamble = head_lines[:-1]
+        prose = header_match.group("prefix").rstrip()
+        if preamble:
+            out += "\n".join(preamble) + "\n"
+        if prose:
+            out += prose + "\n"
+        # A GFM table must be preceded by a blank line (it cannot interrupt a
+        # 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"
+        for row in data_rows:
+            out += "| " + " | ".join(row) + " |\n"
+
+        remainder = "\n".join(tail_lines[consumed:])
+        if not remainder.strip():
+            return out
+        text = remainder if remainder.startswith("\n") else "\n" + remainder
+
+
+def _normalize_markdown_tables(markup: str) -> str:
+    """Apply :func:`_normalize_table_block` to every fence-free span of markup."""
+    if "|" not in markup or "-" not in markup:
+        return markup
+
+    out: list[str] = []
+    buffer: list[str] = []
+    in_fence = False
+    fence_char = ""
+    fence_len = 0
+
+    def flush() -> None:
+        if buffer:
+            out.append(_normalize_table_block("\n".join(buffer)))
+            buffer.clear()
+
+    for line in markup.splitlines():
+        match = _FENCE_RE.match(line)
+        if in_fence:
+            fence = match.group("fence") if match else ""
+            if fence and fence[0] == fence_char and len(fence) >= fence_len:
+                in_fence = False
+            out.append(line)
+            continue
+        if match:
+            flush()
+            in_fence = True
+            fence_char = match.group("fence")[0]
+            fence_len = len(match.group("fence"))
+            out.append(line)
+            continue
+        buffer.append(line)
+    flush()
+
+    result = "\n".join(out)
+    if markup.endswith("\n") and not result.endswith("\n"):
+        result += "\n"
+    return result
+
+
 class PythinkerMarkdown(Markdown):
     """Drop-in replacement for ``rich.markdown.Markdown`` with the Pythinker palette.
 
@@ -358,7 +522,8 @@ class PythinkerMarkdown(Markdown):
     def __init__(self, markup: str, *args: Any, **kwargs: Any) -> None:
         safe_markup = sanitize_ansi(markup)
         repaired_markup = _repair_crammed_markdown_tables(safe_markup)
-        super().__init__(_simplify_markdown_report_icons(repaired_markup), *args, **kwargs)
+        normalized_markup = _normalize_markdown_tables(repaired_markup)
+        super().__init__(_simplify_markdown_report_icons(normalized_markup), *args, **kwargs)
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         overrides = _markdown_style_overrides()

tests/core/test_default_agent.py

@@ -204,7 +204,7 @@ async def test_default_agent(runtime: Runtime):
 
 ## Date and Time
 
-The current date and time in ISO format is `1970-01-01T00:00:00+00:00`. This is only a reference for you when searching the web, or checking file modification time, etc. If you need the exact time, use Shell tool with proper command.
+The current date and time in ISO format is `1970-01-01T00:00:00+00:00`. Treat this as the authoritative present — it reflects the real "now", which is later than your training data suggests. Anchor all reasoning about the current date, the year, recency, and what counts as the "latest" version or release to `1970-01-01T00:00:00+00:00`; do not fall back on an earlier year you might assume from training. Use it as your reference when searching the web or checking file modification times. If you need the exact time, use the Shell tool with a proper command.
 
 ## Working Directory
 
@@ -269,6 +269,15 @@ async def test_default_agent(runtime: Runtime):
 
 Only read skill details when needed to conserve the context window.
 
+# Output Formatting
+
+Your responses are rendered as Markdown in a terminal. Emit well-formed Markdown so it renders cleanly:
+
+- **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.
+- **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
 
 At any time, you should be HELPFUL, CONCISE, and ACCURATE. Be thorough in your actions — test what you build, verify what you change — not in your explanations.

tests/core/test_load_agent.py

@@ -55,6 +55,24 @@ def test_system_prompt_contains_platform_info(builtin_args: BuiltinSystemPromptA
     assert builtin_args.PYTHINKER_SHELL in prompt
 
 
+def test_system_prompt_treats_injected_date_as_authoritative(
+    builtin_args: BuiltinSystemPromptArgs,
+):
+    """The injected date must be framed as authoritative so the model anchors
+    its sense of 'now' to it instead of a training-era year."""
+    from pythinker_code.agentspec import DEFAULT_AGENT_FILE
+
+    prompt = _load_system_prompt(
+        DEFAULT_AGENT_FILE.parent / "system.md",
+        {"ROLE_ADDITIONAL": ""},
+        builtin_args,
+    )
+
+    assert builtin_args.PYTHINKER_NOW in prompt
+    assert "authoritative present" in prompt
+    assert "do not fall back on an earlier year" in prompt
+
+
 def test_system_prompt_enforces_context_first_orchestration(
     builtin_args: BuiltinSystemPromptArgs,
 ):
@@ -74,6 +92,27 @@ def test_system_prompt_enforces_context_first_orchestration(
     assert "Treat subagent claims as leads, not proof" in prompt
 
 
+def test_system_prompt_includes_markdown_table_formatting_guidance(
+    builtin_args: BuiltinSystemPromptArgs,
+):
+    """Default prompt must reach the model with table-formatting rules so it
+    stops emitting headers glued to prose (which render as raw text)."""
+    from pythinker_code.agentspec import DEFAULT_AGENT_FILE
+
+    prompt = _load_system_prompt(
+        DEFAULT_AGENT_FILE.parent / "system.md",
+        {"ROLE_ADDITIONAL": ""},
+        builtin_args,
+    )
+
+    assert "# Output Formatting" in prompt
+    assert "glue a table onto adjacent prose" in prompt
+    # Reports must not be wrapped in code fences (that is what preserves raw
+    # emoji and breaks column alignment), and status icons should be sparing.
+    assert "Code fences are for code only" in prompt
+    assert "Status icons sparingly" in prompt
+
+
 def test_default_subagent_prompts_keep_robust_contracts():
     """Specialist subagents should retain evidence, planning, and verification gates."""
     from pythinker_code.agentspec import DEFAULT_AGENT_FILE, load_agent_spec

tests/ui/test_shell_markdown.py

@@ -63,6 +63,37 @@ def test_shell_markdown_renders_priority_matrix_as_grouped_rows() -> None:
     assert "────────────────" not in output
 
 
+def test_shell_markdown_repairs_glued_table_header() -> None:
+    # The model sometimes glues the header onto preceding prose and drops the
+    # newline before the |---| delimiter; markdown-it then renders it as raw
+    # text. The normalizer should rebuild a real table.
+    output = _render_text(
+        PythinkerMarkdown(
+            "● LOW — Various| Category | Issue | Locations |\n\n"
+            "|----------|-------|-----------| | Error handling | Bare except | 12 files |\n"
+        )
+    )
+    # Header text on its own line, no raw delimiter pipes left in the output.
+    assert "Category" in output and "Locations" in output
+    assert "Error handling" in output and "12 files" in output
+    assert "---" not in output
+    assert "|----------|" not in output
+
+
+def test_shell_markdown_leaves_inline_pipes_alone() -> None:
+    # A stray inline |-| in prose must not be mistaken for a table delimiter.
+    text = "Use the `a | b` operator. See |--| inline here."
+    output = _render_text(PythinkerMarkdown(text))
+    assert "operator" in output and "inline here" in output
+
+
+def test_shell_markdown_keeps_table_like_pipes_in_code_fence() -> None:
+    output = _render_text(PythinkerMarkdown("```\n| not | a | table |\n|-----|---|-------|\n```\n"))
+    # Inside a fence the pipes and delimiter survive verbatim.
+    assert "| not | a | table |" in output
+    assert "|-----|---|-------|" in output
+
+
 def test_shell_markdown_pads_code_block_with_blank_rows() -> None:
     # The code block should read as a distinct section, with a blank row framing
     # the panel above and below so it never crowds the surrounding prose.

tests/utils/test_pyinstaller_utils.py

@@ -284,6 +284,7 @@ def test_pyinstaller_hiddenimports():
             "pythinker_code.tools.todo",
             "pythinker_code.tools.utils",
             "pythinker_code.tools.web",
+            "pythinker_code.tools.web._allowlist",
             "pythinker_code.tools.web.fetch",
             "pythinker_code.tools.web.search",
             "setproctitle",