@pennyfarthing/core 11.2.2 → 11.3.2

package/pennyfarthing-dist/workflows/tdd-tandem.yaml

@@ -23,6 +23,10 @@ workflow:
     - name: setup
       agent: sm
       output: [session_file, branches, story_context]
+      gate:
+        file: gates/sm-setup-exit
+        type: sm_setup_exit
+        condition: Session file created with workflow, phase, context, and branch
 
     - name: red
       agent: tea
@@ -41,9 +45,9 @@ workflow:
       input: [failing_tests, story_context]
       output: [implementation, passing_tests]
       gate:
-        file: gates/tests-pass
-        type: tests_pass
-        condition: All tests passing, no skipped tests
+        file: gates/dev-exit
+        type: dev_exit
+        condition: Tests green, tree clean, no debug code, correct branch
       tandem:
         partner: architect
         scope: file-watch

package/pennyfarthing-dist/workflows/tdd.yaml

@@ -13,6 +13,10 @@ workflow:
     - name: setup
       agent: sm
       output: [session_file, branches, story_context]
+      gate:
+        file: gates/sm-setup-exit
+        type: sm_setup_exit
+        condition: Session file created with workflow, phase, context, and branch
 
     - name: red
       agent: tea
@@ -28,9 +32,9 @@ workflow:
       input: [failing_tests, story_context]
       output: [implementation, passing_tests]
       gate:
-        file: gates/tests-pass
-        type: tests_pass
-        condition: All tests passing, no skipped tests
+        file: gates/dev-exit
+        type: dev_exit
+        condition: Tests green, tree clean, no debug code, correct branch
 
     - name: verify
       agent: tea

package/pennyfarthing-dist/workflows/trivial.yaml

@@ -13,15 +13,19 @@ workflow:
     - name: setup
       agent: sm
       output: [session_file, branches]
+      gate:
+        file: gates/sm-setup-exit
+        type: sm_setup_exit
+        condition: Session file created with workflow, phase, and branch
 
     - name: implement
       agent: dev
       input: [session_file]
       output: [implementation]
       gate:
-        file: gates/tests-pass
-        type: tests_pass
-        condition: Existing tests still pass
+        file: gates/dev-exit
+        type: dev_exit
+        condition: Tests green, tree clean, no debug code, correct branch
 
     - name: review
       agent: reviewer

package/pennyfarthing_scripts/bc/cli.py

@@ -29,6 +29,7 @@ from pennyfarthing_scripts.bc.focus import (
     save_named_layout,
     set_panel_focus,
 )
+from pennyfarthing_scripts.bc.split import set_split_layout
 
 
 def _get_current_layout() -> dict | None:
@@ -206,6 +207,26 @@ def clear_layout(name: str, dry_run: bool):
         sys.exit(1)
 
 
+@bc.command("split")
+@click.argument("left")
+@click.argument("right")
+@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
+def split_layout(left: str, right: str, dry_run: bool):
+    """Set split-pane layout with LEFT and RIGHT panels.
+
+    Example: pf bc split sprint diffs
+    """
+    if dry_run:
+        click.echo(json.dumps({"dry_run": True, "action": "split", "left": left, "right": right}))
+        return
+    result = set_split_layout(left, right)
+    if result["success"]:
+        click.echo(json.dumps({"success": True, "split": result["data"]}))
+    else:
+        click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
+        sys.exit(1)
+
+
 @bc.command("clear-all")
 @click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
 def clear_all_layouts(dry_run: bool):

package/pennyfarthing_scripts/bc/focus.py

@@ -34,6 +34,7 @@ VALID_PANELS = [
     "changed",
     "ac",
     "debug",
+    "progress",
     "settings",
     "tty",
 ]

package/pennyfarthing_scripts/bc/split.py

