railmux 0.4.2.dev5__tar.gz → 0.4.2.dev7__tar.gz

{railmux-0.4.2.dev5/src/railmux.egg-info → railmux-0.4.2.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.2.dev5
+Version: 0.4.2.dev7
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.4.2.dev7/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.2.dev7"

{railmux-0.4.2.dev5 → railmux-0.4.2.dev7}/src/railmux/fast_display_server.py

@@ -374,7 +374,7 @@ class _TranscriptFormatCacheEntry:
 _TRANSCRIPT_CACHE: OrderedDict[tuple[str, int], _TranscriptCacheEntry] = OrderedDict()
 _TRANSCRIPT_CACHE_LIMIT = 4
 _TRANSCRIPT_FORMAT_CACHE: OrderedDict[
-    tuple[str, str], _TranscriptFormatCacheEntry
+    tuple[str, str, int | None], _TranscriptFormatCacheEntry
 ] = OrderedDict()
 _TRANSCRIPT_FORMAT_CACHE_LIMIT = 2
 _TRANSCRIPT_FORMAT_CACHE_MAX_CHARS = 4 * 1024 * 1024
@@ -1699,7 +1699,9 @@ def _transcript_rows(
         ):
             _TRANSCRIPT_CACHE.move_to_end(key)
             return cached
-        format_key = (str(source.path), source.provider)
+        # Claude history is pre-wrapped to the pane; Codex text is not.
+        format_width = width if source.provider == "claude" else None
+        format_key = (str(source.path), source.provider, format_width)
         formatted_entry = _TRANSCRIPT_FORMAT_CACHE.get(format_key)
         if formatted_entry is not None and formatted_entry.identity == identity:
             _TRANSCRIPT_FORMAT_CACHE.move_to_end(format_key)
@@ -1715,6 +1717,7 @@ def _transcript_rows(
                     io.StringIO(raw),
                     source.provider,
                     claude_native=source.provider == "claude",
+                    width=format_width,
                 )
             )
             if len(formatted) <= _TRANSCRIPT_FORMAT_CACHE_MAX_CHARS:
