@pennyfarthing/core 11.2.0 → 11.2.1

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"]