@@ -0,0 +1,52 @@
+"""Split layout management — read/write split config in config.local.yaml.
+
+Story 110-4: /bc split <left> <right> command support.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pennyfarthing_scripts.bc.focus import (
+    VALID_PANELS,
+    _read_config,
+    _write_config,
+)
+
+
+def set_split_layout(
+    left: str, right: str, project_dir: Path | None = None
+) -> dict:
+    """Set split layout in config.local.yaml.
+
+    Args:
+        left: Panel for left pane (must be in VALID_PANELS).
+        right: Panel for right pane (must be in VALID_PANELS).
+        project_dir: Override project root (for testing).
+
+    Returns:
+        {success: bool, data?: dict, error?: str}
+    """
+    if left not in VALID_PANELS:
+        return {
+            "success": False,
+            "error": f"Invalid panel '{left}'. Valid panels: {', '.join(VALID_PANELS)}",
+        }
+    if right not in VALID_PANELS:
+        return {
+            "success": False,
+            "error": f"Invalid panel '{right}'. Valid panels: {', '.join(VALID_PANELS)}",
+        }
+    if left == right:
+        return {
+            "success": False,
+            "error": f"Left and right panels must be different (both are '{left}'). Use same panel in single mode instead.",
+        }
+
+    try:
+        config_path, config = _read_config(project_dir)
+        config["split"] = {"left": left, "right": right}
+        _write_config(config_path, config)
+        return {"success": True, "data": {"left": left, "right": right}}
+    except Exception as exc:
+        return {"success": False, "error": str(exc)}

package/pennyfarthing_scripts/bikerack/context_meter_footer.py

@@ -4,11 +4,15 @@ Story 110-5: Context meter footer bar. Displays context window usage
 percentage with color-coded tier thresholds, always visible at the
 bottom of the layout.
 
+Story 110-12: Periodic refresh timer, event-driven redraws, and
+throttling for more frequent updates without performance degradation.
+
 Subscribes to /ws/context WebSocket channel.
 """
 
 from __future__ import annotations
 
+import time
 from typing import Any
 
 from rich.text import Text
@@ -35,34 +39,80 @@ class ContextMeterFooter(Static):
     #: WebSocket channel this footer subscribes to
     channel: str = "context"
 