@@ -1773,10 +1776,12 @@ def _transcript_rows_before_screen(
 
     Transcript-backed history appends the live viewport after the transcript,
     whose tail usually holds the same newest message. Locate the screen's
-    text in the transcript tail through distinctive anchor rows and cut the
-    transcript where the screen begins. Two anchors must agree on that start
-    unless one long anchor is the only candidate; without a credible match
-    every transcript row is kept.
+    text in the transcript tail through distinctive anchor rows: the largest
+    group of anchors that agree on where the screen starts wins, so screen
+    regions the transcript renders differently (such as a diff) cannot veto
+    the match. A lone anchor must be long and unopposed. From the earliest agreeing anchor
+    the cut walks back over screen rows that also precede it in the
+    transcript; without a credible match every transcript row is kept.
     """
     total = len(transcript_rows)
     window = max(
@@ -1791,26 +1796,42 @@ def _transcript_rows_before_screen(
         parts.append(text)
         offset += len(text)
     haystack = "".join(parts)
+    screen_texts = [_overlap_text(row) for row in screen_rows]
     screen_offset = 0
-    starts: list[tuple[int, int]] = []
-    for row in screen_rows:
-        text = _overlap_text(row)
+    # (screen row, transcript position, anchor length, implied screen start)
+    anchors: list[tuple[int, int, int, int]] = []
+    for index, text in enumerate(screen_texts):
         if len(text) >= _OVERLAP_ANCHOR_CHARS and haystack.count(text) == 1:
-            starts.append((haystack.index(text) - screen_offset, len(text)))
-            if len(starts) == 2:
-                break
+            position = haystack.index(text)
+            anchors.append(
+                (index, position, len(text), position - screen_offset))
         screen_offset += len(text)
-    if not starts:
+    if not anchors:
         return total
-    if len(starts) == 1:
-        if starts[0][1] < _OVERLAP_SINGLE_ANCHOR_CHARS:
-            return total
-    else:
+
+    def agreeing(anchor: tuple[int, int, int, int]) -> list:
         # Allow small rendering differences (list numbering, bullets).
-        tolerance = 16 + abs(starts[0][0]) // 20
-        if abs(starts[0][0] - starts[1][0]) > tolerance:
-            return total
-    start = max(0, starts[0][0])
+        tolerance = 16 + abs(anchor[3]) // 20
+        return [
+            other for other in anchors
+            if abs(other[3] - anchor[3]) <= tolerance
+        ]
+
+    group = max(
+        (agreeing(anchor) for anchor in anchors),
+        key=lambda members: (len(members), max(m[3] for m in members)),
+    )
+    if len(group) == 1 and (
+        len(anchors) > 1 or group[0][2] < _OVERLAP_SINGLE_ANCHOR_CHARS
+    ):
+        return total
+    index, start, _length, _implied = min(group)
+    for text in reversed(screen_texts[:index]):
+        if not text:
+            continue
+        if start < len(text) or haystack[start - len(text):start] != text:
+            break
+        start -= len(text)
     # Keep a row that begins before the screen: it may carry text the screen
     # no longer shows, and a partial duplicate is better than a loss.
     keep = len(row_starts)

{railmux-0.4.2.dev5 → railmux-0.4.2.dev7}/src/railmux/transcript.py

@@ -235,15 +235,220 @@ _MD_INLINE_RE = re.compile(
     r"|\*\*(?=\S)(.+?)(?<=\S)\*\*"
     r"|__(?=\S)(.+?)(?<=\S)__"
     r"|(?<![\w*])\*(?=[^\s*])(.+?)(?<=[^\s*])\*(?![\w*])"
+    r"|\[([^\]\n]+)\]\(([^)\s]+)\)"
 )
+_MD_TABLE_SEPARATOR_RE = re.compile(
+    r"^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$")
+_MD_TABLE_CELL_SPLIT_RE = re.compile(r"(?<!\\)\|")
+_LIST_HANG_RE = re.compile(r" *(?:(?:[-*+]|\d+[.)]) +)?")
+_SGR_RE = re.compile(r"\x1b\[[0-9;]*m")
+_WRAP_TOKEN_RE = re.compile(r"\x1b\[[0-9;]*m| +|[^ \x1b]+")
+_TASK_SUMMARY_RE = re.compile(r"<summary>(.*?)</summary>", re.DOTALL)
+
+_char_width_function = None
+
+
+def _char_width(char: str) -> int:
+    """Terminal cell width of *char*, matching pyte's ``wcwidth`` when present."""
+    global _char_width_function
+    if _char_width_function is None:
+        try:
+            from wcwidth import wcwidth as _char_width_function
+        except ImportError:
+            import unicodedata
+
+            def _char_width_function(value: str) -> int:
+                if unicodedata.combining(value):
+                    return 0
+                return 2 if unicodedata.east_asian_width(value) in "WF" else 1
+    return max(0, _char_width_function(char))
+
+
+def _visible_width(text: str) -> int:
+    # Claude pads an emoji-presentation selector (as in "⚠️") to two cells.
+    return sum(
+        1 if char == "\ufe0f" else _char_width(char)
+        for char in _SGR_RE.sub("", text)
+    )
+
+
+def _wrap_styled(line: str, width: int, hang: int) -> list[str]:
+    """Word-wrap one styled line the way Claude's Ink renderer does.
+
+    Rows break at spaces; only a word wider than a whole row is split. Rows
+    after the first are indented by *hang* columns so list items and message
+    bodies keep their hanging indent instead of restarting at column zero.
+    """
+    line = line.expandtabs(8)
+    if width <= 0 or _visible_width(line) <= width:
+        return [line]
+    if hang >= width // 2:
+        hang = 0
+    rows: list[str] = []
+    row: list[str] = []
+    column = 0
+
+    def newline() -> None:
+        nonlocal row, column
+        rows.append("".join(row).rstrip(" "))
+        row = [" " * hang]
+        column = hang
+
+    for token in _WRAP_TOKEN_RE.findall(line):
+        if token.startswith("\x1b"):
+            row.append(token)
+            continue
+        token_width = _visible_width(token)
+        if token.startswith(" "):
+            if column + token_width <= width:
+                row.append(token)
+                column += token_width
+            else:
+                newline()
+            continue
+        capacity = width - hang
+        if column + token_width > width and column > hang:
+            # Like wrap-ansi: start a word on a fresh row when that fits it,
+            # or when splitting it from there needs fewer breaks.
+            breaks_here = 1 + (token_width - (width - column) - 1) // capacity
+            if (
+                token_width <= capacity
+                or (token_width - 1) // capacity < breaks_here
+            ):
+                newline()
+        for char in token:
+            char_width = _char_width(char)
+            if column + char_width > width and column > hang:
+                newline()
+            row.append(char)
+            column += char_width
+    rows.append("".join(row).rstrip(" "))
+    return rows
+
+
+def _hang_for(row: str, prefix: int) -> int:
+    """Hanging indent for a row whose own content starts after *prefix* cells."""
+    content = _SGR_RE.sub("", row)[prefix:]
+    return prefix + len(_LIST_HANG_RE.match(content).group(0))
+
+
+def _close_fragments(fragments: list[str]) -> list[str]:
+    """Make each wrapped fragment carry and close its own SGR state.
+
+    Table cells sit beside other cells on one row, so a style that continues
+    onto a cell's next fragment must not leak across the borders between.
+    """
+    closed: list[str] = []
+    active: list[str] = []
+    for fragment in fragments:
+        prefix = "".join(active)
+        for code in _SGR_RE.findall(fragment):
+            if code == RESET:
+                active.clear()
+            else:
+                active.append(code)
+        closed.append(f"{prefix}{fragment}{RESET}")
+    return closed
+
+
+def _table_cells(line: str) -> list[str]:
+    stripped = line.strip()
+    if stripped.startswith("|"):
+        stripped = stripped[1:]
+    if stripped.endswith("|") and not stripped.endswith("\\|"):
+        stripped = stripped[:-1]
+    return [
+        cell.strip().replace("\\|", "|")
+        for cell in _MD_TABLE_CELL_SPLIT_RE.split(stripped)
+    ]
+
+
+def _markdown_table(lines: list[str], width: int) -> list[str] | None:
+    """Draw a markdown table as Claude does: a box whose cells wrap to fit.
+
+    *lines* holds the header, the separator and the body rows. ``None`` means
+    the columns cannot fit *width*, and the caller keeps the source text.
+    """
+    header = [
+        f"{BOLD}{_markdown_inline(cell, bold=True)}{BOLD_OFF}"
+        for cell in _table_cells(lines[0])
+    ]
+    count = len(header)
+    body = []
+    for line in lines[2:]:
+        cells = [_markdown_inline(cell) for cell in _table_cells(line)]
+        body.append((cells + [""] * count)[:count])
+    # Claude keeps two spare cells beside the borders and padding.
+    available = width - 3 - 3 * count
+    if available < 3 * count:
+        return None
+    rows = [header, *body]
+    natural = [
+        max(1, *(_visible_width(row[index]) for row in rows))
+        for index in range(count)
+    ]
+    longest_word = [
+        max(
+            _visible_width(word)
+            for row in rows
+            for word in [*_SGR_RE.sub("", row[index]).split(" "), ""]
+        )
+        for index in range(count)
+    ]
+    minimum = [max(1, min(a, b)) for a, b in zip(natural, longest_word)]
+    widths = natural
+    if sum(natural) > available and sum(minimum) <= available:
+        # Claude's split: every column fits its longest word, and the spare
+        # cells go to each column in proportion to how much more it wants.
+        spare = available - sum(minimum)
+        wanted = sum(n - m for n, m in zip(natural, minimum))
+        widths = [
+            m + spare * (n - m) // wanted for n, m in zip(natural, minimum)
+        ]
+    elif sum(natural) > available:
+        low, high = 3, max(natural)
+        while low < high:
+            cap = (low + high + 1) // 2
+            if sum(min(value, cap) for value in natural) <= available:
+                low = cap
+            else:
+                high = cap - 1
+        widths = [min(value, low) for value in natural]
+        spare = available - sum(widths)
+        for index, value in enumerate(natural):
+            if spare and value > widths[index]:
+                widths[index] += 1
+                spare -= 1
+
+    def border(left: str, middle: str, right: str) -> str:
+        return left + middle.join("─" * (cell + 2) for cell in widths) + right
+
+    rendered = [border("┌", "┬", "┐")]
+    for row_index, row in enumerate([header, *body]):
+        if row_index:
+            rendered.append(border("├", "┼", "┤"))
+        fragments = [
+            _close_fragments(_wrap_styled(cell, widths[index], 0))
+            for index, cell in enumerate(row)
+        ]
+        for line_index in range(max(len(cell) for cell in fragments)):
+            parts = []
+            for index, cell in enumerate(fragments):
+                text = cell[line_index] if line_index < len(cell) else ""
+                padding = " " * (widths[index] - _visible_width(text))
+                parts.append(f" {text}{padding} ")
+            rendered.append("│" + "│".join(parts) + "│")
+    rendered.append(border("└", "┴", "┘"))
+    return rendered
 
 
 def _markdown_inline(line: str, *, bold: bool = False) -> str:
-    """Style inline code, bold and italic spans like Claude's markdown view.
+    """Style inline code, bold, italic and link spans like Claude's view.
 
     Only targeted "off" codes close each span, so an enclosing style (for
     example a bold heading) survives an inner code or italic span. *bold*
     marks an already-bold context whose nested strong spans must not end it.
+    A link shows only its text, as Claude's clickable link does.
     """
 
     def replace(match: re.Match[str]) -> str:
@@ -251,6 +456,8 @@ def _markdown_inline(line: str, *, bold: bool = False) -> str:
             match.group(2), match.group(3), match.group(4), match.group(5))
         if code is not None:
             return f"{CLAUDE_ACCENT}{code}{FG_DEFAULT}"
+        if match.group(6) is not None:
+            return _markdown_inline(match.group(6), bold=bold)
         if strong is not None or strong_alt is not None:
             inner = _markdown_inline(
                 strong if strong is not None else strong_alt, bold=True)
@@ -260,48 +467,84 @@ def _markdown_inline(line: str, *, bold: bool = False) -> str:
     return _MD_INLINE_RE.sub(replace, line)
 
 
-def _markdown_lines(lines: list[str]) -> list[str]:
+def _markdown_lines(lines: list[str], width: int | None = None) -> list[str]:
     """Approximate Claude Code's markdown rendering for sanitized text lines.
 
     Styled lines end with a full reset: every span is already closed, and the
-    reset keeps row wrappers from carrying an ever-growing SGR prefix.
+    reset keeps row wrappers from carrying an ever-growing SGR prefix. Tables
+    are drawn as boxes only when the target *width* is known.
     """
     rendered: list[str] = []
     in_fence = False
-    for line in lines:
+    index = 0
+    while index < len(lines):
+        line = lines[index]
+        index += 1
         if _MD_FENCE_RE.match(line):
             in_fence = not in_fence
             continue
         if in_fence:
             rendered.append(line)
             continue
+        if (
+            width is not None
+            and line.lstrip().startswith("|")
+            and index < len(lines)
+            and _MD_TABLE_SEPARATOR_RE.match(lines[index])
+        ):
+            end = index + 1
+            while end < len(lines) and lines[end].lstrip().startswith("|"):
+                end += 1
+            table = _markdown_table(lines[index - 1:end], width)
+            if table is not None:
+                rendered.extend(table)
+                index = end
+                continue
         heading = _MD_HEADING_RE.match(line)
         if heading:
             inner = _markdown_inline(heading.group(2), bold=True)
             rendered.append(f"{BOLD}{inner}{RESET}")
+            # Claude always leaves a blank line below a heading.
+            if index < len(lines) and lines[index].strip():
+                rendered.append("")
             continue
         styled = _markdown_inline(line)
         rendered.append(styled + RESET if styled != line else line)
     return rendered
 
 
+def _wrap_rows(rows: list[str], width: int | None, prefix: int) -> list[str]:
+    """Pre-wrap rendered rows when the pane *width* is known."""
+    if width is None:
+        return rows
+    return [
+        wrapped
+        for row in rows
+        for wrapped in _wrap_styled(row, width, _hang_for(row, prefix))
+    ]
+
+
 def _claude_native_block(
     marker: str, text: str, *, colour: str, markdown: bool = False,
+    width: int | None = None,
 ) -> str:
     """Render a static, non-interactive approximation of one Claude TUI block."""
     lines = _sanitize_text(text).strip().splitlines()
     if markdown:
-        lines = _markdown_lines(lines)
+        lines = _markdown_lines(
+            lines, None if width is None else width - 2)
     if not lines:
         return ""
-    continuation = "\n".join(f"  {line}" for line in lines[1:])
-    result = f"\n{colour}{marker}{RESET} {lines[0]}"
-    if continuation:
-        result += "\n" + continuation
-    return result + "\n"
+    rows = [
+        f"{colour}{marker}{RESET} {lines[0]}",
+        *(f"  {line}" for line in lines[1:]),
+    ]
+    return "\n" + "\n".join(_wrap_rows(rows, width, 2)) + "\n"
 
 
-def _render_claude_native_user(record: dict) -> str | None:
+def _render_claude_native_user(
+    record: dict, width: int | None = None,
+) -> str | None:
     message = record.get("message")
     if not isinstance(message, dict):
         return None
@@ -316,11 +559,21 @@ def _render_claude_native_user(record: dict) -> str | None:
         ).strip()
     else:
         text = ""
-    return _claude_native_block("❯", text, colour=CLAUDE_ACCENT) or None
+    if text.startswith("<task-notification>"):
+        # Claude shows a finished background task as one status line, not as
+        # a prompt carrying the notification's XML.
+        summary = _TASK_SUMMARY_RE.search(text)
+        if summary is None:
+            return None
+        return _claude_native_block(
+            "●", summary.group(1).strip(), colour=CLAUDE_MUTED, width=width,
+        ) or None
+    return _claude_native_block(
+        "❯", text, colour=CLAUDE_ACCENT, width=width) or None
 
 
 def _render_claude_native_assistant(
-    record: dict, calls: dict[str, str],
+    record: dict, calls: dict[str, str], width: int | None = None,
 ):
     """Yield Claude-like read-only text/tool rows from semantic JSONL records."""
     message = record.get("message")
@@ -336,7 +589,7 @@ def _render_claude_native_assistant(
         if block_type == "text":
             rendered = _claude_native_block(
                 "●", str(block.get("text", "")), colour=CLAUDE_ACCENT,
-                markdown=True,
+                markdown=True, width=width,
             )
             if rendered:
                 yield rendered
@@ -352,20 +605,19 @@ def _render_claude_native_assistant(
         if isinstance(tool_input, dict):
             for key in (
                 "description", "command", "query", "pattern",
-                "file_path", "path", "url",
+                "file_path", "path", "url", "skill",
             ):
                 value = tool_input.get(key)
                 if isinstance(value, str) and value.strip():
                     summary = _sanitize_text(value.strip()).replace("\n", " ")
                     break
         suffix = f"({_truncate(summary, 180)})" if summary else ""
-        yield (
-            f"\n{CLAUDE_ACCENT}●{RESET} {BOLD}{name}{RESET}{suffix}\n"
-        )
+        row = f"{CLAUDE_ACCENT}●{RESET} {BOLD}{name}{RESET}{suffix}"
+        yield "\n" + "\n".join(_wrap_rows([row], width, 2)) + "\n"
 
 
 def _render_claude_native_tool_results(
-    record: dict, calls: dict[str, str],
+    record: dict, calls: dict[str, str], width: int | None = None,
 ):
     message = record.get("message")
     if not isinstance(message, dict):
@@ -382,13 +634,16 @@ def _render_claude_native_tool_results(
         tool_id = block.get("tool_use_id")
         if isinstance(tool_id, str):
             calls.pop(tool_id, None)
-        lines = _sanitize_text(_truncate(text, 500)).splitlines()
+        # _truncate sanitizes before appending its own styled ellipsis.
+        lines = _truncate(text, 500).splitlines()
         if not lines:
             continue
         colour = RED if block.get("is_error") is True else CLAUDE_MUTED
-        yield f"  {colour}⎿  {lines[0]}\n"
-        for line in lines[1:]:
-            yield f"     {line}\n"
+        rows = [f"  ⎿  {lines[0]}", *(f"     {line}" for line in lines[1:])]
+        yield colour
+        for row in rows:
+            for wrapped in _wrap_rows([row], width, 5):
+                yield f"{wrapped}\n"
         yield RESET
 
 
@@ -435,36 +690,36 @@ def _claude_current_branch(records: list[dict]) -> list[dict]:
 
 
 def _render_claude_records(
-    records: list[dict], *, claude_native: bool,
+    records: list[dict], *, claude_native: bool, width: int | None = None,
 ):
-    """Render only the active Claude branch from buffered JSONL records."""
+    """Render only the active Claude branch from buffered JSONL records.
+
+    *width* pre-wraps native rows to the pane like Claude's own renderer.
+    """
     calls: dict[str, str] = {}
     for record in _claude_current_branch(records):
         rtype = record.get("type", "")
         if rtype in _SKIP_TYPES:
             continue
-        if _is_real_user(record):
-            rendered = (
-                _render_claude_native_user(record)
-                if claude_native
-                else _render_user(record)
-            )
+        if not claude_native:
+            if _is_real_user(record):
+                rendered = _render_user(record)
+                if rendered:
+                    yield rendered
+            if rtype == "user":
+                yield from _render_claude_tool_results(record, calls)
+            elif rtype == "assistant":
+                yield from _render_assistant_blocks(record, calls)
+            continue
+        # Claude hides meta prompts such as a loaded skill's instructions.
+        if _is_real_user(record) and record.get("isMeta") is not True:
+            rendered = _render_claude_native_user(record, width)
             if rendered:
                 yield rendered
         if rtype == "user":
-            renderer = (
-                _render_claude_native_tool_results
-                if claude_native
-                else _render_claude_tool_results
-            )
-            yield from renderer(record, calls)
+            yield from _render_claude_native_tool_results(record, calls, width)
         elif rtype == "assistant":
-            renderer = (
-                _render_claude_native_assistant
-                if claude_native
-                else _render_assistant_blocks
-            )
-            yield from renderer(record, calls)
+            yield from _render_claude_native_assistant(record, calls, width)
 
 
 def format_transcript(
@@ -472,6 +727,7 @@ def format_transcript(
     fmt: str | None = None,
     *,
     claude_native: bool = False,
+    width: int | None = None,
 ):
     """Read a session JSONL and yield ANSI-formatted strings.
 
@@ -482,6 +738,9 @@ def format_transcript(
     types actually present in the stream, so a bounded Codex rollout whose
     leading ``session_meta`` header was omitted still renders as Codex.
 
+    *width* (Claude native history only) wraps rows and draws tables for a
+    pane of that many cells.
+
     Callers should write each chunk to stdout, e.g.::
 
         for chunk in format_transcript(path_or_file):
@@ -538,7 +797,7 @@ def format_transcript(
             claude_records.append(record)
         if _codex is False:
             yield from _render_claude_records(
-                claude_records, claude_native=claude_native)
+                claude_records, claude_native=claude_native, width=width)
     except OSError:
         yield f"{YELLOW}Could not read: {source}{RESET}\n"
     finally:

{railmux-0.4.2.dev5 → railmux-0.4.2.dev7/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.2.dev5
+Version: 0.4.2.dev7
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

{railmux-0.4.2.dev5 → railmux-0.4.2.dev7}/tests/test_fast_display_server.py

@@ -1672,6 +1672,28 @@ def test_transcript_overlap_rejects_disagreeing_anchors():
     assert fast_display_server._transcript_rows_before_screen(rows, screen) == 3
 
 
+def test_transcript_overlap_ignores_screen_regions_rendered_differently():
+    rows = (
+        b"older message mentioning edited readme line",
+        b"filler " * 20,
+        b"truncated tool output",
+        b"",
+        b"newest message first distinctive row",
+        b"newest message second distinctive row",
+    )
+    # A diff view tops the screen: one of its rows also occurs much earlier
+    # in the transcript, disagreeing with the anchors in the newest message.
+    screen = (
+        b"older message mentioning edited readme line",
+        b"+ added diff row only the screen shows",
+        b"",
+        b"newest message first distinctive row",
+        b"newest message second distinctive row",
+    )
+
+    assert fast_display_server._transcript_rows_before_screen(rows, screen) == 3
+
+
 @pytest.mark.parametrize(
     ("policy", "choice_required"),
     [("ask", True), ("native", False)],
@@ -1843,7 +1865,7 @@ def test_transcript_cache_evicts_least_recent_file_width(monkeypatch, tmp_path):
         fast_display_server._TRANSCRIPT_CACHE.clear()
 
 
-def test_transcript_format_cache_reuses_exact_identity_across_widths(
+def test_transcript_format_cache_reuses_exact_identity_per_width(
     monkeypatch, tmp_path,
 ):
     pyte = fast_display_server._extended_pyte(__import__("pyte"))
@@ -1871,16 +1893,22 @@ def test_transcript_format_cache_reuses_exact_identity_across_widths(
         assert fast_display_server._transcript_rows(
             pyte, marker, 40, allow_stale=False
         ) is not None
+        fast_display_server._TRANSCRIPT_CACHE.clear()
         assert fast_display_server._transcript_rows(
-            pyte, marker, 10, allow_stale=False
+            pyte, marker, 40, allow_stale=False
         ) is not None
         assert len(calls) == 1
+        # Claude history is wrapped for the pane, so a new width re-formats.
+        assert fast_display_server._transcript_rows(
+            pyte, marker, 10, allow_stale=False
+        ) is not None
+        assert len(calls) == 2
 
         path.write_text('{"type":"user","changed":true}\n')
         assert fast_display_server._transcript_rows(
-            pyte, marker, 20, allow_stale=False
+            pyte, marker, 10, allow_stale=False
         ) is not None
-        assert len(calls) == 2
+        assert len(calls) == 3
     finally:
         fast_display_server._TRANSCRIPT_CACHE.clear()
         fast_display_server._TRANSCRIPT_FORMAT_CACHE.clear()