codex-transcript-viewer 0.4.0__tar.gz → 0.5.0__tar.gz

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.5.0
+
+- Short tool outputs no longer appear twice. Every output under 2,000 characters has shown its text twice since the first release; only long outputs were meant to have a preview and a full copy.
+- Memory citations at the end of an answer fold into a small "Memory citations" section, listing each cited note and the sessions it came from, instead of printing Codex's raw citation block.
+- The header shows the model and reasoning effort the session started with, not just "openai", and a row marks each turn that switches model or effort.
+- Code blocks get syntax highlighting for Python, shell, JavaScript and TypeScript, JSON, TOML and YAML, SQL, diffs, and C-like languages. It's built in, so pages stay self-contained.
+- Nested and numbered lists and blockquotes render, and reasoning summaries render as markdown instead of showing literal `**`.
+- The demo page is rebuilt around a made-up session that shows every kind of entry, with a script to regenerate its screenshots.
+- Dependabot keeps the workflow actions current, and the README has PyPI, Python version and test badges.
+
 ## 0.4.0
 
 - The viewer is on PyPI: `uv tool install codex-transcript-viewer`, `pipx install codex-transcript-viewer`, or `uvx codex-transcript-viewer <session.jsonl>` to run it once.

codex_transcript_viewer-0.4.0/README.md → codex_transcript_viewer-0.5.0/PKG-INFO

@@ -1,5 +1,35 @@
+Metadata-Version: 2.5
+Name: codex-transcript-viewer
+Version: 0.5.0
+Summary: Convert Codex CLI JSONL session transcripts to self-contained HTML viewers
+Project-URL: Homepage, https://github.com/masonc15/codex-transcript-viewer
+Project-URL: Issues, https://github.com/masonc15/codex-transcript-viewer/issues
+Project-URL: Changelog, https://github.com/masonc15/codex-transcript-viewer/blob/main/CHANGELOG.md
+Author: Colin Mason
+License-Expression: MIT
+License-File: LICENSE
+Keywords: codex,html,jsonl,openai,transcript,viewer
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
 # codex-transcript-viewer
 
