wafer-core 0.1.46__py3-none-any.whl → 0.1.47__py3-none-any.whl

wafer_core/rollouts/_pytui/app.py

@@ -722,7 +722,15 @@ class App:
         """Send message through update, execute resulting command."""
         if not self._running:
             return
+        old_model = self._model
         self._model, cmd = self._update_fn(self._model, msg)
+        _log(
+            "dispatch",
+            msg_type=type(msg).__name__,
+            msg_data=repr(msg)[:200],
+            cmd_kind=cmd._kind,
+            model_changed=self._model is not old_model,
+        )
         self._execute_cmd(cmd)
 
     def _execute_cmd(self, cmd: Cmd) -> None:

wafer_core/rollouts/_pytui/viewport.py

@@ -0,0 +1,186 @@
+"""Viewport component for pytui - Elm-style scrollable text view.
+
+A frozen dataclass + pure functions approach matching pytui's architecture.
+Based on patterns from charmbracelet/bubbles viewport.
+
+Usage:
+    # In your Model
+    @dataclass(frozen=True)
+    class Model:
+        viewport: Viewport = Viewport()
+
+    # In update()
+    case KeyPress(key="j"):
+        new_vp = viewport_scroll_down(model.viewport, 1, visible_height)
+        return replace(model, viewport=new_vp), Cmd.none()
+
+    # In view()
+    visible = viewport_visible_lines(model.viewport, visible_height)
+    for line in visible:
+        lines.append(line)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+
+
+def _clamp(value: int, min_val: int, max_val: int) -> int:
+    """Clamp value to [min_val, max_val]."""
+    if min_val > max_val:
+        min_val, max_val = max_val, min_val
+    return max(min_val, min(value, max_val))
+
+
+@dataclass(frozen=True)
+class Viewport:
+    """Immutable viewport state.
+
+    Attributes:
+        lines: Content as tuple of strings (one per line)
+        y_offset: Vertical scroll position (0 = top)
+        auto_follow: If True, scroll to bottom when new content added
+    """
+
+    lines: tuple[str, ...] = ()
+    y_offset: int = 0
+    auto_follow: bool = True
+
+
+# ── Query functions ──────────────────────────────────────────────────────────
+
+
+def viewport_max_offset(vp: Viewport, visible_height: int) -> int:
+    """Maximum valid y_offset for this viewport."""
+    return max(0, len(vp.lines) - visible_height)
+
+
+def viewport_at_top(vp: Viewport) -> bool:
+    """Check if viewport is scrolled to top."""
+    return vp.y_offset <= 0
+
+
+def viewport_at_bottom(vp: Viewport, visible_height: int) -> bool:
+    """Check if viewport is scrolled to bottom."""
+    return vp.y_offset >= viewport_max_offset(vp, visible_height)
+
+
+def viewport_scroll_percent(vp: Viewport, visible_height: int) -> float:
+    """Get scroll position as percentage (0.0 to 1.0)."""
+    max_off = viewport_max_offset(vp, visible_height)
+    if max_off == 0:
+        return 1.0
+    return vp.y_offset / max_off
+
+
+def viewport_visible_lines(vp: Viewport, visible_height: int) -> list[str]:
+    """Get the lines currently visible in the viewport."""
+    start = _clamp(vp.y_offset, 0, len(vp.lines))
+    end = _clamp(start + visible_height, start, len(vp.lines))
+    return list(vp.lines[start:end])
+
+
+# ── Scroll operations ────────────────────────────────────────────────────────
+
+
+def viewport_scroll_down(vp: Viewport, n: int, visible_height: int) -> Viewport:
+    """Scroll down by n lines. Returns unchanged viewport if already at bottom."""
+    if viewport_at_bottom(vp, visible_height) or n <= 0:
+        return vp
+    max_off = viewport_max_offset(vp, visible_height)
+    new_offset = _clamp(vp.y_offset + n, 0, max_off)
+    # Re-enable auto_follow if we hit bottom
+    auto_follow = new_offset >= max_off
+    return replace(vp, y_offset=new_offset, auto_follow=auto_follow)
+
+
+def viewport_scroll_up(vp: Viewport, n: int) -> Viewport:
+    """Scroll up by n lines. Returns unchanged viewport if already at top."""
+    if viewport_at_top(vp) or n <= 0:
+        return vp
+    new_offset = max(0, vp.y_offset - n)
+    # Disable auto_follow when scrolling up
+    return replace(vp, y_offset=new_offset, auto_follow=False)
+
+
+def viewport_page_down(vp: Viewport, visible_height: int) -> Viewport:
+    """Scroll down by one page."""
+    return viewport_scroll_down(vp, visible_height, visible_height)
+
+
+def viewport_page_up(vp: Viewport, visible_height: int) -> Viewport:
+    """Scroll up by one page."""
+    return viewport_scroll_up(vp, visible_height)
+
+
+def viewport_half_page_down(vp: Viewport, visible_height: int) -> Viewport:
+    """Scroll down by half a page (Ctrl+D style)."""
+    return viewport_scroll_down(vp, visible_height // 2, visible_height)
+
+
+def viewport_half_page_up(vp: Viewport, visible_height: int) -> Viewport:
+    """Scroll up by half a page (Ctrl+U style)."""
+    return viewport_scroll_up(vp, visible_height // 2)
+
+
+def viewport_goto_top(vp: Viewport) -> Viewport:
+    """Jump to top of content."""
+    if viewport_at_top(vp):
+        return vp
+    return replace(vp, y_offset=0, auto_follow=False)
+
+
+def viewport_goto_bottom(vp: Viewport, visible_height: int) -> Viewport:
+    """Jump to bottom of content, re-enable auto_follow."""
+    max_off = viewport_max_offset(vp, visible_height)
+    return replace(vp, y_offset=max_off, auto_follow=True)
+
+
+# ── Content operations ───────────────────────────────────────────────────────
+
+
+def viewport_set_content(vp: Viewport, lines: tuple[str, ...], visible_height: int) -> Viewport:
+    """Replace all content. Adjusts scroll if past new content end."""
+    new_vp = replace(vp, lines=lines)
+    max_off = viewport_max_offset(new_vp, visible_height)
+
+    # If scrolled past content, jump to bottom
+    if new_vp.y_offset > max_off:
+        return replace(new_vp, y_offset=max_off)
+
+    # If auto_follow enabled, stay at bottom
+    if new_vp.auto_follow:
+        return replace(new_vp, y_offset=max_off)
+
+    return new_vp
+
+
+def viewport_append_line(vp: Viewport, line: str, visible_height: int) -> Viewport:
+    """Append a single line. Auto-scrolls if auto_follow enabled."""
+    new_lines = vp.lines + (line,)
+    new_vp = replace(vp, lines=new_lines)
+
+    if vp.auto_follow:
+        max_off = viewport_max_offset(new_vp, visible_height)
+        return replace(new_vp, y_offset=max_off)
+
+    return new_vp
+
+
+def viewport_append_lines(vp: Viewport, lines: tuple[str, ...], visible_height: int) -> Viewport:
+    """Append multiple lines. Auto-scrolls if auto_follow enabled."""
+    if not lines:
+        return vp
+    new_lines = vp.lines + lines
+    new_vp = replace(vp, lines=new_lines)
+
+    if vp.auto_follow:
+        max_off = viewport_max_offset(new_vp, visible_height)
+        return replace(new_vp, y_offset=max_off)
+
+    return new_vp
+
+
+def viewport_clear(vp: Viewport) -> Viewport:
+    """Clear all content and reset scroll."""
+    return Viewport(lines=(), y_offset=0, auto_follow=True)

wafer_core/rollouts/agents.py

@@ -844,6 +844,18 @@ async def process_pending_tools(
                 if "content" in tool_call.args:
                     result_summary["content"] = tool_call.args["content"]
 
+            # For edit, capture file path and diff stats
+            elif tool_call.name == "edit":
+                if "file_path" in tool_call.args:
+                    result_summary["path"] = tool_call.args["file_path"]
+                # Compute +/- lines from old_string and new_string
+                old_str = tool_call.args.get("old_string", "")
+                new_str = tool_call.args.get("new_string", "")
+                old_lines = old_str.count("\n") + (1 if old_str else 0)
+                new_lines = new_str.count("\n") + (1 if new_str else 0)
+                result_summary["lines_removed"] = old_lines
+                result_summary["lines_added"] = new_lines
+
             # Extract key metrics from details (e.g., compiled, correct for kernelbench)
             if tool_result.details:
                 for k, v in tool_result.details.items():

wafer_core/rollouts/progress_app.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import signal
 import subprocess
 import sys
@@ -71,6 +72,57 @@ SAMPLE_EVENT_TYPES = frozenset({
 })
 
 
+# ── Utilities ────────────────────────────────────────────────────────────────
+
+# Regex for matching ANSI escape codes
+_ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _clamp(value: int, min_val: int, max_val: int) -> int:
+    """Clamp value to [min_val, max_val]."""
+    assert min_val <= max_val, f"min_val ({min_val}) > max_val ({max_val})"
+    return max(min_val, min(value, max_val))
+
+
+def _visible_len(s: str) -> int:
+    """Return visible length of string (excluding ANSI codes)."""
+    return len(_ANSI_ESCAPE.sub("", s))
+
+
+def _ansi_slice(s: str, start: int) -> str:
+    """Slice a string with ANSI codes from visible position `start`.
+
+    Returns substring starting at visible character `start`, preserving
+    any ANSI codes that were active at that position.
+    """
+    if start <= 0:
+        return s
+
+    visible_pos = 0
+    i = 0
+    active_codes: list[str] = []  # Track active ANSI codes
+
+    while i < len(s) and visible_pos < start:
+        # Check for ANSI escape sequence
+        match = _ANSI_ESCAPE.match(s, i)
+        if match:
+            code = match.group()
+            if code == RESET:
+                active_codes.clear()
+            else:
+                active_codes.append(code)
+            i = match.end()
+        else:
+            visible_pos += 1
+            i += 1
+
+    # Return remaining string with any active codes prepended
+    result = s[i:]
+    if active_codes:
+        result = "".join(active_codes) + result
+    return result
+
+
 # ── State ────────────────────────────────────────────────────────────────────
 
 
@@ -196,9 +248,23 @@ def derive_state(events: list[dict[str, Any]]) -> RenderState:
     return state
 
 
-def _format_sample_row(sample: SampleState, width: int, selected: bool = False) -> str:
-    """Format a single sample row."""
-    name = sample.name[:25].ljust(25)
+def _format_sample_row(
+    sample: SampleState,
+    width: int,
+    selected: bool = False,
+    marquee_offset: int = 0,
+) -> tuple[str, int]:
+    """Format a single sample row.
+
+    Returns (formatted_row, overflow_chars) where overflow_chars is how many
+    characters extend beyond the visible width (for marquee animation).
+    """
+    # For selected rows, don't truncate name - show full content with marquee
+    if selected:
+        name = sample.name
+    else:
+        name = sample.name[:25].ljust(25)
+
     turn_info = f"T:{sample.turn}"
 
     if sample.status == "complete":
@@ -213,11 +279,21 @@ def _format_sample_row(sample: SampleState, width: int, selected: bool = False)
         phase = sample.phase or "running"
         row = f"  {name} {turn_info:>4}  {CYAN}{phase}...{RESET}"
 
+    # Calculate visible length and overflow
+    visible_len = _visible_len(row)
+    overflow = max(0, visible_len - width)
+
     if selected:
+        # Apply marquee offset for selected rows (ANSI-aware slicing)
+        if marquee_offset > 0 and overflow > 0:
+            offset = min(marquee_offset, overflow)
+            # Skip the leading indent (2 spaces), slice the rest, re-add indent
+            row = "  " + _ansi_slice(row, 2 + offset)
+
         # Add selection highlight
         row = f"{BG_SELECTED}{row}{RESET}"
 
-    return row
+    return row, overflow
 
 
 # ── Viewport formatting ──────────────────────────────────────────────────────
@@ -251,10 +327,32 @@ def format_sample_event(
     elif msg == "tool_execution":
         tool = event.get("tool_name", "tool")
         duration = event.get("duration_ms", 0)
-        status = event.get("result_summary", "")
+        summary = event.get("result_summary") or {}
         is_error = event.get("is_error", False)
         color = RED if is_error else CYAN
-        return f"{color}→ {tool}{RESET} ({duration / 1000:.1f}s) {status}", None
+
+        # Format tool-specific summary
+        if tool == "edit" and isinstance(summary, dict):
+            path = summary.get("path", "")
+            # Show just filename, not full path
+            filename = path.split("/")[-1] if path else ""
+            added = summary.get("lines_added", 0)
+            removed = summary.get("lines_removed", 0)
+            diff_info = f"{filename} +{added}/-{removed}"
+            return f"{color}→ {tool}{RESET} ({duration / 1000:.1f}s) {diff_info}", None
+        elif tool == "bash" and isinstance(summary, dict):
+            cmd = summary.get("command", "")
+            # Truncate long commands
+            cmd_short = cmd[:50] + "…" if len(cmd) > 50 else cmd
+            return f"{color}→ {tool}{RESET} ({duration / 1000:.1f}s) {cmd_short}", None
+        elif tool == "write" and isinstance(summary, dict):
+            path = summary.get("path", "")
+            filename = path.split("/")[-1] if path else ""
+            return f"{color}→ {tool}{RESET} ({duration / 1000:.1f}s) {filename}", None
+        else:
+            # Fallback: show summary dict or empty
+            status = str(summary) if summary else ""
+            return f"{color}→ {tool}{RESET} ({duration / 1000:.1f}s) {status}", None
 
     elif msg == "llm_call":
         provider = event.get("provider", "")
@@ -314,49 +412,39 @@ def render_header(state: RenderState, width: int) -> str:
     return header[:width]
 
 
-def render(state: RenderState, width: int, height: int) -> list[str]:
-    """Render state to list of lines. Pure function."""
-    lines: list[str] = []
-
-    lines.append(render_header(state, width))
-
-    # Active samples, sorted by most recently updated
-    active = [s for s in state.samples.values() if s.status != "complete" and s.phase]
-    active.sort(key=lambda s: s.last_update, reverse=True)
-
-    max_samples = max(1, height - 4)
-    for sample in active[:max_samples]:
-        lines.append(_format_sample_row(sample, width))
-
-    total_in_flight = sum(1 for s in state.samples.values() if s.status != "complete")
-    hidden = total_in_flight - len(active[:max_samples])
-    if hidden > 0:
-        lines.append(f"{DIM}  ... and {hidden} more in flight{RESET}")
-
-    if state.scores:
-        mean_score = sum(state.scores) / len(state.scores)
-        lines.append(f"{DIM}score: {mean_score:.1%}{RESET}")
-
-    return lines
-
-
 # ── Elm architecture (subprocess entry point) ────────────────────────────────
 
 
 @dataclass(frozen=True)
 class Model:
-    """Immutable model for the pytui App."""
+    """Immutable model for the pytui App.
+
+    Uses bubbles-style cursor tracking:
+    - selected_sample_id: stable selection by ID (not index)
+    - viewport_scroll: scroll offset for detail viewport
+
+    Note: list_scroll is computed dynamically in view() to keep selection visible.
+    """
 
     events: tuple[dict[str, Any], ...] = ()
     done: bool = False
 
-    # Viewport state
+    # Focus state
     focus: str = "list"  # "list" or "viewport"
-    selected_idx: int = 0  # Index into active samples list
+
+    # Sample list state (bubbles table pattern)
+    selected_sample_id: str | None = None  # Track by ID, not index
+
+    # Marquee state for selected row (scrolls long text horizontally)
+    marquee_offset: int = 0  # Current scroll offset for selected row text
+
+    # Viewport state
     viewport_lines: tuple[str, ...] = ()  # Formatted lines for viewport
     viewport_scroll: int = 0  # Scroll position in viewport
     viewport_auto_follow: bool = True  # Auto-scroll to bottom on new content
-    tailing_sample_id: str | None = None  # Which sample file we're tailing
+
+    # Viewport marquee state (for scrolling long lines when focused)
+    viewport_marquee_offset: int = 0  # Horizontal scroll for viewport lines
 
     # For streaming text accumulation
     streaming_text: str = ""
@@ -379,6 +467,20 @@ class SampleEvent:
     line: str
 
 
+@dataclass(frozen=True)
+class MarqueeTick:
+    """Periodic tick for marquee animation on selected sample row."""
+
+    pass
+
+
+@dataclass(frozen=True)
+class ViewportMarqueeTick:
+    """Periodic tick for marquee animation on viewport lines."""
+
+    pass
+
+
 def _parse_event(line: str) -> dict[str, Any] | None:
     try:
         return json.loads(line)
@@ -387,71 +489,178 @@ def _parse_event(line: str) -> dict[str, Any] | None:
 
 
 def _get_active_samples(events: tuple[dict[str, Any], ...]) -> list[SampleState]:
-    """Get list of active (non-complete) samples from events."""
+    """Get list of active (non-complete) samples from events.
+
+    Returns samples sorted by name (stable order) not last_update (jumping order).
+    """
     state = derive_state(list(events))
     active = [s for s in state.samples.values() if s.status != "complete" and s.phase]
-    active.sort(key=lambda s: s.last_update, reverse=True)
+    # Sort by sample name for stable order (not last_update which causes jumping)
+    active.sort(key=lambda s: s.name)
     return active
 
 
-def _get_selected_sample_id(events: tuple[dict[str, Any], ...], selected_idx: int) -> str | None:
-    """Get the sample_id of the currently selected sample."""
-    active = _get_active_samples(events)
-    if 0 <= selected_idx < len(active):
-        return active[selected_idx].id
+def _find_sample_index(active: list[SampleState], sample_id: str | None) -> int:
+    """Find index of sample_id in active list, or 0 if not found."""
+    if sample_id is None:
+        return 0
+    for i, s in enumerate(active):
+        if s.id == sample_id:
+            return i
+    return 0
+
+
+def _get_sample_at_index(active: list[SampleState], idx: int) -> SampleState | None:
+    """Get sample at index, or None if out of bounds."""
+    if 0 <= idx < len(active):
+        return active[idx]
     return None
 
 
+def _handle_marquee_tick(model: Model) -> tuple[Model, Any]:
+    """Handle marquee tick for selected row animation."""
+    from ._pytui import Cmd
+
+    if not model.selected_sample_id:
+        return model, Cmd.none()
+
+    # Get the selected sample to check if it has overflow
+    active = _get_active_samples(model.events)
+    selected_idx = _find_sample_index(active, model.selected_sample_id)
+    sample = _get_sample_at_index(active, selected_idx)
+    if not sample:
+        return model, Cmd.none()
+
+    # Check how much overflow this sample has (use typical terminal width)
+    _, overflow = _format_sample_row(sample, 80, selected=True, marquee_offset=0)
+    if overflow <= 0:
+        # No overflow, reset offset
+        if model.marquee_offset != 0:
+            return replace(model, marquee_offset=0), Cmd.none()
+        return model, Cmd.none()
+
+    # Advance marquee with pause at start and end
+    # offset < 0: pause at start (show beginning)
+    # offset 0..overflow: scrolling
+    # offset > overflow: pause at end (show end)
+    pause_ticks = 5  # Ticks to pause at start/end
+    new_offset = model.marquee_offset + 1
+    if new_offset > overflow + pause_ticks:
+        new_offset = -pause_ticks  # Snap back to start pause
+
+    return replace(model, marquee_offset=new_offset), Cmd.none()
+
+
+def _get_max_viewport_overflow(model: Model, width: int) -> int:
+    """Get the maximum overflow across all visible viewport lines."""
+    if not model.viewport_lines:
+        return 0
+
+    max_overflow = 0
+    for line in model.viewport_lines:
+        visible_len = _visible_len(line)
+        overflow = max(0, visible_len - width)
+        max_overflow = max(max_overflow, overflow)
+    return max_overflow
+
+
+def _handle_viewport_marquee_tick(model: Model) -> tuple[Model, Any]:
+    """Handle marquee tick for viewport lines animation."""
+    from ._pytui import Cmd
+
+    # Only animate when viewport is focused
+    if model.focus != "viewport":
+        if model.viewport_marquee_offset != 0:
+            return replace(model, viewport_marquee_offset=0), Cmd.none()
+        return model, Cmd.none()
+
+    # Check if any lines have overflow (use typical terminal width)
+    max_overflow = _get_max_viewport_overflow(model, 80)
+    if max_overflow <= 0:
+        if model.viewport_marquee_offset != 0:
+            return replace(model, viewport_marquee_offset=0), Cmd.none()
+        return model, Cmd.none()
+
+    # Advance marquee with pause at start and end
+    pause_ticks = 8  # Longer pause for viewport (more content to read)
+    new_offset = model.viewport_marquee_offset + 1
+    if new_offset > max_overflow + pause_ticks:
+        new_offset = -pause_ticks  # Snap back to start pause
+
+    return replace(model, viewport_marquee_offset=new_offset), Cmd.none()
+
+
 def update(model: Model, msg: object) -> tuple[Model, Any]:
     from ._pytui import Cmd, KeyPress
 
     match msg:
-        case KeyPress(key="q" | "\x03"):
+        case KeyPress(key="\x03"):  # Ctrl+C: cancel eval and quit
+            # Signal parent process to cancel the eval
+            os.kill(os.getppid(), signal.SIGINT)
+            return model, Cmd.quit()
+
+        case KeyPress(key="q"):  # q: detach (quit TUI, eval continues)
             return model, Cmd.quit()
 
         # Focus switching
         case KeyPress(key="\t"):  # Tab
             new_focus = "viewport" if model.focus == "list" else "list"
-            return replace(model, focus=new_focus), Cmd.none()
+            # Reset viewport marquee when switching focus
+            return replace(model, focus=new_focus, viewport_marquee_offset=-8), Cmd.none()
 
         # Navigation in list focus
         case KeyPress(key="j" | "\x1b[B") if model.focus == "list":  # Down
             active = _get_active_samples(model.events)
-            new_idx = min(model.selected_idx + 1, len(active) - 1) if active else 0
-            new_sample_id = _get_selected_sample_id(model.events, new_idx)
-            # Reset viewport when selection changes
-            if new_sample_id != model.tailing_sample_id:
+            if not active:
+                return model, Cmd.none()
+
+            # Find current index, move down
+            current_idx = _find_sample_index(active, model.selected_sample_id)
+            new_idx = _clamp(current_idx + 1, 0, len(active) - 1)
+            new_sample = active[new_idx]
+
+            # Reset viewport and marquee when selection changes
+            if new_sample.id != model.selected_sample_id:
                 return replace(
                     model,
-                    selected_idx=new_idx,
-                    tailing_sample_id=new_sample_id,
+                    selected_sample_id=new_sample.id,
+                    marquee_offset=-5,  # Start with pause at beginning
                     viewport_lines=(),
                     viewport_scroll=0,
                     viewport_auto_follow=True,
                     streaming_text="",
                     last_turn=None,
                 ), Cmd.none()
-            return replace(model, selected_idx=new_idx), Cmd.none()
+            return model, Cmd.none()
 
         case KeyPress(key="k" | "\x1b[A") if model.focus == "list":  # Up
-            new_idx = max(model.selected_idx - 1, 0)
-            new_sample_id = _get_selected_sample_id(model.events, new_idx)
-            if new_sample_id != model.tailing_sample_id:
+            active = _get_active_samples(model.events)
+            if not active:
+                return model, Cmd.none()
+
+            # Find current index, move up
+            current_idx = _find_sample_index(active, model.selected_sample_id)
+            new_idx = _clamp(current_idx - 1, 0, len(active) - 1)
+            new_sample = active[new_idx]
+
+            if new_sample.id != model.selected_sample_id:
                 return replace(
                     model,
-                    selected_idx=new_idx,
-                    tailing_sample_id=new_sample_id,
+                    selected_sample_id=new_sample.id,
+                    marquee_offset=-5,  # Start with pause at beginning
                     viewport_lines=(),
                     viewport_scroll=0,
                     viewport_auto_follow=True,
                     streaming_text="",
                     last_turn=None,
                 ), Cmd.none()
-            return replace(model, selected_idx=new_idx), Cmd.none()
+            return model, Cmd.none()
 
         # Navigation in viewport focus
         case KeyPress(key="j" | "\x1b[B") if model.focus == "viewport":  # Down
-            new_scroll = model.viewport_scroll + 1
+            # Clamp to content length to prevent phantom scroll past end
+            max_scroll = max(0, len(model.viewport_lines) - 1)
+            new_scroll = min(model.viewport_scroll + 1, max_scroll)
             return replace(
                 model, viewport_scroll=new_scroll, viewport_auto_follow=False
             ), Cmd.none()
@@ -479,12 +688,13 @@ def update(model: Model, msg: object) -> tuple[Model, Any]:
             if event.get("message") == "eval_end":
                 return replace(model, events=new_events, done=True), Cmd.quit()
 
-            # Auto-select first sample if none selected
             new_model = replace(model, events=new_events)
-            if model.tailing_sample_id is None:
-                sample_id = _get_selected_sample_id(new_events, model.selected_idx)
-                if sample_id:
-                    new_model = replace(new_model, tailing_sample_id=sample_id)
+
+            # Auto-select first sample if none selected
+            if model.selected_sample_id is None:
+                active = _get_active_samples(new_events)
+                if active:
+                    new_model = replace(new_model, selected_sample_id=active[0].id)
 
             return new_model, Cmd.none()
 
@@ -502,39 +712,103 @@ def update(model: Model, msg: object) -> tuple[Model, Any]:
                 new_streaming = model.streaming_text + (formatted or "")
                 return replace(model, streaming_text=new_streaming), Cmd.none()
 
-            # When we get a non-delta event, flush accumulated streaming text
-            new_lines = list(model.viewport_lines)
-            if model.streaming_text:
-                # Wrap streaming text to reasonable width and add
-                for line in model.streaming_text.split("\n"):
-                    if line:
-                        new_lines.append(line)
-                new_streaming = ""
-            else:
-                new_streaming = model.streaming_text
-
-            # Add the formatted event line
-            if formatted and msg_type != "text_delta":
-                new_lines.append(formatted)
+            # Non-delta event: flush streaming text and add formatted line
+            flushed_lines = [l for l in model.streaming_text.split("\n") if l]
+            event_line = [formatted] if formatted else []
+            new_lines = model.viewport_lines + tuple(flushed_lines) + tuple(event_line)
 
             # Auto-scroll if enabled
-            new_scroll = model.viewport_scroll
-            if model.viewport_auto_follow:
-                new_scroll = max(0, len(new_lines) - 1)
+            new_scroll = (
+                max(0, len(new_lines) - 1) if model.viewport_auto_follow else model.viewport_scroll
+            )
 
             return replace(
                 model,
-                viewport_lines=tuple(new_lines),
+                viewport_lines=new_lines,
                 viewport_scroll=new_scroll,
-                streaming_text=new_streaming,
+                streaming_text="",
                 last_turn=new_turn if new_turn is not None else model.last_turn,
             ), Cmd.none()
 
+        # Marquee tick for selected row animation
+        case MarqueeTick():
+            return _handle_marquee_tick(model)
+
+        # Marquee tick for viewport lines animation
+        case ViewportMarqueeTick():
+            return _handle_viewport_marquee_tick(model)
+
     return model, Cmd.none()
 
 
+def _render_viewport(model: Model, width: int, viewport_height: int, list_height: int) -> list[str]:
+    """Render the viewport section showing selected sample's output."""
+    lines: list[str] = []
+
+    if model.selected_sample_id:
+        # Include any streaming text as a "virtual" line at the end
+        display_lines = list(model.viewport_lines)
+        if model.streaming_text:
+            # Show streaming text (last 200 chars to keep it manageable)
+            stream_preview = model.streaming_text[-200:]
+            if len(model.streaming_text) > 200:
+                stream_preview = "..." + stream_preview
+            display_lines.append(f"{CYAN}{stream_preview}{RESET}")
+
+        if display_lines:
+            # Clamp scroll (bubbles pattern)
+            max_scroll = max(0, len(display_lines) - viewport_height)
+            scroll = _clamp(model.viewport_scroll, 0, max_scroll)
+
+            # Render visible lines with marquee for overflow
+            visible = display_lines[scroll : scroll + viewport_height]
+            marquee_offset = (
+                max(0, model.viewport_marquee_offset) if model.focus == "viewport" else 0
+            )
+
+            for line in visible:
+                visible_len = _visible_len(line)
+                overflow = visible_len - width
+
+                if overflow > 0 and marquee_offset > 0:
+                    # Apply marquee: slice from offset position (ANSI-aware)
+                    offset = min(marquee_offset, overflow)
+                    sliced = _ansi_slice(line, offset)
+                    # Truncate to width after slicing
+                    if _visible_len(sliced) > width:
+                        # Crude truncation - find approx position
+                        lines.append(sliced[: width + 20] + "…")
+                    else:
+                        lines.append(sliced)
+                elif overflow > 0:
+                    # No marquee active, just truncate with indicator
+                    lines.append(line[: width + 20] + "…")
+                else:
+                    lines.append(line)
+        else:
+            lines.append(f"{DIM}  (waiting for events...){RESET}")
+
+        # Pad viewport
+        target_len = viewport_height
+    else:
+        # No sample selected
+        lines.append(f"{DIM}  (select a sample to view its output){RESET}")
+        target_len = viewport_height
+
+    while len(lines) < target_len:
+        lines.append("")
+
+    return lines
+
+
 def view(model: Model, width: int, height: int) -> list[str]:
