@pennyfarthing/core 11.2.1 → 11.3.1

package/pennyfarthing_scripts/bikerack/tui.py

@@ -10,6 +10,7 @@ Panel navigation: Mount all panels, tab bar, keyboard switching, command palette
 
 from __future__ import annotations
 
+import os
 from functools import partial
 from pathlib import Path
 from typing import Any
@@ -105,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().
@@ -359,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."""
@@ -392,6 +402,11 @@ class BikeRackApp(App):
         height: auto;
         width: 1fr;
     }
+    #project-dir {
+        height: 1;
+        padding: 0 1;
+        color: $text-muted;
+    }
     Tabs {
         dock: top;
     }
@@ -407,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),
@@ -423,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),
@@ -442,10 +468,20 @@ 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(
+            os.environ.get("CYCLIST_PROJECT_DIR", os.getcwd())
+        ).name
         yield Header()
         yield AgentHeader(id="agent-header")
+        yield Static(f"[dim]{project_dir_name}[/dim]", id="project-dir")
         yield Tabs(*_build_panel_tabs(), id="tab-bar")
         yield ConnectionStatus(
             STATE_DISPLAY[ConnectionState.DISCONNECTED],
@@ -460,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:
@@ -533,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:
@@ -596,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.
 
@@ -628,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.
         """