+    #: Seconds between periodic refresh redraws
+    refresh_interval: float = 5.0
+
+    #: Minimum seconds between redraws (throttle)
+    min_redraw_interval: float = 0.25
+
     def __init__(self, client: Any = None, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._client = client
         self._context_data: dict[str, Any] | None = None
         self._mounted = False
+        self._refresh_timer: Any = None
+        self._last_redraw_time: float = 0.0
+        self.last_update_time: float = 0.0
+
+    @property
+    def is_stale(self) -> bool:
+        """True if no context data has been received."""
+        return self._context_data is None
 
     def on_mount(self) -> None:
-        """Subscribe to context channel on mount."""
+        """Subscribe to context channel and start periodic refresh on mount."""
         self._mounted = True
         if self._client is not None:
             self._client.subscribe("context", self.handle_context_message)
+            self._client.on_state_change(self.on_connection_state_change)
+        try:
+            self._refresh_timer = self.set_interval(
+                self.refresh_interval, self.request_refresh
+            )
+        except RuntimeError:
+            # No running event loop (e.g. unit tests calling on_mount directly)
+            pass
 
     def on_unmount(self) -> None:
-        """Mark as unmounted so further messages are ignored."""
+        """Stop timer and mark as unmounted so further messages are ignored."""
         self._mounted = False
+        if self._refresh_timer is not None:
+            self._refresh_timer.stop()
 
     def on_context_meter_footer_meter_update(self, event: MeterUpdate) -> None:
         """Process MeterUpdate in Textual message context — triggers repaint."""
         self.update(event.content)
 
+    def request_refresh(self) -> None:
+        """Redraw from cached context data. Safe to call at any time."""
+        if not self._mounted or self._context_data is None:
+            return
+        try:
+            rendered = self.render_meter(self._context_data)
+            self.post_message(self.MeterUpdate(rendered))
+        except Exception:
+            pass
+
+    def on_connection_state_change(self, state: Any) -> None:
+        """Redraw on WebSocket reconnection."""
+        self.request_refresh()
+
     def handle_context_message(self, msg: dict[str, Any] | None) -> None:
-        """Process incoming /ws/context message."""
+        """Process incoming /ws/context message with throttling."""
         if not self._mounted or msg is None:
             return
         ctx = msg.get("context")
         if ctx is None:
             return
         self._context_data = ctx
+        self.last_update_time = time.monotonic()
+
+        # Throttle: skip redraw if too soon after last one
+        now = time.monotonic()
+        if now - self._last_redraw_time < self.min_redraw_interval:
+            return
+        self._last_redraw_time = now
+
         try:
             rendered = self.render_meter(ctx)
             self.post_message(self.MeterUpdate(rendered))

package/pennyfarthing_scripts/bikerack/tui.py

@@ -106,6 +106,14 @@ PANEL_DISPLAY_NAMES: dict[str, str] = {
 # Keys from PANEL_REGISTRY for fast lookup
 _PANEL_KEYS = [key for key, _ in PANEL_REGISTRY]
 
+# Split-pane layout presets: name → (left_panel, right_panel)
+# Story 110-4: Named presets for common side-by-side views.
+SPLIT_PRESETS: dict[str, tuple[str, str]] = {
+    "sprint+diffs": ("sprint", "diffs"),
+    "changed+diffs": ("changed", "diffs"),
+    "progress+debug": ("progress", "debug"),
+}
+
 
 class BindingFooter(Footer):
     """Footer subclass that exposes active binding text via render().
@@ -360,9 +368,10 @@ class BikeRackApp(App):
     class FocusUpdate(Message, bubble=False):
         """Focus change from WS — routed through Textual message system."""
 
-        def __init__(self, focus: str | None) -> None:
+        def __init__(self, focus: str | None, split_config: dict | None = None) -> None:
             super().__init__()
             self.focus = focus
+            self.split_config = split_config
 
     class WsStateUpdate(Message, bubble=False):
         """WS connection state change — routed through Textual message system."""
@@ -413,12 +422,23 @@ class BikeRackApp(App):
     ContextMeterFooter {
         height: 1;
     }
+    #split-container {
+        display: none;
+        height: 1fr;
+    }
+    #split-left {
+        width: 1fr;
+    }
+    #split-right {
+        width: 1fr;
+    }
     """
 
     COMMANDS = App.COMMANDS | {PanelCommands}
 
     BINDINGS = [
         Binding("q", "quit", "Quit"),
+        Binding("shift+s", "toggle_split", "Split"),
         Binding("1", "switch_panel('sprint')", "Sprint", show=False),
         Binding("2", "switch_panel('git')", "Git", show=False),
         Binding("3", "switch_panel('diffs')", "Diffs", show=False),
@@ -429,8 +449,8 @@ class BikeRackApp(App):
         Binding("8", "switch_panel('progress')", "Progress", show=False),
         Binding("bracketright", "next_panel", "]Next"),
         Binding("bracketleft", "prev_panel", "[Prev"),
-        Binding("tab", "next_panel", show=False),
-        Binding("shift+tab", "prev_panel", show=False),
+        Binding("tab", "next_panel", show=False, priority=True),
+        Binding("shift+tab", "prev_panel", show=False, priority=True),
         Binding("n", "next_diff_file", "Next file", show=False),
         Binding("p", "prev_diff_file", "Prev file", show=False),
         Binding("j", "next_epic", show=False),
@@ -448,6 +468,12 @@ class BikeRackApp(App):
         self._focused_panel: str = "sprint"
         self._previous_panel: str | None = None
         self._programmatic_tab_count: int = 0
+        self._context_meter: ContextMeterFooter | None = None
+        # Split-pane state (Story 110-4)
+        self._split_mode: bool = False
+        self._active_split_pane: str = "left"
+        self._split_left_key: str = "sprint"
+        self._split_right_key: str = "diffs"
 
     def compose(self) -> ComposeResult:
         project_dir_name = Path(
@@ -470,7 +496,11 @@ class BikeRackApp(App):
             yield AuditLogPanel(client=self._client, id="panel-audit-log")
             yield DebugPanel(client=self._client, id="panel-debug")
             yield ProgressPanel(client=self._client, id="panel-progress")
-        yield ContextMeterFooter(client=self._client)
+        with Horizontal(id="split-container"):
+            yield VerticalScroll(id="split-left")
+            yield VerticalScroll(id="split-right")
+        self._context_meter = ContextMeterFooter(client=self._client)
+        yield self._context_meter
         yield BindingFooter()
 
     async def on_mount(self) -> None:
@@ -543,8 +573,27 @@ class BikeRackApp(App):
         save_last_panel(key, project_dir=None)
         self._update_tab_bar(key)
 
+        # Refresh context meter on panel switch (110-12)
+        if self._context_meter is not None:
+            self._context_meter.request_refresh()
+
     def action_next_panel(self) -> None:
-        """Cycle to the next panel."""
+        """Cycle to the next panel, or toggle pane focus in split mode."""
+        if self._split_mode:
+            # In split mode, Tab toggles between left and right pane
+            if self._active_split_pane == "left":
+                self._active_split_pane = "right"
+                try:
+                    self.query_one("#split-right").focus()
+                except Exception:
+                    pass
+            else:
+                self._active_split_pane = "left"
+                try:
+                    self.query_one("#split-left").focus()
+                except Exception:
+                    pass
+            return
         try:
             idx = _PANEL_KEYS.index(self._focused_panel)
         except ValueError:
@@ -606,6 +655,131 @@ class BikeRackApp(App):
             except Exception:
                 pass
 
+    # ------------------------------------------------------------------
+    # Split-pane layout (Story 110-4)
+    # ------------------------------------------------------------------
+
+    def _sync_reparent(self, widget: Any, new_parent: Any) -> None:
+        """Move widget from current parent to new parent synchronously.
+
+        Uses internal Textual DOM API so the move is visible immediately
+        without awaiting an async mount/remove cycle.
+        """
+        old_parent = widget._parent
+        if old_parent is not None:
+            try:
+                old_parent._nodes._remove(widget)
+            except (ValueError, AttributeError):
+                # Fallback: remove from internal list directly
+                try:
+                    old_parent._nodes._nodes.remove(widget)
+                except Exception:
+                    pass
+        try:
+            new_parent._nodes._append(widget)
+        except AttributeError:
+            new_parent._nodes._nodes.append(widget)
+        widget._parent = new_parent
+
+    def _enter_split(self, left_key: str, right_key: str) -> None:
+        """Activate split mode with specified panels (synchronous)."""
+        if left_key not in _PANEL_KEYS or right_key not in _PANEL_KEYS:
+            return
+        if left_key == right_key:
+            return
+
+        self._split_mode = True
+        self._split_left_key = left_key
+        self._split_right_key = right_key
+        self._active_split_pane = "left"
+
+        try:
+            main_content = self.query_one("#main-content")
+            split_container = self.query_one("#split-container")
+            split_left = self.query_one("#split-left")
+            split_right = self.query_one("#split-right")
+        except Exception:
+            return
+
+        # Move left panel to split-left pane
+        try:
+            left_panel = self.query_one(f"#panel-{left_key}")
+            left_panel.display = True
+            self._sync_reparent(left_panel, split_left)
+        except Exception:
+            pass
+
+        # Move right panel to split-right pane
+        try:
+            right_panel = self.query_one(f"#panel-{right_key}")
+            right_panel.display = True
+            self._sync_reparent(right_panel, split_right)
+        except Exception:
+            pass
+
+        # Hide all other panels remaining in main-content
+        for panel_key in _PANEL_KEYS:
+            if panel_key not in (left_key, right_key):
+                try:
+                    p = self.query_one(f"#panel-{panel_key}")
+                    p.display = False
+                except Exception:
+                    pass
+
+        main_content.display = False
+        split_container.display = True
+
+    def _exit_split(self) -> None:
+        """Deactivate split mode, return panels to main-content."""
+        self._split_mode = False
+
+        try:
+            main_content = self.query_one("#main-content")
+            split_container = self.query_one("#split-container")
+            split_left = self.query_one("#split-left")
+            split_right = self.query_one("#split-right")
+        except Exception:
+            return
+
+        # Move panels back from split panes to main-content
+        for pane in (split_left, split_right):
+            for child in list(pane.children):
+                self._sync_reparent(child, main_content)
+
+        split_container.display = False
+        main_content.display = True
+
+        # Restore single-panel visibility
+        for panel_key in _PANEL_KEYS:
+            try:
+                p = self.query_one(f"#panel-{panel_key}")
+                p.display = (panel_key == self._focused_panel)
+            except Exception:
+                pass
+
+    def action_toggle_split(self) -> None:
+        """Toggle split mode on/off (Shift+S keybinding)."""
+        if self._split_mode:
+            self._exit_split()
+        else:
+            # Default: current panel left, next panel right
+            left_key = self._focused_panel
+            try:
+                idx = _PANEL_KEYS.index(left_key)
+            except ValueError:
+                idx = 0
+            right_key = _PANEL_KEYS[(idx + 1) % len(_PANEL_KEYS)]
+            self._enter_split(left_key, right_key)
+
+    def action_apply_split_preset(self, name: str) -> None:
+        """Apply a named split preset (synchronous)."""
+        if name not in SPLIT_PRESETS:
+            return
+        left_key, right_key = SPLIT_PRESETS[name]
+        if self._split_mode:
+            self._exit_split()
+        self._enter_split(left_key, right_key)
+
     def _update_tab_bar(self, panel_key: str) -> None:
         """Update the tab bar widget with the given panel key.
 
@@ -638,7 +812,10 @@ class BikeRackApp(App):
     def _handle_focus_message(self, message: dict[str, Any] | None) -> None:
         """Handle incoming focus channel messages.
 
-        Expected format: {type: 'init'|'update', focus: '<panel>'|null}
+        Expected format:
+          Single panel: {type: 'update', focus: '<panel>'}
+          Split layout:  {type: 'update', focus: 'split', split: {left: ..., right: ...}}
+          Split preset:  {type: 'update', focus: 'split:<preset-name>'}
         Only 'update' messages trigger panel switches (matching React hook).
         Routes through Textual message system via post_message for proper repaint.
         """
@@ -648,7 +825,8 @@ class BikeRackApp(App):
             return
         if "focus" not in message:
             return
-        self.post_message(self.FocusUpdate(message["focus"]))
+        split_config = message.get("split")
+        self.post_message(self.FocusUpdate(message["focus"], split_config=split_config))
 
     def _handle_persona_message(self, message: dict[str, Any] | None) -> None:
         """Handle incoming persona channel messages.
@@ -677,7 +855,23 @@ class BikeRackApp(App):
     def on_bike_rack_app_focus_update(self, event: FocusUpdate) -> None:
         """Apply focus change in Textual message context."""
         focus = event.focus
-        if focus is not None and focus in _PANEL_KEYS:
+        split_config = event.split_config
+
+        if focus == "split" and split_config:
+            # Explicit split layout: {focus: "split", split: {left: ..., right: ...}}
+            left = split_config.get("left", "sprint")
+            right = split_config.get("right", "diffs")
+            if self._split_mode:
+                self._exit_split()
+            self._enter_split(left, right)
+        elif focus is not None and focus.startswith("split:"):
+            # Preset reference: {focus: "split:progress+debug"}
+            preset_name = focus[len("split:"):]
+            self.action_apply_split_preset(preset_name)
+        elif focus is not None and focus in _PANEL_KEYS:
+            # Single panel focus — exit split if active
+            if self._split_mode:
+                self._exit_split()
             self.action_switch_panel(focus)
         elif focus is not None:
             self._previous_panel = self._focused_panel

package/pennyfarthing_scripts/bmad/__init__.py

@@ -0,0 +1 @@
+# BMAD adapter — bidirectional sprint sync between BMAD markdown and PF YAML.