-    """Render the split view: sample list on top, viewport on bottom."""
+    """Render the split view: sample list on top, viewport on bottom.
+
+    Uses bubbles-style bounded rendering:
+    - Only render visible rows in each section
+    - Keep selected item in view
+    - Clamp scroll positions
+    """
     state = derive_state(list(model.events))
     lines: list[str] = []
 
@@ -546,30 +820,57 @@ def view(model: Model, width: int, height: int) -> list[str]:
     list_height = max(4, min(height // 3, 10))
     viewport_height = height - list_height - 3  # -3 for header, separator, footer
 
-    # Active samples with selection highlight
+    # Get active samples (stable sort by name)
     active = _get_active_samples(model.events)
 
-    # Render sample list
-    for i, sample in enumerate(active[: list_height - 1]):
-        selected = i == model.selected_idx
-        row = _format_sample_row(sample, width, selected=selected)
+    # Find selected index
+    selected_idx = _find_sample_index(active, model.selected_sample_id)
+
+    # Calculate visible window for sample list (bubbles pattern)
+    # Reserve last line for scroll indicator if there will be hidden items
+    needs_scroll_indicator = len(active) > list_height - 1
+    list_visible_height = list_height - 2 if needs_scroll_indicator else list_height - 1
+
+    # Compute list_scroll to keep selected item visible (derived, not stored in model)
+    # Start with scroll that centers selection, then clamp
+    list_scroll = max(0, selected_idx - list_visible_height // 2)
+    list_scroll = _clamp(list_scroll, 0, max(0, len(active) - list_visible_height))
+
+    # Render visible sample rows
+    visible_end = min(list_scroll + list_visible_height, len(active))
+    for i in range(list_scroll, visible_end):
+        sample = active[i]
+        selected = i == selected_idx
+        row, _overflow = _format_sample_row(
+            sample,
+            width,
+            selected=selected,
+            marquee_offset=model.marquee_offset if selected else 0,
+        )
         lines.append(row)
 
+    # Show scroll indicator if there are hidden items (on its own line)
+    hidden_above = list_scroll
+    hidden_below = max(0, len(active) - visible_end)
+    if hidden_above > 0 or hidden_below > 0:
+        indicator_parts = []
+        if hidden_above > 0:
+            indicator_parts.append(f"↑{hidden_above}")
+        if hidden_below > 0:
+            indicator_parts.append(f"↓{hidden_below}")
+        indicator = " ".join(indicator_parts)
+        lines.append(f"{DIM}  ... {indicator} more{RESET}")
+
     # Pad list area
     while len(lines) < list_height:
         lines.append("")
 
-    # Show hidden count
-    if len(active) > list_height - 1:
-        hidden = len(active) - (list_height - 1)
-        lines[list_height - 1] = f"{DIM}  ... and {hidden} more{RESET}"
-
     # Separator with focus indicator and selected sample name
     selected_name = ""
-    if model.tailing_sample_id:
-        active = _get_active_samples(model.events)
-        if 0 <= model.selected_idx < len(active):
-            selected_name = f" [{active[model.selected_idx].name[:20]}]"
+    if model.selected_sample_id:
+        sample = _get_sample_at_index(active, selected_idx)
+        if sample:
+            selected_name = f" [{sample.name[:20]}]"
 
     if model.focus == "list":
         label = "samples"
@@ -581,48 +882,14 @@ def view(model: Model, width: int, height: int) -> list[str]:
     lines.append(f"{DIM}{prefix}{fill}{RESET}")
 
     # Viewport
-    if model.tailing_sample_id:
-        # Include any streaming text as a "virtual" line at the end
-        display_lines = list(model.viewport_lines)
-        if model.streaming_text:
-            # Show streaming text (last 200 chars to keep it manageable)
-            stream_preview = model.streaming_text[-200:]
-            if len(model.streaming_text) > 200:
-                stream_preview = "..." + stream_preview
-            display_lines.append(f"{CYAN}{stream_preview}{RESET}")
-
-        if display_lines:
-            # Clamp scroll
-            max_scroll = max(0, len(display_lines) - viewport_height)
-            scroll = min(model.viewport_scroll, max_scroll)
-
-            # Render visible lines
-            visible = display_lines[scroll : scroll + viewport_height]
-            for line in visible:
-                # Truncate long lines (but preserve ANSI - crude truncation for now)
-                # TODO: proper ANSI-aware truncation
-                if len(line) > width + 20:  # Allow some slack for ANSI codes
-                    lines.append(line[: width + 10] + "...")
-                else:
-                    lines.append(line)
-        else:
-            lines.append(f"{DIM}  (waiting for events...){RESET}")
-
-        # Pad viewport
-        while len(lines) < list_height + 1 + viewport_height:
-            lines.append("")
-    else:
-        # No sample selected
-        lines.append(f"{DIM}  (select a sample to view its output){RESET}")
-        while len(lines) < list_height + 1 + viewport_height:
-            lines.append("")
+    lines.extend(_render_viewport(model, width, viewport_height, list_height))
 
     # Footer
     if model.focus == "list":
-        footer = f"{DIM}j/k: select  Tab: focus viewport  q: quit{RESET}"
+        footer = f"{DIM}j/k: select  Tab: viewport  q: detach  ^C: cancel{RESET}"
     else:
         follow_status = "follow" if model.viewport_auto_follow else "manual"
-        footer = f"{DIM}j/k: scroll  G: bottom  Tab: focus list  [{follow_status}]  q: quit{RESET}"
+        footer = f"{DIM}j/k: scroll  G: bottom  Tab: list  [{follow_status}]  q: detach  ^C: cancel{RESET}"
 
     # Pad to fill screen
     while len(lines) < height - 1:
@@ -639,6 +906,7 @@ def view(model: Model, width: int, height: int) -> list[str]:
 def progress_display(
     output_dir: Path | str,
     disable: bool = False,
+    debug_log: Path | str | None = None,
 ) -> Generator[Path, None, None]:
     """Context manager that spawns a pytui progress display in a subprocess.
 
@@ -648,6 +916,7 @@ def progress_display(
     Args:
         output_dir: Directory containing events.jsonl
         disable: If True, skip progress display (verbose mode)
+        debug_log: If set, write pytui debug events to this file
     """
     if disable:
         yield Path(output_dir)
@@ -657,18 +926,24 @@ def progress_display(
     output_dir.mkdir(parents=True, exist_ok=True)
     events_file = output_dir / "events.jsonl"
 
+    # Build command
+    cmd = [sys.executable, "-m", "wafer_core.rollouts.progress_app", str(events_file)]
+    if debug_log is None:
+        # Default: write debug log to output_dir
+        debug_log = output_dir / "pytui_debug.jsonl"
+    if debug_log:
+        cmd.extend(["--debug-log", str(debug_log)])
+
     proc = subprocess.Popen(
-        [sys.executable, "-m", "wafer_core.rollouts.progress_app", str(events_file)],
+        cmd,
         # Don't touch stdout/stderr — child inherits the terminal.
         # pytui opens /dev/tty directly for input, writes to stdout for rendering.
         #
-        # start_new_session: put subprocess in its own session so it doesn't
-        # receive SIGINT from Ctrl+C. The parent gets SIGINT and terminates
-        # the subprocess in the finally block. Without this, pytui's raw mode
-        # swallows Ctrl+C (terminal driver doesn't generate SIGINT in raw mode)
-        # and the parent never sees it.
+        # We need the subprocess to stay in the same session so it can access
+        # /dev/tty for keyboard input. SIGINT handling: pytui is in raw mode
+        # so Ctrl+C becomes a regular keypress (^C / \x03) rather than generating
+        # SIGINT. The progress app handles KeyPress("\x03") -> Cmd.quit().
         stdin=subprocess.DEVNULL,
-        start_new_session=True,
     )
 
     try:
@@ -695,13 +970,16 @@ def progress_display(
 # ── CLI entry point (subprocess runs this) ────────────────────────────────────
 
 if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("Usage: python -m wafer_core.rollouts.progress_app <events.jsonl>", file=sys.stderr)
-        sys.exit(1)
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("events_file", help="Path to events.jsonl")
+    parser.add_argument("--debug-log", help="Path to debug log file")
+    args = parser.parse_args()
 
     from ._pytui import App, Cmd, Sub
 
-    events_file = sys.argv[1]
+    events_file = args.events_file
     output_dir = Path(events_file).parent
     samples_dir = output_dir / "samples"
 
@@ -712,11 +990,18 @@ if __name__ == "__main__":
         subs = [Sub.file_tail(events_file, lambda line: NewEvent(line=line))]
 
         # Tail the selected sample's file if we have one
-        if model.tailing_sample_id:
-            sample_file = samples_dir / f"{model.tailing_sample_id}.jsonl"
+        if model.selected_sample_id:
+            sample_file = samples_dir / f"{model.selected_sample_id}.jsonl"
             if sample_file.exists():
                 subs.append(Sub.file_tail(str(sample_file), lambda line: SampleEvent(line=line)))
 
+            # Marquee animation tick (scrolls selected row text)
+            subs.append(Sub.every(0.15, lambda: MarqueeTick()))
+
+        # Viewport marquee animation (scrolls long lines when viewport focused)
+        if model.focus == "viewport" and model.viewport_lines:
+            subs.append(Sub.every(0.12, lambda: ViewportMarqueeTick()))
+
         return Sub.batch(*subs)
 
     App(
@@ -725,4 +1010,5 @@ if __name__ == "__main__":
         view=view,
         subscriptions=_subscriptions,
         alternate_screen=False,
+        debug_log=args.debug_log,
     ).run()

wafer_core/rollouts/scoring.py

@@ -155,18 +155,35 @@ async def score_with_llm_judge(
         client = anthropic.Anthropic(api_key=api_key)
         response = client.messages.create(
             model=model,
-            max_tokens=500,
+            max_tokens=8192,
             messages=[{"role": "user", "content": prompt}],
         )
 
         raw_response = response.content[0].text
 
-        # Parse JSON from response
+        # Parse JSON from response - extract JSON object from anywhere in text
         text = raw_response.strip()
         if text.startswith("```"):
             lines = text.split("\n")
             text = "\n".join(lines[1:-1] if lines[-1] == "```" else lines[1:])
 
+        # Try to find JSON object with "score" key anywhere in response
+        import re
+        # Find last occurrence of {"score" pattern and extract to end
+        json_match = re.search(r'(\{"score":\s*\d+.*)', text, re.DOTALL)
+        if json_match:
+            # Find the matching closing brace
+            candidate = json_match.group(1)
+            # Try progressively shorter substrings until valid JSON
+            for i in range(len(candidate), 0, -1):
+                if candidate[i-1] == '}':
+                    try:
+                        json.loads(candidate[:i])
+                        text = candidate[:i]
+                        break
+                    except json.JSONDecodeError:
+                        continue
+
         try:
             result = json.loads(text)
             return {

{wafer_core-0.1.46.dist-info → wafer_core-0.1.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-core
-Version: 0.1.46
+Version: 0.1.47
 Summary: Core utilities and environments for Wafer GPU kernel optimization
 Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3.9.0

{wafer_core-0.1.46.dist-info → wafer_core-0.1.47.dist-info}/RECORD

@@ -350,7 +350,7 @@ wafer_core/rollouts/__init__.py,sha256=7RjEk9MCHY_aFe9Yl02uTNG-gZJdlU8LTkw70Ip67
 wafer_core/rollouts/__main__.py,sha256=aSZKLG1SRhTMRGeGi4nA2tUHonJwxA6y0SGYfb-VfnM,127
 wafer_core/rollouts/_rate_limit.py,sha256=pNToYI5OJL41wPYNjAAYkYca3rmshlNgf1KnVBLiWY0,5629
 wafer_core/rollouts/_retry.py,sha256=Ay3EelWoZRs9DvsXLQkg31kGwVb6DWBh0V9IwdQZkpE,9990
-wafer_core/rollouts/agents.py,sha256=Uv1kjYogUfdPl18YfkVxVqFTbmWfuJQrxem_iHTUgdw,44742
+wafer_core/rollouts/agents.py,sha256=LZcW2ydzEspHUu6I3itvAMakmo9fNoD05NPvureuQ8o,45421
 wafer_core/rollouts/cli.py,sha256=2NqgegKdlmxD0eJzGOMB5o_1Hb5t7O5JpP_32uvF2BE,80117
 wafer_core/rollouts/cli_agents.py,sha256=e4qqqYBzWLsbw8FsNnddGApWp_on9Cvzrfd1amiAyvI,20641
 wafer_core/rollouts/deploy.py,sha256=3t88fM_BMyAPkxIl8pS4r5ogHJvrlqWQDuIaltDZBRc,40924
@@ -366,11 +366,11 @@ wafer_core/rollouts/models.py,sha256=BrMnUpTA9_HnOghpedzdLUm9Di3FyJouzOkK4PPBg_k
 wafer_core/rollouts/paths.py,sha256=9XtrA9ylhb5LttMFe2DE7X0IHeUMjuGUerII9OscYec,3436
 wafer_core/rollouts/pipeline.py,sha256=vlJTYE3ZX2XScpF9pmtv91K8Q0g8uLmcbI5jn6b5Hzg,15319
 wafer_core/rollouts/progress.py,sha256=szA9cvWT2xUxGVhF9BaAqJMmKDqMAUlxImxcOpcnqbY,29228
-wafer_core/rollouts/progress_app.py,sha256=JSx4FKn_H8Thi2IK19mr2RvpH15BZuUi3nC0h6qMcD8,26218
+wafer_core/rollouts/progress_app.py,sha256=dWuMj3KQphiVt-D-5jH7mPYtVybpTtliXRJXOaLWOAU,36638
 wafer_core/rollouts/prompt.py,sha256=EDmGb0rhWwke7tokIcO8dukc3q5c8x0n5Omi5CpAQmA,11022
 wafer_core/rollouts/providers.py,sha256=dcGJh1p30hstVbCDDtJ902lyafkg81DKjcOzb0uuKS0,1400
 wafer_core/rollouts/remote.py,sha256=cAYpRCONlsTeRxzLiegAUfjZWGtqBNwZTHehMhk5ldA,8816
-wafer_core/rollouts/scoring.py,sha256=qeIT8Z7pK51XRDmN2sGdg_hIPRabWqoQIYKsuytlvRo,8838
+wafer_core/rollouts/scoring.py,sha256=WNEDZltad_4T4Pw4DHUGrXqGZU1DqFm9Ph4Ibho40H0,9623
 wafer_core/rollouts/search.py,sha256=5BEDuw9FVbQhei3nvUXEVwBU5ouwgJE6ONhEqvU5Ldc,14696
 wafer_core/rollouts/skills.py,sha256=ATYoG02Cc6_VrtE415TnseBFJrKOMq27z-5YgBgPpZQ,5081
 wafer_core/rollouts/slice.py,sha256=darOZO53BuSPfvv_KjOSzulGVSWbL4OuoE3k6xXpBFg,20195
@@ -383,13 +383,14 @@ wafer_core/rollouts/_logging/json_formatter.py,sha256=jJIa2IZCsu2C_Y1HXQi7hbI33x
 wafer_core/rollouts/_logging/logging_config.py,sha256=JbHCBcKHaospwF3BlKfp1HzhZTUElhtOGghKHF21bvc,10581
 wafer_core/rollouts/_logging/sample_handler.py,sha256=XhS5bVs6VKjABP7PeAp8CuEppqXUOm5rPCi-uEbt6QU,2122
 wafer_core/rollouts/_pytui/__init__.py,sha256=Q4TwOoefOqDkudvaWJ7TQF6Ak32Nqs09h7jl8luPuo8,2368
-wafer_core/rollouts/_pytui/app.py,sha256=NGNZ97nPq8ZZitMrY2tUgSEz_K3m5FqlNQpdy3geoEk,26163
+wafer_core/rollouts/_pytui/app.py,sha256=I_0sFuMCu5LQIbezp9B0zNIDNaDsKjBnYY8b57gPpvU,26410
 wafer_core/rollouts/_pytui/console.py,sha256=0TBZ9MPfLls6wPQvI9KA_0k1348e0VckAvPwn2y6D9Q,10804
 wafer_core/rollouts/_pytui/renderer.py,sha256=kFJoEsURAowj8KmKujcDJF00VDwiFhW4AP0fFD7hsrA,6429
 wafer_core/rollouts/_pytui/spinner.py,sha256=ilIOIubZQz5C77m-Y6te55z8c1Kz8njy66CVsxMu9xw,2256
 wafer_core/rollouts/_pytui/terminal.py,sha256=mCSZYAAH10Dl53fuCxQ2ZegkOmL1gFI5wEkTxQyOoKI,17736
 wafer_core/rollouts/_pytui/text.py,sha256=KeGJAM6MJQQLSk9y2R-HnYgLqCcc8Qk4QfukctBuYA8,14107
 wafer_core/rollouts/_pytui/theme.py,sha256=FdYrvQz66b7uMNbB2WCp8FPUvGSJ6vUHDaYnR6SSeSY,8067
+wafer_core/rollouts/_pytui/viewport.py,sha256=8Y3adY57dXSn9H3bCtQ7FnhA5iq2miZKkiAv09aSgSI,6425
 wafer_core/rollouts/agent_presets/README.md,sha256=gGyE0P_2Cp5s5ekHVY3cYcz19g91Wb-wboFakcvBriQ,7584
 wafer_core/rollouts/agent_presets/__init__.py,sha256=BLZOzAyC-cThQQQpAROeo4eEMOlMCrVEgnKYqzSsyS4,454
 wafer_core/rollouts/agent_presets/base_preset.py,sha256=vDzDiVe_DHN2fiQrtGTW309EJgt3t1jaPAgkQCgDycw,2550
@@ -727,6 +728,6 @@ wafer_core/utils/modal_execution/modal_app.py,sha256=VfS2cX8gHtnlPXemmMcEwDPeQdh
 wafer_core/utils/modal_execution/modal_config.py,sha256=7cGX9TGqilQ3qxI3OFGXV5orjtyRU-PEDOJ4vP2oxno,4421
 wafer_core/utils/modal_execution/modal_execution.py,sha256=gChjnV6jqA3A7IRP3DfvV5cSfm_MN0X4f7JZufXgdZE,24594
 wafer_core/utils/modal_execution/test_modal.py,sha256=_jqou_hrLs1Daf1590Pnb0a_lXMMa2rczAPpW9HpoNQ,8153
-wafer_core-0.1.46.dist-info/METADATA,sha256=rgFOq_IA8Z0JLFzshlHqGDDZPo50owAGlqWuFhiu_HY,1477
-wafer_core-0.1.46.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-wafer_core-0.1.46.dist-info/RECORD,,
+wafer_core-0.1.47.dist-info/METADATA,sha256=OLmPs__QV_sZBZ1_-VNFx9SoHtnaRj-CnrgJvf1b2BY,1477
+wafer_core-0.1.47.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wafer_core-0.1.47.dist-info/RECORD,,