@pennyfarthing/core 11.1.1 → 11.2.1

package/pennyfarthing_scripts/bellmode_hook.py

@@ -1,309 +1,25 @@
-#!/usr/bin/env python3
 """
-PostToolUse Hook — Bell Mode + Tandem Injection (Python)
+Backward-compatibility shim — bell mode hook moved to hooks/bell_mode.py.
 
-Called by Claude Code after each tool execution. Handles two independent
-injection systems:
-
-1. Bell queue (Cyclist only) — injects queued user messages when Cyclist
-   is running and bell_mode is enabled. In CLI sessions this is a no-op.
-2. Tandem observations (always active) — injects backseat agent observations
-   when tandem observation files exist. No configuration required.
-
-Bell queue takes precedence: if a queued message exists, tandem is
-deferred to the next hook invocation.
-
-Story: MSSCI-12409 - Hook consistency and WheelHub consolidation
+This file will be removed in a future version.
 """
 
-import json
-import re
-import sys
-from pathlib import Path
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent))
-
-from hooks import (
-    CYCLIST_PORT_FILE,
-    HookResponse,
-    find_project_root,
-    is_bell_mode_enabled,
-    output_hook_response,
-    read_port_file,
-    send_to_cyclist,
+# Re-export public API from new location for existing tests/imports
+from pennyfarthing_scripts.hooks.bell_mode import (  # noqa: F401
+    _check_tandem_files as check_tandem_files,
+    _get_latest_observation as get_latest_observation,
+    _get_tandem_mtime as get_tandem_mtime,
+    _read_bell_queue as read_bell_queue,
+    _read_tandem_observations as read_tandem_observations,
+    _save_tandem_mtime as save_tandem_mtime,
+    main,
 )
 
 
-def read_bell_queue(project_root: Path) -> list[dict]:
-    """Read the bell message queue.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        List of queued messages, or empty list if none
-    """
-    queue_path = project_root / ".pennyfarthing" / "bell-queue.json"
-    if not queue_path.exists():
-        return []
-
-    try:
-        with open(queue_path) as f:
-            queue = json.load(f)
-            if isinstance(queue, list):
-                return queue
-    except (json.JSONDecodeError, OSError):
-        pass
-
-    return []
-
-
-def dequeue_message(project_root: Path) -> None:
-    """Remove the first message from the queue.
-
-    Args:
-        project_root: Project root directory
-    """
-    queue_path = project_root / ".pennyfarthing" / "bell-queue.json"
-    if not queue_path.exists():
-        return
-
-    try:
-        with open(queue_path) as f:
-            queue = json.load(f)
-
-        if isinstance(queue, list) and len(queue) > 0:
-            queue = queue[1:]  # Remove first item
-            with open(queue_path, "w") as f:
-                json.dump(queue, f)
-    except (json.JSONDecodeError, OSError):
-        pass
-
-
-def notify_cyclist(project_root: Path, message_text: str) -> None:
-    """Notify Cyclist browser that a queued message was consumed.
-
-    Args:
-        project_root: Project root directory
-        message_text: The message text that was consumed
-    """
-    try:
-        send_to_cyclist(
-            endpoint="/api/bell-consumed",
-            data={"text": message_text},
-            project_root=project_root,
-            timeout=5,
-        )
-    except Exception:
-        # Ignore errors - don't block hook
-        pass
-
-
-# =============================================================================
-# Tandem Observation Injection (Story 95-7 / MSSCI-14672)
-# =============================================================================
-# Stubs for tandem observation injection. Dev will implement.
-
-
-def read_tandem_observations(project_root: Path) -> list[Path]:
-    """Find tandem observation files in .session/ directory.
-
-    Looks for files matching .session/*-tandem-*.md pattern.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        List of Path objects for tandem observation files
-    """
-    session_dir = project_root / ".session"
-    if not session_dir.is_dir():
-        return []
-    return sorted(session_dir.glob("*-tandem-*.md"))
-
-
-def get_latest_observation(file_content: str) -> dict | None:
-    """Extract the latest observation entry from a tandem observation file.
-
-    Parses the markdown format to extract the most recent ## [HH:MM] Observation
-    block, including the observer persona name from the file header.
-
-    Args:
-        file_content: Full text content of the tandem observation file
-
-    Returns:
-        Dict with 'persona' and 'text' keys, or None if no observations found
-    """
-    # Extract persona from header: **Observer:** agent (Persona Name)
-    persona_match = re.search(r"\*\*Observer:\*\*\s*\w+\s*\(([^)]+)\)", file_content)
-    persona = persona_match.group(1) if persona_match else "Unknown"
-
-    # Split on observation headers: ## [HH:MM] Observation
-    entries = re.split(r"## \[\d{1,2}:\d{2}\] Observation\n", file_content)
-    if len(entries) < 2:
-        return None
-
-    # Last entry is the most recent observation
-    last_entry = entries[-1].strip()
-    # Remove trailing --- separator
-    last_entry = re.sub(r"\n---\s*$", "", last_entry).strip()
-    # Remove the **Trigger:** line
-    lines = last_entry.split("\n")
-    text_lines = [line for line in lines if not line.startswith("**Trigger:**")]
-    text = "\n".join(text_lines).strip()
-
-    if not text:
-        return None
-
-    return {"persona": persona, "text": text}
-
-
 def format_tandem_message(persona_name: str, observation_text: str) -> str:
-    """Format a tandem observation as a bell mode injection message.
-
-    Args:
-        persona_name: The backseat agent's persona name
-        observation_text: The observation summary text
-
-    Returns:
-        Formatted string: [Tandem] {persona_name}: {observation_text}
-    """
+    """Format a tandem observation as a bell mode injection message."""
     return f"[Tandem] {persona_name}: {observation_text}"
 
 
-def get_tandem_mtime(project_root: Path, agent: str) -> float:
-    """Read the last-checked mtime for a tandem agent's observation file.
-
-    Args:
-        project_root: Project root directory
-        agent: Agent name (e.g. 'reviewer', 'tea')
-
-    Returns:
-        Last-checked mtime as float, or 0.0 if no sidecar exists
-    """
-    sidecar = project_root / ".session" / f".tandem-mtime-{agent}"
-    if not sidecar.exists():
-        return 0.0
-    try:
-        return float(sidecar.read_text().strip())
-    except (ValueError, OSError):
-        return 0.0
-
-
-def save_tandem_mtime(project_root: Path, agent: str, mtime: float) -> None:
-    """Save the mtime for a tandem agent's observation file.
-
-    Writes to .session/.tandem-mtime-{agent} sidecar file.
-
-    Args:
-        project_root: Project root directory
-        agent: Agent name (e.g. 'reviewer', 'tea')
-        mtime: The mtime value to save
-    """
-    sidecar = project_root / ".session" / f".tandem-mtime-{agent}"
-    try:
-        sidecar.write_text(str(mtime))
-    except OSError:
-        pass
-
-
-def check_tandem_files(project_root: Path) -> list[dict]:
-    """Check for new tandem observations and return injection messages.
-
-    Main entry point for tandem injection in the PostToolUse hook.
-    Always active — no configuration required. The presence of tandem
-    observation files in .session/ is the only signal needed.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        List of dicts with 'agent', 'message' keys for each new observation
-    """
-    tandem_files = read_tandem_observations(project_root)
-    if not tandem_files:
-        return []
-
-    results = []
-    for obs_file in tandem_files:
-        # Extract agent name from filename: *-tandem-{agent}.md
-        agent_match = re.search(r"-tandem-(\w+)\.md$", obs_file.name)
-        if not agent_match:
-            continue
-        agent = agent_match.group(1)
-
-        # Compare mtime
-        try:
-            file_mtime = obs_file.stat().st_mtime
-        except OSError:
-            continue
-        saved_mtime = get_tandem_mtime(project_root, agent)
-        if file_mtime == saved_mtime:
-            continue
-
-        # Read and parse
-        try:
-            content = obs_file.read_text()
-        except OSError:
-            continue
-        obs = get_latest_observation(content)
-        if not obs:
-            # Update mtime even for unparseable files to avoid re-checking
-            save_tandem_mtime(project_root, agent, file_mtime)
-            continue
-
-        message = format_tandem_message(obs["persona"], obs["text"])
-        results.append({"agent": agent, "message": message})
-
-        # Update mtime sidecar
-        save_tandem_mtime(project_root, agent, file_mtime)
-
-    return results
-
-
-def main() -> None:
-    """Main entry point for PostToolUse hook."""
-    try:
-        # Read and discard stdin (required by hook protocol)
-        sys.stdin.read()
-
-        # Find project root
-        project_root = find_project_root()
-        if not project_root:
-            sys.exit(0)
-
-        # --- Bell queue (Cyclist only, requires bell_mode: true) ---
-        # Takes precedence over tandem when active.
-        is_cyclist = read_port_file(CYCLIST_PORT_FILE, project_root) is not None
-        if is_cyclist and is_bell_mode_enabled(project_root):
-            queue = read_bell_queue(project_root)
-            if queue:
-                first_message = queue[0]
-                message_text = first_message.get("text", "")
-                if message_text:
-                    output_hook_response(HookResponse(
-                        event_name="PostToolUse",
-                        additional_context=f"User feedback: {message_text}",
-                    ))
-                    dequeue_message(project_root)
-                    notify_cyclist(project_root, message_text)
-                    sys.exit(0)
-
-        # --- Tandem observations (always active, no config required) ---
-        tandem_results = check_tandem_files(project_root)
-        if tandem_results:
-            output_hook_response(HookResponse(
-                event_name="PostToolUse",
-                additional_context=tandem_results[0]["message"],
-            ))
-
-        sys.exit(0)
-
-    except Exception as e:
-        print(f"[bellmode-hook] Error: {e}", file=sys.stderr)
-        sys.exit(0)
-
-
 if __name__ == "__main__":
     main()

package/pennyfarthing_scripts/bikerack/audit_log_panel.py

@@ -0,0 +1,119 @@
+"""AuditLogPanel — Real-time tool event audit log for BikeRack TUI.
+
+Story 110-8: Subscribes to /ws/spans, displays tool events in a native
+Textual DataTable with timestamp, tool name, input excerpt, and result.
+
+Uses native Textual widgets (DataTable) instead of Rich renderables.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from rich.console import Console
+from textual._context import NoActiveAppError
+from textual.widgets import DataTable
+
+from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
+
+MAX_INPUT_LENGTH = 80
+
+# Shared fallback console for offline column/cell measurement
+_FALLBACK_CONSOLE = Console()
+
+
+class _OfflineDataTable(DataTable):
+    """DataTable subclass that works without an active Textual app.
+
+    Textual's DataTable.add_columns/add_row need self.app.console for
+    column width measurement. This subclass provides a fallback Rich Console
+    so the table can be constructed and populated in unit tests.
+    """
+
+    @property
+    def app(self):
+        try:
+            return super().app
+        except NoActiveAppError:
+            return type("_Stub", (), {"console": _FALLBACK_CONSOLE})()
+
+
+class AuditLogPanel(BasePanel):
+    """Audit log panel — real-time tool event display via DataTable.
+
+    Subscribes to the 'spans' WebSocket channel and renders tool events
+    in a native Textual DataTable with columns: Time, Tool, Input, Result.
+    """
+
+    channel: str = "spans"
+    panel_name: str = "Audit Log"
+    icon: str = PANEL_ICONS["audit-log"][0]
+
+    def __init__(self, client=None, **kwargs):
+        super().__init__(client=client, **kwargs)
+        self._table = _OfflineDataTable()
+        self._table.add_columns("Time", "Tool", "Input", "Result")
+
+    def handle_message(self, message: dict[str, Any] | None) -> None:
+        """Handle incoming WebSocket messages for tool events.
+
+        Overrides BasePanel.handle_message to manipulate DataTable directly
+        instead of going through render_panel/post_message.
+        """
+        if not self._mounted or message is None:
+            return
+        if not isinstance(message, dict):
+            return
+
+        msg_type = message.get("type")
+
+        if msg_type == "init":
+            spans = message.get("spans")
+            if not isinstance(spans, list):
+                return
+            self._table.clear()
+            for span in spans:
+                if isinstance(span, dict):
+                    self._add_row(span)
+
+        elif msg_type == "span":
+            span = message.get("span")
+            if isinstance(span, dict):
+                self._add_row(span)
+
+    def _add_row(self, span: dict[str, Any]) -> None:
+        """Add a single tool event row to the DataTable."""
+        timestamp = span.get("timestamp")
+        tool_name = span.get("toolName", "")
+        input_text = span.get("input", "")
+        success = span.get("success")
+
+        time_str = _format_timestamp(timestamp)
+
+        if len(input_text) > MAX_INPUT_LENGTH:
+            input_text = input_text[: MAX_INPUT_LENGTH - 1] + "\u2026"
+
+        if success is True:
+            result = "\u2713"
+        elif success is False:
+            result = "\u2717"
+        else:
+            result = "\u2014"
+
+        self._table.add_row(time_str, tool_name, input_text, result)
+
+    def render_panel(self, payload: dict[str, Any]) -> Any:
+        """Not used — handle_message manages DataTable directly."""
+        return self._table
+
+
+def _format_timestamp(ts: Any) -> str:
+    """Format millisecond timestamp to HH:MM:SS."""
+    if ts is None:
+        return "\u2014"
+    try:
+        dt = datetime.fromtimestamp(float(ts) / 1000, tz=timezone.utc)
+        return dt.strftime("%H:%M:%S")
+    except (ValueError, TypeError, OSError):
+        return "\u2014"

package/pennyfarthing_scripts/bikerack/background_panel.py

@@ -6,12 +6,13 @@ list with status indicators (running, completed, failed).
 
 from __future__ import annotations
 
+import time
 from typing import Any
 
 from rich.console import Group
 from rich.text import Text
 
-from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
+from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel, format_duration
 
 
 class BackgroundPanel(BasePanel):
@@ -25,12 +26,62 @@ class BackgroundPanel(BasePanel):
     panel_name: str = "Background"
     icon: str = PANEL_ICONS["background"][0]
 
+    def __init__(self, client=None, **kwargs):
+        super().__init__(client=client, **kwargs)
+        self._timer = None
+
+    def on_mount(self) -> None:
+        """Subscribe to channel and start elapsed timer."""
+        super().on_mount()
+        self._timer = self.set_interval(1, self._tick)
+
+    def on_unmount(self) -> None:
+        """Stop timer and cleanup."""
+        if self._timer is not None:
+            self._timer.stop()
+        super().on_unmount()
+
+    def _tick(self) -> None:
+        """Re-render every second to update elapsed times."""
+        if self._last_payload is not None:
+            rendered = self.render_panel(self._last_payload)
+            try:
+                self.update(rendered)
+            except Exception:
+                pass
+
     def render_panel(self, payload: dict[str, Any]) -> Any:
         """Render background task data from WebSocket payload."""
         tasks = payload.get("tasks", [])
         if not isinstance(tasks, list) or not tasks:
             return Text("No background tasks", style="dim italic")
 
+        running = 0
+        done = 0
+        failed = 0
+        for task in tasks:
+            if not isinstance(task, dict):
+                continue
+            if task.get("completedAt") is not None:
+                if task.get("success"):
+                    done += 1
+                else:
+                    failed += 1
+            else:
+                running += 1
+
+        # Summary header
+        summary = Text()
+        summary.append(f"{running} running", style="yellow")
+        summary.append("  ")
+        summary.append(f"{done} done", style="green")
+        if failed > 0:
+            summary.append("  ")
+            summary.append(f"{failed} failed", style="red")
+
+        separator = Text("─" * 30, style="dim")
+
+        # Task list
         parts: list[Any] = []
         for task in tasks:
             if not isinstance(task, dict):
@@ -40,7 +91,7 @@ class BackgroundPanel(BasePanel):
         if not parts:
             return Text("No background tasks", style="dim italic")
 
-        return Group(*parts)
+        return Group(summary, separator, *parts)
 
 
 def _render_task(task: dict[str, Any]) -> Text:
@@ -48,6 +99,7 @@ def _render_task(task: dict[str, Any]) -> Text:
     description = task.get("description", "Unknown task")
     subagent_type = task.get("subagentType", "")
     completed_at = task.get("completedAt")
+    started_at = task.get("startedAt")
     success = task.get("success")
     result = task.get("result", "")
     error = task.get("error", "")
@@ -60,7 +112,12 @@ def _render_task(task: dict[str, Any]) -> Text:
             line.append(description)
             if subagent_type:
                 line.append(f" [{subagent_type}]", style="dim")
-            line.append(" — done", style="green")
+            # Show duration if timestamps available
+            duration = _calc_duration(started_at, completed_at)
+            if duration:
+                line.append(f" — {duration}", style="green")
+            else:
+                line.append(" — done", style="green")
             if result:
                 line.append(f" ({result})", style="dim green")
         else:
@@ -68,7 +125,11 @@ def _render_task(task: dict[str, Any]) -> Text:
             line.append(description)
             if subagent_type:
                 line.append(f" [{subagent_type}]", style="dim")
-            line.append(" — failed", style="red")
+            duration = _calc_duration(started_at, completed_at)
+            if duration:
+                line.append(f" — {duration}", style="red")
+            else:
+                line.append(" — failed", style="red")
             if error:
                 line.append(f"\n  {error}", style="red")
     else:
@@ -76,6 +137,26 @@ def _render_task(task: dict[str, Any]) -> Text:
         line.append(description)
         if subagent_type:
             line.append(f" [{subagent_type}]", style="dim")
-        line.append(" — running", style="yellow")
+        # Live elapsed time for running tasks
+        if started_at:
+            try:
+                elapsed = time.time() - float(started_at) / 1000  # startedAt is typically ms
+                line.append(f" — {format_duration(elapsed)}", style="yellow")
+            except (ValueError, TypeError):
+                line.append(" — running", style="yellow")
+        else:
+            line.append(" — running", style="yellow")
 
     return line
+
+
+def _calc_duration(started_at, completed_at) -> str:
+    """Calculate duration string from timestamps."""
+    if started_at is None or completed_at is None:
+        return ""
+    try:
+        start = float(started_at) / 1000  # ms to seconds
+        end = float(completed_at) / 1000
+        return format_duration(end - start)
+    except (ValueError, TypeError):
+        return ""