@pennyfarthing/core 11.2.0 → 11.2.2

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/handoff/cli.py

@@ -4,8 +4,9 @@ Usage:
     pf handoff resolve-gate STORY_ID WORKFLOW PHASE
     pf handoff complete-phase STORY_ID WORKFLOW FROM_PHASE TO_PHASE GATE_TYPE
     pf handoff marker NEXT_AGENT [--error MESSAGE]
+    pf handoff phase-check AGENT
 
-Stories: 105-1, 105-4 (Script-First Handoff)
+Stories: 105-1, 105-4 (Script-First Handoff), 110-8 (CLI Relay Handoff Fix)
 """
 
 from __future__ import annotations
@@ -22,6 +23,7 @@ def handoff():
       resolve-gate    - Resolve gate for current phase
       complete-phase  - Complete phase transition atomically
       marker          - Generate AGENT_COMMAND handoff marker
+      phase-check     - Check if agent owns current phase
     """
     pass
 
@@ -118,3 +120,33 @@ def marker_cmd(next_agent: str | None, error_msg: str | None):
         )
 
     click.echo(generate_marker(next_agent, error=error_msg))
+
+
+@handoff.command("phase-check")
+@click.argument("agent")
+def phase_check_cmd(agent: str):
+    """Check if the requested agent owns the current workflow phase.
+
+    Returns a YAML block with action ("start" or "redirect"), the correct
+    agent, story ID, phase, and a human-readable message.
+
+    If the agent does not own the phase, generates a handoff marker for
+    the correct agent.
+
+    \b
+    Arguments:
+      AGENT  - Agent to check (e.g., dev, tea, reviewer, sm)
+    """
+    from pennyfarthing_scripts.handoff.phase_check import phase_check_start
+
+    result = phase_check_start(agent)
+
+    import yaml
+
+    click.echo(yaml.dump({"PHASE_CHECK": result}, default_flow_style=False).rstrip())
+
+    if result["action"] == "redirect":
+        click.echo("")
+        from pennyfarthing_scripts.handoff.marker import generate_marker
+
+        click.echo(generate_marker(result["agent"]))

package/pennyfarthing_scripts/handoff/complete_phase.py