+[![PyPI](https://img.shields.io/pypi/v/codex-transcript-viewer)](https://pypi.org/project/codex-transcript-viewer/)
+[![Python versions](https://img.shields.io/pypi/pyversions/codex-transcript-viewer)](https://pypi.org/project/codex-transcript-viewer/)
+[![Tests](https://github.com/masonc15/codex-transcript-viewer/actions/workflows/tests.yml/badge.svg)](https://github.com/masonc15/codex-transcript-viewer/actions/workflows/tests.yml)
+
 Converts Codex CLI JSONL session transcripts into single-file HTML viewers with sidebar navigation, search, and filtering. No external dependencies. Just open the `.html` in any browser.
 
 ![Viewer showing a final answer with sidebar navigation and filters](https://raw.githubusercontent.com/masonc15/codex-transcript-viewer/main/docs/images/final-answer.png)
@@ -53,7 +83,7 @@ If the log contains record types the viewer doesn't know about, it says so on st
 
 ## What the viewer shows
 
-The page has a sticky sidebar with a searchable event tree on the left and the transcript on the right. Your prompts get a green border, with any attached images shown as thumbnails you can click to enlarge. Final answers sit on a faint green background, commentary is italic with a muted border, and reasoning summaries are gray. Each tool call shows its command or arguments, and its result is colored by what actually happened: green when the exit code was 0, red when it failed, and neutral when the log doesn't record a status, so nothing looks successful by accident. Long outputs expand on click. Markdown in prompts and answers renders, tables included; web links open in a new tab, and links to local files show their full path on hover. Generated images show up as the result of their `image_generation` call, next to the prompt the model used. Turn starts, aborts, rollbacks and token counts show up as dim system lines.
+The page has a sticky sidebar with a searchable event tree on the left and the transcript on the right. Your prompts get a green border, with any attached images shown as thumbnails you can click to enlarge. Final answers sit on a faint green background, commentary is italic with a muted border, and reasoning summaries are gray. Each tool call shows its command or arguments, and its result is colored by what actually happened: green when the exit code was 0, red when it failed, and neutral when the log doesn't record a status, so nothing looks successful by accident. Long outputs expand on click. Markdown in prompts, answers and reasoning renders, including tables, nested lists, blockquotes and syntax-highlighted code; web links open in a new tab, and links to local files show their full path on hover. When Codex ends an answer with a memory-citation block, it's folded into a small "Memory citations" section instead of printed raw. Generated images show up as the result of their `image_generation` call, next to the prompt the model used. Turn starts, aborts, rollbacks and token counts show up as dim system lines. The header shows the model and reasoning effort the session started with, and a highlighted row marks any turn that switches either.
 
 Some things Codex only sends to the model, so the viewer shows them as their own highlighted entries: the objective and status changes of a `/goal`, text a hook sent back (a rejected plan, for example), review start and result markers, and errors such as hitting a usage limit. A review's findings appear in full when no reply repeats them. Newer models repeat the turn's earlier reasoning headings each time they add one, so each heading is shown once, at the point it first appeared.
 
@@ -89,6 +119,7 @@ Inspired by the HTML session export in [pi](https://github.com/badlogic/pi-mono/
 src/codex_transcript_viewer/
   parser.py       - JSONL parsing and event extraction
   markdown.py     - lightweight markdown-to-HTML conversion
+  highlight.py    - small built-in syntax highlighter for code blocks
   formatting.py   - timestamp formatting helpers
   html_builder.py - assembles the final HTML from events
   style.css       - all CSS for the viewer
@@ -97,4 +128,7 @@ src/codex_transcript_viewer/
 scripts/
   audit_sessions.py - checks the parser against real sessions
   visual_review.py  - renders sessions and screenshots the sidebar
+docs/demo/
+  make_session.py   - writes the synthetic session behind docs/demo.md
+  screenshots.py    - renders it and saves the demo screenshots
 ```

codex_transcript_viewer-0.4.0/PKG-INFO → codex_transcript_viewer-0.5.0/README.md

@@ -1,27 +1,9 @@
-Metadata-Version: 2.5
-Name: codex-transcript-viewer
-Version: 0.4.0
-Summary: Convert Codex CLI JSONL session transcripts to self-contained HTML viewers
-Project-URL: Homepage, https://github.com/masonc15/codex-transcript-viewer
-Project-URL: Issues, https://github.com/masonc15/codex-transcript-viewer/issues
-Project-URL: Changelog, https://github.com/masonc15/codex-transcript-viewer/blob/main/CHANGELOG.md
-Author: Colin Mason
-License-Expression: MIT
-License-File: LICENSE
-Keywords: codex,html,jsonl,openai,transcript,viewer
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Topic :: Software Development
-Classifier: Topic :: Utilities
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
 # codex-transcript-viewer
 
+[![PyPI](https://img.shields.io/pypi/v/codex-transcript-viewer)](https://pypi.org/project/codex-transcript-viewer/)
+[![Python versions](https://img.shields.io/pypi/pyversions/codex-transcript-viewer)](https://pypi.org/project/codex-transcript-viewer/)
+[![Tests](https://github.com/masonc15/codex-transcript-viewer/actions/workflows/tests.yml/badge.svg)](https://github.com/masonc15/codex-transcript-viewer/actions/workflows/tests.yml)
+
 Converts Codex CLI JSONL session transcripts into single-file HTML viewers with sidebar navigation, search, and filtering. No external dependencies. Just open the `.html` in any browser.
 
 ![Viewer showing a final answer with sidebar navigation and filters](https://raw.githubusercontent.com/masonc15/codex-transcript-viewer/main/docs/images/final-answer.png)
@@ -75,7 +57,7 @@ If the log contains record types the viewer doesn't know about, it says so on st
 
 ## What the viewer shows
 
-The page has a sticky sidebar with a searchable event tree on the left and the transcript on the right. Your prompts get a green border, with any attached images shown as thumbnails you can click to enlarge. Final answers sit on a faint green background, commentary is italic with a muted border, and reasoning summaries are gray. Each tool call shows its command or arguments, and its result is colored by what actually happened: green when the exit code was 0, red when it failed, and neutral when the log doesn't record a status, so nothing looks successful by accident. Long outputs expand on click. Markdown in prompts and answers renders, tables included; web links open in a new tab, and links to local files show their full path on hover. Generated images show up as the result of their `image_generation` call, next to the prompt the model used. Turn starts, aborts, rollbacks and token counts show up as dim system lines.
+The page has a sticky sidebar with a searchable event tree on the left and the transcript on the right. Your prompts get a green border, with any attached images shown as thumbnails you can click to enlarge. Final answers sit on a faint green background, commentary is italic with a muted border, and reasoning summaries are gray. Each tool call shows its command or arguments, and its result is colored by what actually happened: green when the exit code was 0, red when it failed, and neutral when the log doesn't record a status, so nothing looks successful by accident. Long outputs expand on click. Markdown in prompts, answers and reasoning renders, including tables, nested lists, blockquotes and syntax-highlighted code; web links open in a new tab, and links to local files show their full path on hover. When Codex ends an answer with a memory-citation block, it's folded into a small "Memory citations" section instead of printed raw. Generated images show up as the result of their `image_generation` call, next to the prompt the model used. Turn starts, aborts, rollbacks and token counts show up as dim system lines. The header shows the model and reasoning effort the session started with, and a highlighted row marks any turn that switches either.
 
 Some things Codex only sends to the model, so the viewer shows them as their own highlighted entries: the objective and status changes of a `/goal`, text a hook sent back (a rejected plan, for example), review start and result markers, and errors such as hitting a usage limit. A review's findings appear in full when no reply repeats them. Newer models repeat the turn's earlier reasoning headings each time they add one, so each heading is shown once, at the point it first appeared.
 
@@ -111,6 +93,7 @@ Inspired by the HTML session export in [pi](https://github.com/badlogic/pi-mono/
 src/codex_transcript_viewer/
   parser.py       - JSONL parsing and event extraction
   markdown.py     - lightweight markdown-to-HTML conversion
+  highlight.py    - small built-in syntax highlighter for code blocks
   formatting.py   - timestamp formatting helpers
   html_builder.py - assembles the final HTML from events
   style.css       - all CSS for the viewer
@@ -119,4 +102,7 @@ src/codex_transcript_viewer/
 scripts/
   audit_sessions.py - checks the parser against real sessions
   visual_review.py  - renders sessions and screenshots the sidebar
+docs/demo/
+  make_session.py   - writes the synthetic session behind docs/demo.md
+  screenshots.py    - renders it and saves the demo screenshots
 ```

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codex-transcript-viewer"
-version = "0.4.0"
+version = "0.5.0"
 description = "Convert Codex CLI JSONL session transcripts to self-contained HTML viewers"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -15,6 +15,10 @@ classifiers = [
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development",
     "Topic :: Utilities",
 ]

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/scripts/visual_review.py

@@ -10,7 +10,8 @@ format the archive contains gets looked at before a release.
 
 For each session this writes <name>-sidebar-N.png tiles covering the first
 --rows sidebar entries, and prints any turn where two message entries carry the
-same text in the rendered page. A repeat between two kinds of entry in the
+same text in the rendered page, plus any tool output that shows two visible
+copies of its text. A repeat between two kinds of entry in the
 same role (commentary and a final answer, say) is how an event_msg copy
 slipping past dedup looks, and fails the run. Other repeats are listed for the
 reviewer: within one kind it is usually the model repeating itself, and across
@@ -66,6 +67,9 @@ FIND_REPEATS = """
     }
     seen.set(text, kind);
   }
+  // A tool output must show one block of text; two visible copies is a render bug.
+  const doubled = [...document.querySelectorAll('.tool-output')].filter(out =>
+    [...out.querySelectorAll('pre')].filter(pre => pre.offsetParent !== null).length > 1).length;
   // Let the entry list grow to its full height so it can be screenshotted.
   const sidebar = document.getElementById('sidebar');
   sidebar.style.position = 'static';
@@ -75,7 +79,7 @@ FIND_REPEATS = """
   tree.style.overflow = 'visible';
   tree.style.flex = 'none';
   nodes.filter(n => n.style.display !== 'none').slice(maxRows).forEach(n => n.style.display = 'none');
-  return {rows: nodes.length, repeats};
+  return {rows: nodes.length, repeats, doubled};
 }
 """
 
@@ -141,7 +145,9 @@ def main(argv: list[str] | None = None) -> int:
                 page.set_viewport_size({"width": 1440, "height": 900})
 
             cross = [r for r in result["repeats"] if r["cross"]]
-            found += len(cross)
+            found += len(cross) + result["doubled"]
+            if result["doubled"]:
+                print(f"   {result['doubled']} tool outputs show their text twice")
             print(f"== {session.name}: {result['rows']} sidebar rows, {len(tiles)} tiles in {args.out}")
             print(f"   {len(cross)} repeats between entry kinds in one role, "
                   f"{len(result['repeats']) - len(cross)} other repeats")

codex_transcript_viewer-0.5.0/src/codex_transcript_viewer/highlight.py

@@ -0,0 +1,108 @@
+"""A small built-in syntax highlighter for fenced code blocks.
+
+Pages stay self-contained with no dependencies, so this is a regex tokenizer
+for the languages Codex writes most, not a real lexer. It colors comments,
+strings, numbers and keywords; diffs get added, removed and hunk lines.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+
+_PY_KEYWORDS = (
+    "False None True and as assert async await break class continue def del elif else "
+    "except finally for from global if import in is lambda match nonlocal not or pass "
+    "raise return try while with yield case self"
+)
+_SHELL_KEYWORDS = (
+    "if then else elif fi for while until do done case esac function in select return "
+    "export local readonly declare set unset source exit break continue"
+)
+_JS_KEYWORDS = (
+    "async await break case catch class const continue debugger default delete do else "
+    "enum export extends false finally for from function if implements import in "
+    "instanceof interface let new null of private protected public readonly return static "
+    "super switch this throw true try type typeof undefined var void while with yield as"
+)
+_C_LIKE_KEYWORDS = (
+    "as async await break case catch class const continue crate default defer do else enum "
+    "extension extern false fileprivate final fn for func func go guard if impl import in "
+    "init interface internal let loop match mod move mut nil null override package private "
+    "protocol pub public return select self Self static struct super switch throw throws "
+    "trait true try type typealias unsafe use var void where while"
+)
+_SQL_KEYWORDS = (
+    "select from where and or not insert into values update set delete create table index "
+    "drop alter join left right inner outer on group by order having limit offset as "
+    "distinct union all null is in like between case when then else end primary key"
+)
+
+_STRINGS = r'"(?:[^"\\\n]|\\.)*"|\'(?:[^\'\\\n]|\\.)*\''
+_NUMBER = r"\b(?:0[xX][0-9a-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b"
+
+
+def _spec(comment: str, strings: str, keywords: str, flags: int = 0) -> re.Pattern:
+    words = "|".join(sorted(set(keywords.split()), key=len, reverse=True))
+    return re.compile(
+        rf"(?P<comment>{comment})|(?P<string>{strings})|(?P<number>{_NUMBER})"
+        rf"|(?P<keyword>\b(?:{words})\b)",
+        flags,
+    )
+
+
+_PYTHON = _spec(r"#[^\n]*", r'[rRbBfFuU]{0,2}(?:"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'|' + _STRINGS + ")", _PY_KEYWORDS)
+_SHELL = _spec(r"(?<![\w$\\{])#[^\n]*", _STRINGS, _SHELL_KEYWORDS)
+_JS = _spec(r"//[^\n]*|/\*[\s\S]*?\*/", _STRINGS + r"|`(?:[^`\\]|\\.)*`", _JS_KEYWORDS)
+_C_LIKE = _spec(r"//[^\n]*|/\*[\s\S]*?\*/", _STRINGS, _C_LIKE_KEYWORDS)
+_JSON = _spec(r"(?!)", r'"(?:[^"\\\n]|\\.)*"', "true false null")
+_CONFIG = _spec(r"#[^\n]*", _STRINGS, "true false yes no null on off")
+_SQL = _spec(r"--[^\n]*", _STRINGS, _SQL_KEYWORDS, re.IGNORECASE)
+
+_LANGUAGES = {
+    **dict.fromkeys(("python", "py", "python3"), _PYTHON),
+    **dict.fromkeys(("bash", "sh", "shell", "zsh", "console", "shellscript"), _SHELL),
+    **dict.fromkeys(("javascript", "js", "jsx", "mjs", "cjs", "typescript", "ts", "tsx"), _JS),
+    **dict.fromkeys(
+        ("rust", "rs", "go", "golang", "swift", "c", "cpp", "h", "java", "kotlin", "kt", "cs", "csharp"),
+        _C_LIKE,
+    ),
+    **dict.fromkeys(("json", "jsonc", "jsonl"), _JSON),
+    **dict.fromkeys(("toml", "yaml", "yml", "ini", "conf"), _CONFIG),
+    "sql": _SQL,
+}
+
+
+def highlight(code: str, lang: str) -> str | None:
+    """Escaped, highlighted HTML for ``code``, or None for an unknown language."""
+    lang = lang.lower()
+    if lang in ("diff", "patch"):
+        return _highlight_diff(code)
+    pattern = _LANGUAGES.get(lang)
+    if pattern is None:
+        return None
+    out: list[str] = []
+    last = 0
+    for match in pattern.finditer(code):
+        out.append(html.escape(code[last : match.start()]))
+        out.append(f'<span class="tok-{match.lastgroup}">{html.escape(match.group())}</span>')
+        last = match.end()
+    out.append(html.escape(code[last:]))
+    return "".join(out)
+
+
+def _highlight_diff(code: str) -> str:
+    lines = []
+    for line in code.split("\n"):
+        kind = None
+        if line.startswith(("+++", "---")):
+            kind = "meta"
+        elif line.startswith("+"):
+            kind = "added"
+        elif line.startswith("-"):
+            kind = "removed"
+        elif line.startswith("@@"):
+            kind = "hunk"
+        escaped = html.escape(line)
+        lines.append(f'<span class="tok-{kind}">{escaped}</span>' if kind else escaped)
+    return "\n".join(lines)

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/src/codex_transcript_viewer/html_builder.py

@@ -9,7 +9,7 @@ from datetime import datetime
 from importlib import resources
 
 from .formatting import format_ts, format_ts_full
-from .markdown import escape, render_markdown
+from .markdown import escape, render_markdown, split_memory_citations
 
 
 def _load_asset(name: str) -> str:
@@ -66,7 +66,7 @@ def build_html(
         elif evt["type"] == "tool_call":
             ctx.names_by_call.setdefault(call_id, evt.get("name", ""))
     session_id = meta.get("id", "unknown") if meta else "unknown"
-    model = meta.get("model_provider", "") if meta else ""
+    model = _session_model(meta, events)
     cli_version = meta.get("cli_version", "") if meta else ""
     cwd = meta.get("cwd", "") if meta else ""
     branch = meta.get("git", {}).get("branch", "") if meta else ""
@@ -134,6 +134,19 @@ def build_html(
     )
 
 
+def _session_model(meta: dict | None, events: list[dict]) -> str:
+    """The first turn's model and effort, falling back to the provider name.
+
+    A forked subagent's copied parent turns come first, so its own turns win.
+    """
+    settings = [e for e in events if e.get("type") == "turn_settings"]
+    first = next((e for e in settings if not e.get("inherited")), settings[0] if settings else None)
+    if first:
+        effort = f" ({first['effort']} effort)" if first.get("effort") else ""
+        return first["model"] + effort
+    return meta.get("model_provider", "") if meta else ""
+
+
 def _subagent_info_html(meta: dict | None, events: list[dict]) -> str:
     """Header rows that identify a subagent thread and its parent."""
     source = meta.get("source") if isinstance(meta, dict) else None
@@ -304,12 +317,12 @@ def _render_reasoning(evt, ts, anchor, sidebar, messages, ctx):
     sidebar.append(
         f'<a class="tree-node tree-role-thinking" href="#{anchor}">'
         f'<span class="tree-ts">{ts}</span> '
-        f'<span class="tree-content">\U0001f4ad {escape(evt["text"][:60])}</span></a>'
+        f'<span class="tree-content">\U0001f4ad {escape(evt["text"].replace("**", "")[:60])}</span></a>'
     )
     messages.append(
         f'<div class="thinking-block" id="{anchor}">'
         f'<div class="message-timestamp">{ts}</div>'
-        f'<div class="thinking-text">{escape(evt["text"])}</div>'
+        f'<div class="thinking-text markdown-content">{render_markdown(evt["text"])}</div>'
         f"</div>"
     )
 
@@ -318,12 +331,12 @@ def _render_agent_commentary(evt, ts, anchor, sidebar, messages, ctx):
     sidebar.append(
         f'<a class="tree-node tree-role-assistant" href="#{anchor}">'
         f'<span class="tree-ts">{ts}</span> '
-        f'<span class="tree-content">\U0001f4ac {escape(evt["text"][:60])}</span></a>'
+        f'<span class="tree-content">\U0001f4ac {escape(_reply_preview(evt["text"]))}</span></a>'
     )
     messages.append(
         f'<div class="commentary-message" id="{anchor}">'
         f'<div class="message-timestamp">{ts}</div>'
-        f'<div class="markdown-content">{render_markdown(evt["text"])}</div>'
+        f"{_render_reply(evt['text'])}"
         f"</div>"
     )
 
@@ -333,7 +346,7 @@ def _render_assistant_text(evt, ts, anchor, sidebar, messages, ctx):
         _render_task_complete(evt, ts, anchor, sidebar, messages, ctx)
         return
     phase_label = f' ({evt["phase"]})' if evt.get("phase") else ""
-    preview = evt["text"][:60].replace("\n", " ")
+    preview = _reply_preview(evt["text"])
     sidebar.append(
         f'<a class="tree-node tree-role-assistant" data-kind="assistant" href="#{anchor}">'
         f'<span class="tree-ts">{ts}</span> '
@@ -342,11 +355,44 @@ def _render_assistant_text(evt, ts, anchor, sidebar, messages, ctx):
     messages.append(
         f'<div class="assistant-message" id="{anchor}">'
         f'<div class="message-timestamp">{ts}{escape(phase_label)}</div>'
-        f'<div class="assistant-text markdown-content">{render_markdown(evt["text"])}</div>'
+        f'{_render_reply(evt["text"], "assistant-text ")}'
         f"</div>"
     )
 
 
+def _reply_preview(text: str) -> str:
+    """Sidebar text for an assistant message, without its memory citations."""
+    return split_memory_citations(text)[0][:60].replace("\n", " ")
+
+
+def _render_reply(text: str, extra_class: str = "") -> str:
+    """An assistant message, with its memory citations folded away at the end."""
+    body, entries, rollouts = split_memory_citations(text)
+    html = f'<div class="{extra_class}markdown-content">{render_markdown(body)}</div>'
+    if not entries and not rollouts:
+        return html
+    items = "".join(
+        f'<li><span class="citation-location">{escape(entry["location"])}</span>'
+        + (f" \u2014 {escape(entry['note'])}" if entry["note"] else "")
+        + "</li>"
+        for entry in entries
+    )
+    parts = [f"{len(entries)} memory entr{'y' if len(entries) == 1 else 'ies'}"] if entries else []
+    if rollouts:
+        parts.append(f"{len(rollouts)} earlier session{'' if len(rollouts) == 1 else 's'}")
+    sessions = (
+        '<div class="citation-rollouts">Sessions: '
+        + ", ".join(f"<code>{escape(r)}</code>" for r in rollouts)
+        + "</div>"
+        if rollouts
+        else ""
+    )
+    return (
+        f'{html}<details class="memory-citations"><summary>Memory citations: '
+        f'{" from ".join(parts)}</summary><ul>{items}</ul>{sessions}</details>'
+    )
+
+
 def _compact_json(value):
     return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
 
@@ -486,12 +532,16 @@ def _render_tool_output(evt, ts, anchor, sidebar, messages, ctx):
         f'<span class="tree-content">\U0001f4e4 output ({size_label}){marker}</span></a>'
     )
 
-    expandable_class = " expandable" if truncated else ""
-    expand_hint = (
-        f'\n<span class="expand-hint">[click to expand {len(output)} chars]</span>'
-        if truncated
-        else ""
-    )
+    if truncated:
+        # A long output shows its first 2,000 characters until clicked.
+        body = (
+            '<div class="tool-output expandable" onclick="this.classList.toggle(\'expanded\')">'
+            f'<div class="output-preview"><pre>{escape(preview)}\n'
+            f'<span class="expand-hint">[click to expand {len(output)} chars]</span></pre></div>'
+            f'<div class="output-full"><pre>{escape(shown)}{escape(omitted)}</pre></div></div>'
+        )
+    else:
+        body = f'<div class="tool-output"><pre>{escape(shown)}{escape(omitted)}</pre></div>'
 
     output_images = _render_attachments(
         attachments, ctx, default_label="image output", budgeted=True
@@ -502,15 +552,12 @@ def _render_tool_output(evt, ts, anchor, sidebar, messages, ctx):
         f'<div class="tool-execution {status}" id="{anchor}">'
         f'<div class="tool-header"><span class="tool-name">{label}</span>'
         f"{_status_badge(evt, status)}</div>"
-        f'<div class="tool-output{expandable_class}" onclick="this.classList.toggle(\'expanded\')">'
-        f'<div class="output-preview"><pre>{escape(preview)}{expand_hint}</pre></div>'
-        f'<div class="output-full"><pre>{escape(shown)}{escape(omitted)}</pre></div>'
-        f"</div>{output_images}</div>"
+        f"{body}{output_images}</div>"
     )
 
 
 def _render_task_complete(evt, ts, anchor, sidebar, messages, ctx):
-    preview = evt["text"][:60].replace("\n", " ")
+    preview = _reply_preview(evt["text"])
     sidebar.append(
         f'<a class="tree-node tree-role-assistant" data-kind="final-answer" href="#{anchor}">'
         f'<span class="tree-ts">{ts}</span> '
@@ -519,7 +566,7 @@ def _render_task_complete(evt, ts, anchor, sidebar, messages, ctx):
     messages.append(
         f'<div class="assistant-message final-answer" id="{anchor}">'
         f'<div class="message-timestamp">{ts} \u2014 final answer</div>'
-        f'<div class="assistant-text markdown-content">{render_markdown(evt["text"])}</div>'
+        f'{_render_reply(evt["text"], "assistant-text ")}'
         f"</div>"
     )
 
@@ -691,6 +738,30 @@ def _render_hook_prompt(evt, ts, anchor, sidebar, messages, ctx):
                label=f"\U0001fa9d {hook}: {preview}", title=f"\U0001fa9d {hook}", body=body)
 
 
+def _render_turn_settings(evt, ts, anchor, sidebar, messages, ctx):
+    effort = evt.get("effort")
+    if evt.get("first"):
+        label = f"\u2699 {evt['model']}" + (f", {effort} effort" if effort else "")
+        sidebar.append(
+            f'<a class="tree-node tree-role-system" href="#{anchor}">'
+            f'<span class="tree-ts">{ts}</span> '
+            f'<span class="tree-content">{escape(label)}</span></a>'
+        )
+        messages.append(
+            f'<div class="system-event" id="{anchor}">'
+            f'<div class="message-timestamp">{ts}</div>'
+            f'<span class="event-label">{escape(label)}</span></div>'
+        )
+        return
+    changes = []
+    if evt["model"] != evt.get("previous_model"):
+        changes.append(f"model {evt.get('previous_model')} \u2192 {evt['model']}")
+    if effort != evt.get("previous_effort"):
+        changes.append(f"effort {evt.get('previous_effort') or 'default'} \u2192 {effort or 'default'}")
+    _event_row(anchor, ts, sidebar, messages, role="event", kind="settings",
+               label="\u2699 Switched " + ", ".join(changes))
+
+
 def _render_error(evt, ts, anchor, sidebar, messages, ctx):
     _event_row(anchor, ts, sidebar, messages, role="error", kind="",
                label=f"\u26a0 {evt.get('message') or 'Error'}")
@@ -713,6 +784,7 @@ _EVENT_HANDLERS = {
     "review_finished": _render_review_finished,
     "hook_prompt": _render_hook_prompt,
     "error": _render_error,
+    "turn_settings": _render_turn_settings,
 }
 
 

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/src/codex_transcript_viewer/markdown.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import html
 import re
 
+from .highlight import highlight
+
 
 def escape(text: str | None) -> str:
     """HTML-escape text, returning empty string for None."""
@@ -27,9 +29,10 @@ _TABLE_SEPARATOR_RE = re.compile(r"^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$")
 def render_markdown(text: str) -> str:
     """Convert the markdown Codex writes to HTML.
 
-    Handles fenced code blocks, inline code, bold, italic, headers, unordered
-    lists, links and pipe tables. Intended for session transcript content
-    where full CommonMark compliance is unnecessary.
+    Handles fenced code blocks (highlighted for common languages), inline code,
+    bold, italic, headers, bullet and numbered lists at any depth, blockquotes,
+    links and pipe tables. Intended for session transcript content where full
+    CommonMark compliance is unnecessary.
     """
     slots: list[str] = []
 
@@ -40,12 +43,7 @@ def render_markdown(text: str) -> str:
     escaped = escape(text)
 
     # Fenced code blocks (```lang ... ```)
-    escaped = re.sub(
-        r"```(\w*)\n(.*?)```",
-        lambda m: park(f'<pre><code class="language-{m.group(1)}">{m.group(2)}</code></pre>'),
-        escaped,
-        flags=re.DOTALL,
-    )
+    escaped = re.sub(r"```([\w+#-]*)\n(.*?)```", lambda m: park(_code_block(*m.groups())), escaped, flags=re.DOTALL)
 
     # Inline code
     escaped = re.sub(r"`([^`\n]+)`", lambda m: park(f"<code>{m.group(1)}</code>"), escaped)
@@ -55,6 +53,15 @@ def render_markdown(text: str) -> str:
     escaped = _AUTOLINK_RE.sub(lambda m: park(_link(m.group(1), m.group(1))), escaped)
     escaped = _BARE_URL_RE.sub(lambda m: park(_link(m.group(1), m.group(1))), escaped)
 
+    # List items, before emphasis so a "* " bullet is not read as italics
+    escaped = re.sub(r"^( *)[-*+] (?=\S)", _bullet, escaped, flags=re.MULTILINE)
+    escaped = re.sub(
+        r"^( *)(\d+)[.)] (?=\S)",
+        lambda m: park(f'{m.group(1)}<span class="md-list-number">{m.group(2)}.</span> '),
+        escaped,
+        flags=re.MULTILINE,
+    )
+
     # Bold
     escaped = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", escaped)
 
@@ -74,15 +81,77 @@ def render_markdown(text: str) -> str:
         r"^# (.+)$", r"<h1>\1</h1>", escaped, flags=re.MULTILINE
     )
 
-    # Unordered list items
-    escaped = re.sub(r"^- (.+)$", r"• \1", escaped, flags=re.MULTILINE)
-
+    escaped = _render_blockquotes(escaped)
     escaped = _render_tables(escaped)
 
     # Restore parked markup; link text may itself hold parked inline code.
     while _SLOT_RE.search(escaped):
         escaped = _SLOT_RE.sub(lambda m: slots[int(m.group(1))], escaped)
-    return escaped
+    # A code block has its own margins, so the line breaks around it only add gaps;
+    # a paragraph break after one would otherwise render as an extra blank line.
+    return re.sub(r"\n?(<pre><code[^>]*>.*?</code></pre>)\n{0,2}", r"\1", escaped, flags=re.S)
+
+
+def _code_block(lang: str, escaped_code: str) -> str:
+    highlighted = highlight(html.unescape(escaped_code), lang) if lang else None
+    return f'<pre><code class="language-{lang}">{highlighted or escaped_code}</code></pre>'
+
+
+_BULLETS = ("\u2022", "\u25e6", "\u25aa")
+
+
+def _bullet(match: re.Match) -> str:
+    """Bullets change shape with depth: two spaces of indent per level."""
+    indent = match.group(1)
+    return indent + _BULLETS[min(len(indent) // 2, len(_BULLETS) - 1)] + " "
+
+
+def _render_blockquotes(text: str) -> str:
+    """Group consecutive "> " lines into one blockquote."""
+    out: list[str] = []
+    quote: list[str] = []
+
+    def flush() -> None:
+        if quote:
+            out.append("<blockquote>" + "\n".join(quote) + "</blockquote>")
+            quote.clear()
+
+    for line in text.split("\n"):
+        if line.startswith("&gt;"):
+            quote.append(line[4:][1:] if line[4:5] == " " else line[4:])
+        else:
+            flush()
+            out.append(line)
+    flush()
+    return re.sub("(</blockquote>)\n", r"\1", "\n".join(out))
+
+
+_CITATION_BLOCK_RE = re.compile(r"\s*<oai-mem-citation>(.*?)(?:</oai-mem-citation>|\Z)", re.S)
+_CITATION_SECTION_RE = re.compile(r"<(citation_entries|rollout_ids)>(.*?)(?:</\w+>|\Z)", re.S)
+
+
+def split_memory_citations(text: str) -> tuple[str, list[dict], list[str]]:
+    """Take Codex's memory-citation blocks out of an answer.
+
+    Returns the answer without them, the cited entries as
+    {"location", "note"} dicts, and the ids of the sessions they came from.
+    """
+    entries: list[dict] = []
+    rollouts: list[str] = []
+    for block in _CITATION_BLOCK_RE.finditer(text):
+        for section, body in _CITATION_SECTION_RE.findall(block.group(1)):
+            for line in body.splitlines():
+                line = line.strip()
+                if not line or line.startswith("<"):
+                    continue
+                if section == "rollout_ids":
+                    rollouts.append(line)
+                    continue
+                location, _, note = line.partition("|note=")
+                entries.append({"location": location.strip(), "note": note.strip().strip("[]")})
+    if not entries and not rollouts:
+        return text, [], []
+    return _CITATION_BLOCK_RE.sub("", text).rstrip(), entries, rollouts
 
 
 def _link(label: str, target: str) -> str:

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/src/codex_transcript_viewer/parser.py

@@ -87,10 +87,26 @@ def extract_conversation(
             _handle_response_item(payload, ts, raw_events, turn_seq)
             continue
 
+        if etype == "turn_context":
+            model = _as_text(payload.get("model"))
+            if model:
+                raw_events.append(
+                    {
+                        "type": "turn_settings",
+                        "ts": ts,
+                        "model": model,
+                        "effort": _as_text(payload.get("effort") or payload.get("reasoning_effort")),
+                        "_source": "turn_context",
+                        "_turn_seq": turn_seq,
+                    }
+                )
+            continue
+
     raw_events = _attach_model_input_images(raw_events)
     raw_events = _apply_exec_status(raw_events)
     raw_events = _drop_repeated_reasoning_summaries(raw_events)
     raw_events = _drop_unchanged_goal_updates(raw_events)
+    raw_events = _keep_turn_settings_changes(raw_events)
     reconciled = _mark_reviews_repeated_by_reply(_reconcile_events(raw_events))
     for event in reconciled:
         if event.get("_turn_seq") in inherited_turns:
@@ -163,8 +179,9 @@ _HANDLED_RESPONSE_ITEM = {
     "tool_search_output", "message", "reasoning", "image_generation_call",
 }
 _IGNORED_RESPONSE_ITEM = {"ghost_snapshot", "agent_message"}
+_HANDLED_TOP_LEVEL = {"session_meta", "event_msg", "response_item", "turn_context"}
 _IGNORED_TOP_LEVEL = {
-    "token_usage_record", "turn_context", "compacted", "world_state",
+    "token_usage_record", "compacted", "world_state",
     "inter_agent_communication_metadata", "realtime_item",
 }
 
@@ -191,7 +208,7 @@ def unrecognized_record_kinds(entries: list[dict]) -> Counter:
         elif etype == "response_item":
             if subtype not in _HANDLED_RESPONSE_ITEM and subtype not in _IGNORED_RESPONSE_ITEM:
                 unknown[f"response_item/{subtype}"] += 1
-        elif etype not in _IGNORED_TOP_LEVEL:
+        elif etype not in _HANDLED_TOP_LEVEL and etype not in _IGNORED_TOP_LEVEL:
             unknown[str(etype)] += 1
     return unknown
 
@@ -361,6 +378,27 @@ def _drop_unchanged_goal_updates(events: list[dict]) -> list[dict]:
     return kept
 
 
+def _keep_turn_settings_changes(events: list[dict]) -> list[dict]:
+    """Keep the first turn's model and effort, then only turns that change them.
+
+    Codex records both at the start of every turn; most sessions never change.
+    """
+    kept = []
+    last: tuple[str, str] | None = None
+    for event in events:
+        if event.get("type") == "turn_settings":
+            key = (event["model"], event["effort"])
+            if key == last:
+                continue
+            if last is None:
+                event["first"] = True
+            else:
+                event["previous_model"], event["previous_effort"] = last
+            last = key
+        kept.append(event)
+    return kept
+
+
 def _review_started_event(payload: dict, ts: str, turn_seq: int) -> dict:
     hint = _as_text(payload.get("user_facing_hint")) or _as_text(payload.get("prompt"))
     return {

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/src/codex_transcript_viewer/style.css

@@ -534,6 +534,25 @@ body {
   font-weight: bold;
 }
 
+.markdown-content .md-list-number { color: var(--mdListBullet); }
+
+/* Syntax highlighting in fenced code */
+.tok-keyword { color: #c792ea; }
+.tok-string { color: var(--success); }
+.tok-number { color: var(--mdHeading); }
+.tok-comment { color: var(--muted); font-style: italic; }
+.tok-added { color: var(--success); }
+.tok-removed { color: var(--error); }
+.tok-hunk { color: var(--mdLink); }
+.tok-meta { color: var(--muted); font-weight: bold; }
+
+/* Memory citations folded under an answer */
+.memory-citations { margin-top: 8px; color: var(--muted); font-size: 11px; white-space: normal; }
+.memory-citations summary { cursor: pointer; }
+.memory-citations ul { margin: 4px 0 0 20px; }
+.memory-citations .citation-location { color: var(--mdLink); }
+.memory-citations .citation-rollouts { margin-top: 4px; }
+
 /* Footer */
 .footer {
   margin-top: 48px;

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/tests/test_markdown.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import unittest
 
-from codex_transcript_viewer.markdown import render_markdown
+from codex_transcript_viewer.highlight import highlight
+from codex_transcript_viewer.markdown import render_markdown, split_memory_citations
 
 
 class LinkTests(unittest.TestCase):
@@ -100,5 +101,91 @@ class ExistingFormattingTests(unittest.TestCase):
         self.assertEqual(render_markdown("<script>x</script>"), "&lt;script&gt;x&lt;/script&gt;")
 
 
+class ListAndQuoteTests(unittest.TestCase):
+    def test_nested_bullets_change_shape_by_depth(self) -> None:
+        html = render_markdown("- a\n  - b\n    - c\n      - d\n* e\n+ f")
+        self.assertEqual(html, "\u2022 a\n  \u25e6 b\n    \u25aa c\n      \u25aa d\n\u2022 e\n\u2022 f")
+
+    def test_star_bullet_is_not_italics(self) -> None:
+        html = render_markdown("* one\n* two")
+        self.assertNotIn("<em>", html)
+
+    def test_numbered_items_get_styled_numbers(self) -> None:
+        html = render_markdown("1. first\n  2) nested")
+        self.assertEqual(
+            html,
+            '<span class="md-list-number">1.</span> first\n  <span class="md-list-number">2.</span> nested',
+        )
+
+    def test_blockquote_groups_lines(self) -> None:
+        html = render_markdown("before\n> one **bold**\n>two\nafter")
+        self.assertEqual(html, "before\n<blockquote>one <strong>bold</strong>\ntwo</blockquote>after")
+
+
+class HighlightTests(unittest.TestCase):
+    def test_python_tokens(self) -> None:
+        html = highlight('def f():  # hi\n    return "x" + 1', "python")
+        self.assertIn('<span class="tok-keyword">def</span>', html)
+        self.assertIn('<span class="tok-comment"># hi</span>', html)
+        self.assertIn('<span class="tok-string">&quot;x&quot;</span>', html)
+        self.assertIn('<span class="tok-number">1</span>', html)
+
+    def test_strings_hide_comment_markers(self) -> None:
+        html = highlight('url = "http://x#y"', "py")
+        self.assertNotIn("tok-comment", html)
+
+    def test_shell_hash_inside_variable_is_not_a_comment(self) -> None:
+        html = highlight("echo ${#arr[@]} # count", "bash")
+        self.assertEqual(html.count("tok-comment"), 1)
+        self.assertIn("${#arr[@]}", html)
+
+    def test_diff_lines(self) -> None:
+        html = highlight("--- a\n+++ b\n@@ -1 +1 @@\n-old\n+new\n same", "diff")
+        for kind in ("meta", "hunk", "removed", "added"):
+            self.assertIn(f"tok-{kind}", html)
+
+    def test_unknown_language_is_left_alone(self) -> None:
+        self.assertIsNone(highlight("x", "brainfuck"))
+        self.assertEqual(render_markdown("```brainfuck\n<+>\n```"),
+                         '<pre><code class="language-brainfuck">&lt;+&gt;\n</code></pre>')
+
+    def test_code_is_escaped_in_highlighted_blocks(self) -> None:
+        html = render_markdown("```js\nif (a < b) { x = '<b>' }\n```")
+        self.assertIn("&lt;", html)
+        self.assertNotIn("<b>", html)
+
+
+class CodeBlockSpacingTests(unittest.TestCase):
+    def test_line_breaks_around_code_blocks_are_dropped(self) -> None:
+        html = render_markdown("Before:\n\n```\nx\n```\n\nAfter")
+        self.assertEqual(html, 'Before:\n<pre><code class="language-">x\n</code></pre>After')
+
+
+class MemoryCitationTests(unittest.TestCase):
+    BLOCK = (
+        "<oai-mem-citation>\n<citation_entries>\n"
+        "MEMORY.md:383-405|note=[slack digest source of truth]\n"
+        "extensions/x/resources/a.md:1-2|note=[other]\n"
+        "</citation_entries>\n<rollout_ids>\n019e-a\n019e-b\n</rollout_ids>\n</oai-mem-citation>"
+    )
+
+    def test_split_citations(self) -> None:
+        text, entries, rollouts = split_memory_citations("Done.\n\n" + self.BLOCK)
+        self.assertEqual(text, "Done.")
+        self.assertEqual(entries[0], {"location": "MEMORY.md:383-405", "note": "slack digest source of truth"})
+        self.assertEqual(len(entries), 2)
+        self.assertEqual(rollouts, ["019e-a", "019e-b"])
+
+    def test_unclosed_block_and_typo_close_tag(self) -> None:
+        text, entries, rollouts = split_memory_citations(
+            "Done.\n<oai-mem-citation>\n<citation_entries>\nMEMORY.md:1-2|note=[n]\n"
+            "</citation_entries>\n<rollout_ids>\nr1\n</rollup_ids>"
+        )
+        self.assertEqual((text, len(entries), rollouts), ("Done.", 1, ["r1"]))
+
+    def test_text_without_citations_is_unchanged(self) -> None:
+        self.assertEqual(split_memory_citations("plain\n"), ("plain\n", [], []))
+
+
 if __name__ == "__main__":
     unittest.main()

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/tests/test_output_cap.py

@@ -33,5 +33,19 @@ class OutputCapTests(unittest.TestCase):
         self.assertIn("[50,000 characters omitted]", _html("z" * 300_000))
 
 
+class OutputShownOnceTests(unittest.TestCase):
+    def test_short_output_is_rendered_once(self) -> None:
+        html = _html("12 passed in 0.34s")
+        self.assertEqual(html.count("12 passed in 0.34s"), 1)
+        self.assertNotIn('class="output-preview"', html)
+
+    def test_long_output_has_preview_and_full_copy(self) -> None:
+        html = _html("line\n" * 1000)
+        self.assertIn('class="tool-output expandable"', html)
+        self.assertIn("output-preview", html)
+        self.assertIn("output-full", html)
+        self.assertIn("[click to expand 5000 chars]", html)
+
+
 if __name__ == "__main__":
     unittest.main()

{codex_transcript_viewer-0.4.0 → codex_transcript_viewer-0.5.0}/tests/test_session_events.py

@@ -219,6 +219,53 @@ class ImageGenerationTests(unittest.TestCase):
         self.assertIs(output["failed"], True)
 
 
+class TurnSettingsTests(unittest.TestCase):
+    def _context(self, model: str, effort: str) -> dict:
+        return {"type": "turn_context", "timestamp": "2026-09-27T01:00:00Z",
+                "payload": {"model": model, "effort": effort, "cwd": "/x"}}
+
+    def test_only_changes_are_kept_and_header_shows_first_model(self) -> None:
+        entries = [
+            _turn(), self._context("gpt-5.6-sol", "high"),
+            _turn(), self._context("gpt-5.6-sol", "high"),
+            _turn(), self._context("gpt-6-astra", "high"),
+            _turn(), self._context("gpt-6-astra", "xhigh"),
+        ]
+        settings = [e for e in _events(*entries) if e["type"] == "turn_settings"]
+        self.assertEqual([(s["model"], s["effort"]) for s in settings],
+                         [("gpt-5.6-sol", "high"), ("gpt-6-astra", "high"), ("gpt-6-astra", "xhigh")])
+        html = _html(*entries)
+        self.assertIn('<span class="info-value">gpt-5.6-sol (high effort)</span>', html)
+        self.assertIn("Switched model gpt-5.6-sol \u2192 gpt-6-astra", html)
+        self.assertIn("Switched effort high \u2192 xhigh", html)
+        self.assertIn('data-kind="settings"', html)
+
+    def test_header_falls_back_to_provider(self) -> None:
+        meta, events = extract_conversation(
+            [{"type": "session_meta", "payload": {"id": "s", "model_provider": "openai"}}, _turn()]
+        )
+        self.assertIn('<span class="info-value">openai</span>', build_html(meta, events))
+
+
+class MemoryCitationRenderTests(unittest.TestCase):
+    def test_citations_fold_under_the_answer(self) -> None:
+        answer = ("All set.\n\n<oai-mem-citation>\n<citation_entries>\nMEMORY.md:1-2|note=[why]\n"
+                  "</citation_entries>\n<rollout_ids>\nr1\n</rollout_ids>\n</oai-mem-citation>")
+        html = _html(_turn(), _response_item({"type": "message", "role": "assistant", "phase": "final_answer",
+                                              "content": [{"type": "output_text", "text": answer}]}))
+        self.assertNotIn("oai-mem-citation", html)
+        self.assertIn("Memory citations: 1 memory entry from 1 earlier session", html)
+        self.assertIn('<span class="citation-location">MEMORY.md:1-2</span> \u2014 why', html)
+
+
+class ReasoningMarkdownTests(unittest.TestCase):
+    def test_reasoning_renders_markdown(self) -> None:
+        html = _html(_turn(), _reasoning("**Planning the CSV writer**\n\nUse `csv.writer`."))
+        self.assertIn("<strong>Planning the CSV writer</strong>", html)
+        self.assertIn("<code>csv.writer</code>", html)
+        self.assertIn("\U0001f4ad Planning the CSV writer", html)
+
+
 class RecordKindTests(unittest.TestCase):
     def test_new_kinds_are_handled_or_ignored(self) -> None:
         entries = [
@@ -230,6 +277,7 @@ class RecordKindTests(unittest.TestCase):
             _item({"type": kind}) for kind in ("EnteredReviewMode", "ExitedReviewMode", "HookPrompt")
         ] + [
             {"type": "realtime_item", "payload": {"type": "realtime_session_started"}},
+            {"type": "turn_context", "payload": {"model": "m"}},
             _response_item({"type": "image_generation_call"}),
         ]
         self.assertEqual(unrecognized_record_kinds(entries), Counter())