@@ -638,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.
@@ -667,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
@@ -693,7 +897,7 @@ def main(
     """Launch BikeRack TUI as a standalone application.
 
     Args:
-        port: Explicit WheelHub port. If None, reads from .wheelhub-port file.
+        port: Explicit WheelHub port. If None, reads from .bikerack-port file.
         project_dir: Project directory for port file discovery. Defaults to cwd.
     """
     # Detect terminal image protocol BEFORE App.run() claims the terminal
@@ -703,7 +907,7 @@ def main(
 
     if port is None:
         if project_dir is not None:
-            port_file = project_dir / ".wheelhub-port"
+            port_file = project_dir / ".bikerack-port"
             if port_file.exists():
                 try:
                     port = int(port_file.read_text().strip())

package/pennyfarthing_scripts/bikerack/ws_client.py

@@ -75,14 +75,14 @@ class WheelHubClient:
             cb(new_state)
 
     def discover_port(self) -> int:
-        """Read port from .wheelhub-port file, fallback to DEFAULT_PORT.
+        """Read port from .bikerack-port file, fallback to DEFAULT_PORT.
 
         Priority: explicit port > port file > DEFAULT_PORT.
         """
         if self._port is not None:
             return self._port
         if self._project_dir is not None:
-            port_file = self._project_dir / ".wheelhub-port"
+            port_file = self._project_dir / ".bikerack-port"
             if port_file.exists():
                 try:
                     return int(port_file.read_text().strip())

package/pennyfarthing_scripts/cli.py

@@ -147,6 +147,11 @@ from pennyfarthing_scripts.hooks.cli import hooks  # noqa: E402
 
 cli.add_command(hooks)
 
+# Import and register settings group
+from pennyfarthing_scripts.settings.cli import settings  # noqa: E402
+
+cli.add_command(settings)
+
 
 @cli.group()
 def agent():

package/pennyfarthing_scripts/common/config.py

@@ -82,11 +82,38 @@ def load_yaml_config(path: Path) -> dict[str, Any] | None:
         return yaml.safe_load(f)
 
 
-def load_pennyfarthing_config() -> dict[str, Any]:
+def load_pennyfarthing_config(project_root: Path | None = None) -> dict[str, Any]:
     """Load .pennyfarthing/config.local.yaml.
 
+    Args:
+        project_root: Project root path (defaults to auto-detect)
+
     Returns:
         Config dict, or empty dict if not found
     """
-    config_path = get_project_root() / ".pennyfarthing" / "config.local.yaml"
+    root = project_root or get_project_root()
+    config_path = root / ".pennyfarthing" / "config.local.yaml"
     return load_yaml_config(config_path) or {}
+
+
+def save_pennyfarthing_config_key(
+    key: str, value: Any, project_root: Path | None = None
+) -> None:
+    """Set a top-level key in .pennyfarthing/config.local.yaml.
+
+    Creates the file if it doesn't exist. Preserves existing keys.
+
+    Args:
+        key: Top-level key (e.g., "sprint")
+        value: Value to set (dict, str, etc.)
+        project_root: Project root path (defaults to auto-detect)
+    """
+    root = project_root or get_project_root()
+    config_path = root / ".pennyfarthing" / "config.local.yaml"
+
+    config = load_yaml_config(config_path) or {}
+    config[key] = value
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)

package/pennyfarthing_scripts/consultation/cli.py

@@ -6,7 +6,7 @@ the bash wrapper dialogue-manager.sh interface.
 
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 
 import click
@@ -44,7 +44,7 @@ def init(story_id: str, workflow: str, leader: str, partner: str) -> None:
         workflow=workflow,
         leader=leader,
         partner=partner,
-        started_at=datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        started_at=datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
     )
 
     content = create_dialogue_content(header)
@@ -80,7 +80,7 @@ def append(story_id: str, question: str, recommendation: str, confidence: str) -
 
     exchange = DialogueExchange(
         number=next_num,
-        timestamp=datetime.now(timezone.utc).strftime("%H:%M"),
+        timestamp=datetime.now(UTC).strftime("%H:%M"),
         leader="",
         partner="",
         question=question,

package/pennyfarthing_scripts/context.py

@@ -269,7 +269,7 @@ def detect_cyclist(project_dir: str | None = None) -> bool:
 
     Checks:
     1. CYCLIST env var set to '1' (Electron mode - definitive)
-    2. .wheelhub-port file exists AND port is responding (Web mode)
+    2. .bikerack-port file exists AND port is responding (Web mode)
     """
     # Env var is definitive - set by Cyclist when it spawns Claude
     if os.environ.get("CYCLIST") == "1":
@@ -284,8 +284,8 @@ def detect_cyclist(project_dir: str | None = None) -> bool:
     )
 
     port_files = [
-        Path(project_dir) / "packages" / "cyclist" / ".wheelhub-port",
-        Path(os.getcwd()) / ".wheelhub-port",
+        Path(project_dir) / "packages" / "cyclist" / ".bikerack-port",
+        Path(os.getcwd()) / ".bikerack-port",
     ]
 
     for port_file in port_files:

package/pennyfarthing_scripts/git/hooks_installer.py

@@ -10,7 +10,6 @@ Usage via CLI:
 
 from __future__ import annotations
 
-import re
 from pathlib import Path
 
 from pennyfarthing_scripts.common.config import get_project_root
@@ -70,8 +69,8 @@ def install_git_hooks(project_root: Path | None = None) -> int:
         return 1
 
     print("Installing git hooks with .d/ dispatcher pattern...")
-    print(f"  Source: pennyfarthing-dist/scripts/hooks/")
-    print(f"  Dest:   .git/hooks/")
+    print("  Source: pennyfarthing-dist/scripts/hooks/")
+    print("  Dest:   .git/hooks/")
     print()
 
     for source_file, dest_name in HOOKS:

package/pennyfarthing_scripts/git/status_all.py

@@ -291,7 +291,7 @@ async def main(brief: bool = False) -> int:
     Returns:
         0 if all repos clean, 1 if any have changes/unpushed
     """
-    from pennyfarthing_scripts.git.repos import load_repos_config, get_repo_paths
+    from pennyfarthing_scripts.git.repos import get_repo_paths, load_repos_config
 
     repos_with_upstream: list[tuple[str, Path, str]] = []
     repo_paths = get_repo_paths()

package/pennyfarthing_scripts/git/worktree.py

@@ -199,7 +199,7 @@ def remove_worktree(name: str) -> int:
         shutil.rmtree(wt_path)
 
     # Prune worktree references
-    for repo_name, cfg in repos.items():
+    for _repo_name, cfg in repos.items():
         full_path = (project_root / cfg.path).resolve()
         if full_path.exists():
             _git(["worktree", "prune"], full_path)
@@ -277,7 +277,7 @@ def show_worktree_status() -> int:
             if repo_wt.exists():
                 branch, _ = _git(["branch", "--show-current"], repo_wt)
                 status_out, _ = _git(["status", "--short"], repo_wt)
-                count = len([l for l in status_out.split("\n") if l.strip()]) if status_out else 0
+                count = len([line for line in status_out.split("\n") if line.strip()]) if status_out else 0
                 print(f"  {repo_name} ({cfg.repo_type}): {branch} ({count} uncommitted)")
 
         # Check for session files referencing this worktree

package/pennyfarthing_scripts/hooks/__init__.py

@@ -30,7 +30,7 @@ import yaml
 
 # WheelHub port file - central coordination server for all communication
 # Per ADR-0004: "the hub where all communication converges"
-CYCLIST_PORT_FILE = ".wheelhub-port"
+CYCLIST_PORT_FILE = ".bikerack-port"
 
 # Default port if file not found
 DEFAULT_CYCLIST_PORT = 7431
@@ -48,7 +48,7 @@ def find_project_root(start_dir: Path | None = None) -> Path | None:
     """Find the project root by looking for marker files.
 
     Searches for (in order):
-    1. .wheelhub-port (WheelHub is running)
+    1. .bikerack-port (WheelHub is running)
     2. .pennyfarthing directory
     3. .claude directory
 
@@ -84,7 +84,7 @@ def read_port_file(file_name: str, project_root: Path | None = None) -> int | No
     """Read a port number from a Cyclist port file.
 
     Args:
-        file_name: Name of the port file (e.g. .wheelhub-port)
+        file_name: Name of the port file (e.g. .bikerack-port)
         project_root: Project root directory (auto-detected if not provided)
 
     Returns:
@@ -140,6 +140,7 @@ class CyclistSettings:
     permission_mode: str = "manual"  # plan, manual, accept
     relay_mode: bool = False
     bell_mode: bool = False
+    git_monitor: bool = False
     theme: str | None = None
 
 
@@ -206,6 +207,10 @@ def load_settings(project_root: Path | None = None) -> CyclistSettings:
     if "bell_mode" in workflow and isinstance(workflow["bell_mode"], bool):
         settings.bell_mode = workflow["bell_mode"]
 
+    # Handle git_monitor
+    if "git_monitor" in workflow and isinstance(workflow["git_monitor"], bool):
+        settings.git_monitor = workflow["git_monitor"]
+
     return settings