@@ -70,6 +70,19 @@ def complete_phase(
     from_agent = _get_phase_agent(project_root, workflow, from_phase)
     to_agent = _get_phase_agent(project_root, workflow, to_phase)
 
+    # Update tandem line: remove existing, add if to_phase has tandem config
+    content = re.sub(r"\*\*Tandem:\*\*[^\n]*\n", "", content)
+    tandem = _get_phase_tandem(project_root, workflow, to_phase)
+    if tandem:
+        partner = tandem["partner"]
+        scope = tandem["scope"]
+        tandem_line = f"**Tandem:** {partner} ({scope})\n"
+        content = re.sub(
+            r"(\*\*Workflow:\*\*[^\n]*\n)",
+            rf"\1{tandem_line}",
+            content,
+        )
+
     # Update all **Phase:** lines to new phase
     content = re.sub(r"(\*\*Phase:\*\*) \S+", rf"\1 {to_phase}", content)
 
@@ -145,6 +158,21 @@ def _calc_duration(started_str: str, ended_str: str) -> str:
     return f"{hours}h {rem_minutes}m" if rem_minutes else f"{hours}h"
 
 
+def _get_phase_tandem(project_root: Path, workflow: str, phase: str) -> dict | None:
+    """Return tandem config for a phase, or None if no tandem block."""
+    for name in [f"{workflow}.yaml", f"{workflow}/workflow.yaml"]:
+        path = project_root / ".pennyfarthing" / "workflows" / name
+        if path.exists():
+            try:
+                data = yaml.safe_load(path.read_text())
+                for p in data["workflow"]["phases"]:
+                    if p["name"] == phase:
+                        return p.get("tandem")
+            except Exception:
+                pass
+    return None
+
+
 def _get_phase_agent(project_root: Path, workflow: str, phase: str) -> str:
     for name in [f"{workflow}.yaml", f"{workflow}/workflow.yaml"]:
         path = project_root / ".pennyfarthing" / "workflows" / name

package/pennyfarthing_scripts/handoff/marker.py

@@ -72,25 +72,25 @@ def generate_marker(
             fallback=f"Run `{cmd}` to continue",
         )
 
-    # Non-Cyclist relay: invoke the next agent directly
-    import subprocess
-    try:
-        result = subprocess.run(
-            ["pf", "agent", "start", next_agent],
-            capture_output=True,
-            text=True,
-            timeout=30,
+    # Non-Cyclist relay: return structured action for the agent to act on.
+    # The calling agent reads the `action` field and executes accordingly.
+    if ctx.use_tirepump:
+        return _block(
+            action="tirepump_handoff",
+            next_agent=next_agent,
+            fallback=f"Context is high ({pct}%). Run /clear then {cmd}",
+            context_percent=pct,
+            relay_mode=True,
         )
-        agent_output = result.stdout.strip()
-    except Exception as e:
-        agent_output = f"Failed to invoke agent: {e}"
 
     return _block(
-        fallback=f"Run `{cmd}` to continue{context_warning}",
-        relay_mode=True,
+        action="inline_handoff",
+        next_agent=next_agent,
+        activation_command=f"pf agent start {next_agent} --tier handoff --quiet",
+        fallback=f"Run `{cmd}` to continue",
         context_percent=pct,
-        invoke=cmd,
-    ) + f"\n\n{agent_output}"
+        relay_mode=True,
+    )
 
 
 def _block(**fields: object) -> str:

package/pennyfarthing_scripts/handoff/phase_check.py

@@ -0,0 +1,96 @@
+"""Phase check for agent activation.
+
+Determines whether the requested agent owns the current workflow phase.
+If not, returns a redirect to the correct agent. Replaces phase-check-start.sh.
+
+Story: 110-8 (CLI Relay Handoff Fix)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pennyfarthing_scripts.common.config import get_project_root
+from pennyfarthing_scripts.prime.workflow import (
+    check_redirect,
+    detect_workflow_state,
+    find_active_session,
+    parse_session_header,
+)
+
+
+def phase_check_start(
+    agent_name: str,
+    project_root: Path | None = None,
+) -> dict:
+    """Check if requested agent owns current phase.
+
+    Args:
+        agent_name: Agent to check (e.g., "dev", "tea", "reviewer").
+        project_root: Project root path (auto-detected if not provided).
+
+    Returns:
+        Dict with:
+          action: "start" (proceed) or "redirect" (wrong agent)
+          agent: The agent that should run
+          story_id: Current story ID (if session exists)
+          phase: Current phase (if session exists)
+          phase_owner: Agent that owns the phase
+          message: Human-readable explanation
+    """
+    root = project_root or get_project_root()
+
+    # Find active session
+    session_file = find_active_session(root)
+    if not session_file:
+        return {
+            "action": "start",
+            "agent": agent_name,
+            "story_id": None,
+            "phase": None,
+            "phase_owner": None,
+            "message": f"No active session — starting {agent_name}",
+        }
+
+    # Parse session header
+    header = parse_session_header(session_file)
+    story_id = header.get("story_id")
+    workflow = header.get("workflow", "tdd")
+    phase = header.get("phase")
+
+    if not phase:
+        return {
+            "action": "start",
+            "agent": agent_name,
+            "story_id": story_id,
+            "phase": None,
+            "phase_owner": None,
+            "message": f"No phase detected — starting {agent_name}",
+        }
+
+    # Use detect_workflow_state + check_redirect for consistent logic
+    workflow_status = detect_workflow_state(root)
+    redirect = check_redirect(workflow_status, agent_name)
+
+    if redirect:
+        target_agent, reason = redirect
+        return {
+            "action": "redirect",
+            "agent": target_agent,
+            "story_id": story_id,
+            "phase": phase,
+            "phase_owner": target_agent,
+            "message": (
+                f"Story {story_id} is in '{phase}' phase "
+                f"(workflow: {workflow}) — owned by {target_agent}"
+            ),
+        }
+
+    return {
+        "action": "start",
+        "agent": agent_name,
+        "story_id": story_id,
+        "phase": phase,
+        "phase_owner": agent_name,
+        "message": f"Agent {agent_name} owns phase '{phase}' — proceeding",
+    }

package/pennyfarthing_scripts/handoff/resolve_gate.py

@@ -67,7 +67,19 @@ def resolve_gate(
 
     gate = current_phase.get("gate")
 
-    if current_idx + 1 < len(phases):
+    # Support explicit next: directive for non-linear phase routing
+    explicit_next = current_phase.get("next")
+    if explicit_next:
+        nxt = next((p for p in phases if p["name"] == explicit_next), None)
+        if nxt:
+            next_phase = nxt["name"]
+            next_agent = nxt["agent"]
+        else:
+            return _result(
+                status="error",
+                error=f"Phase '{explicit_next}' referenced by next: not found in workflow '{workflow}'",
+            )
+    elif current_idx + 1 < len(phases):
         nxt = phases[current_idx + 1]
         next_phase = nxt["name"]
         next_agent = nxt["agent"]