@pennyfarthing/core 11.1.1 → 11.2.1

package/pennyfarthing_scripts/git_group/cli.py

@@ -5,15 +5,16 @@ Usage:
     pf git [COMMAND] [ARGS]...
 
 Commands:
-    status    Check git status of all project repos
-    cleanup   Organize changes into proper commits/branches
-    branches  Create feature branches from a story
-    release   Interactive release with verification gates
+    status       Check git status of all project repos
+    cleanup      Organize changes into proper commits/branches
+    branches     Create feature branches from a story
+    worktree     Manage git worktrees for parallel work
+    install-hooks Install git hooks with .d/ dispatcher pattern
 """
 
-import click
+import asyncio
 
-from pennyfarthing_scripts.common.config import get_project_root
+import click
 
 
 @click.group()
@@ -22,10 +23,11 @@ def git():
 
     \b
     Commands:
-      status    - Check git status of all repos
-      cleanup   - Organize changes into commits/branches
-      branches  - Create feature branches from a story
-      release   - Interactive release with verification gates
+      status        - Check git status of all repos
+      cleanup       - Organize changes into commits/branches
+      branches      - Create feature branches from a story
+      worktree      - Manage git worktrees for parallel work
+      install-hooks - Install git hooks with .d/ dispatcher
     """
     pass
 
@@ -37,21 +39,38 @@ def status(brief: bool):
 
     Shows branch, uncommitted changes, and ahead/behind status for each repo.
     """
-    import subprocess
+    from pennyfarthing_scripts.git.repos import get_repo_paths, load_repos_config
+    from pennyfarthing_scripts.git.status_all import (
+        format_status_brief,
+        format_status_full,
+        format_summary,
+        get_all_repo_status,
+    )
 
-    root = get_project_root()
-    script = root / ".pennyfarthing" / "scripts" / "git" / "git-status-all.sh"
+    repo_paths = get_repo_paths()
+    config = load_repos_config()
 
-    if not script.is_file():
-        click.echo("Error: git-status-all.sh not found", err=True)
-        raise SystemExit(1)
+    # Build repo list with per-repo upstream refs
+    repos_with_upstream: list[tuple[str, object, str]] = []
+    for name, path in repo_paths:
+        upstream = config[name].upstream_ref if name in config else "origin/main"
+        repos_with_upstream.append((name, path, upstream))
+
+    statuses = asyncio.run(get_all_repo_status(repos_with_upstream))
 
-    cmd = [str(script)]
     if brief:
-        cmd.append("--brief")
+        click.echo(format_status_brief(statuses))
+    else:
+        click.echo("━" * 40)
+        click.echo("  Git Status - All Repos")
+        click.echo("━" * 40)
+        click.echo()
+        click.echo(format_status_full(statuses))
+        click.echo("━" * 40)
+        click.echo(format_summary(statuses))
 
-    result = subprocess.run(cmd, cwd=str(root))
-    raise SystemExit(result.returncode)
+    has_issues = any(not s.is_clean or s.has_unpushed for s in statuses)
+    raise SystemExit(1 if has_issues else 0)
 
 
 @git.command()
@@ -67,34 +86,118 @@ def cleanup():
 
 
 @git.command()
-@click.argument("story_id")
-def branches(story_id: str):
-    """Create feature branches in both repos from a story.
+@click.argument("branch_name")
+@click.option(
+    "--repos",
+    type=click.Choice(["all", "api", "ui"]),
+    default="all",
+    help="Which repos to target",
+)
+def branches(branch_name: str, repos: str):
+    """Create feature branches across all configured repos.
 
     \b
     Arguments:
-      STORY_ID  - The story ID to create branches for (e.g., 86-3)
+      BRANCH_NAME  - The branch name to create (e.g., feat/86-3-file-upload)
     """
-    import subprocess
+    from pennyfarthing_scripts.git.create_branches import (
+        create_feature_branches,
+        detect_worktree,
+        filter_repos,
+        format_results,
+    )
+    from pennyfarthing_scripts.git.repos import get_repo_paths
+
+    is_worktree, worktree_name, _ = detect_worktree()
+    if is_worktree:
+        click.echo(f"📂 Detected worktree: {worktree_name}")
+    else:
+        click.echo("📂 Using main checkout")
+
+    all_repos = get_repo_paths()
+    filtered = filter_repos(all_repos, repos)
+
+    if not filtered:
+        click.echo(f"No repos match filter: {repos}", err=True)
+        raise SystemExit(1)
 
-    root = get_project_root()
-    script = root / ".pennyfarthing" / "scripts" / "git" / "create-branches.sh"
+    results = asyncio.run(create_feature_branches(filtered, branch_name))
+    click.echo(format_results(results, branch_name))
 
-    if not script.is_file():
-        click.echo("Error: create-branches.sh not found", err=True)
-        raise SystemExit(1)
+    from pennyfarthing_scripts.git.create_branches import BranchAction
 
-    result = subprocess.run([str(script), story_id], cwd=str(root))
-    raise SystemExit(result.returncode)
+    has_errors = any(r.action == BranchAction.ERROR for r in results)
+    raise SystemExit(1 if has_errors else 0)
 
 
-@git.command()
-def release():
-    """Interactive release with verification gates.
+# Worktree subgroup
+@git.group()
+def worktree():
+    """Manage git worktrees for parallel development.
+
+    \b
+    Commands:
+      create  - Create worktree(s) for parallel work
+      remove  - Remove worktree and clean up
+      list    - List all active worktrees
+      status  - Show detailed worktree status
+    """
+    pass
 
-    Starts the release stepped workflow via BikeLane.
-    Equivalent to: /pf-workflow start release
+
+@worktree.command("create")
+@click.argument("name")
+@click.argument("branch")
+@click.option(
+    "--repos",
+    default="all",
+    help="Repos filter: all, api, ui, or comma-separated names",
+)
+def worktree_create(name: str, branch: str, repos: str):
+    """Create worktree(s) for parallel work.
+
+    \b
+    Arguments:
+      NAME    - Worktree name (e.g., wt-5-3a)
+      BRANCH  - Branch name (e.g., feat/5-3a-file-upload)
     """
-    click.echo("Starting release workflow...")
-    click.echo("Run: /pf-workflow start release")
-    click.echo("Or:  pf workflow start release")
+    from pennyfarthing_scripts.git.worktree import create_worktree
+
+    raise SystemExit(create_worktree(name, branch, repos))
+
+
+@worktree.command("remove")
+@click.argument("name")
+def worktree_remove(name: str):
+    """Remove worktree and clean up."""
+    from pennyfarthing_scripts.git.worktree import remove_worktree
+
+    raise SystemExit(remove_worktree(name))
+
+
+@worktree.command("list")
+def worktree_list():
+    """List all active worktrees."""
+    from pennyfarthing_scripts.git.worktree import list_worktrees
+
+    raise SystemExit(list_worktrees())
+
+
+@worktree.command("status")
+def worktree_status():
+    """Show detailed worktree status."""
+    from pennyfarthing_scripts.git.worktree import show_worktree_status
+
+    raise SystemExit(show_worktree_status())
+
+
+@git.command("install-hooks")
+def install_hooks():
+    """Install git hooks with .d/ dispatcher pattern.
+
+    Creates .d/ directories, symlinks pennyfarthing hooks, and
+    migrates existing user hooks.
+    """
+    from pennyfarthing_scripts.git.hooks_installer import install_git_hooks
+
+    raise SystemExit(install_git_hooks())

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

@@ -53,11 +53,36 @@ def complete_phase(
         }
 
     content = session_path.read_text()
+
+    # Guard: require assessment section before allowing gated phase transitions.
+    # Skip/manual transitions (e.g. setup→implement) don't need assessments.
+    if gate_type not in ("skip", "manual", "-", None, "") and not re.search(
+        r"^##\s+.*Assessment", content, re.MULTILINE
+    ):
+        return {
+            "status": "error",
+            "session_file": str(session_path),
+            "error": "No assessment found in session file. Write your assessment before completing the phase.",
+        }
+
     now = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
 
     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)
 
@@ -133,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

@@ -1,14 +1,14 @@
 """Resolve gate for current workflow phase.
 
-Reads workflow YAML, finds current phase gate, checks for assessment
-section in session file, and returns a structured RESOLVE_RESULT.
+Reads workflow YAML, finds current phase gate, and returns gate info.
+Assessment checks are enforced in complete_phase (not here) to avoid
+race conditions where agents call resolve-gate before writing assessments.
 
 Story: 105-1 (Script-First Handoff)
 """
 
 from __future__ import annotations
 
-import re
 from pathlib import Path
 
 import yaml
@@ -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"]
@@ -95,22 +107,13 @@ def resolve_gate(
             assessment_found=True,
         )
 
-    session_path = project_root / ".session" / f"{story_id}-session.md"
-    assessment_found = False
-    if session_path.exists():
-        content = session_path.read_text()
-        assessment_found = bool(
-            re.search(r"^##\s+.*Assessment", content, re.MULTILINE)
-        )
-
-    status = "ready" if assessment_found else "blocked"
     return _result(
-        status=status,
+        status="ready",
         gate_type=gate_type,
         gate_file=gate_file,
         next_agent=next_agent,
         next_phase=next_phase,
-        assessment_found=assessment_found,
+        assessment_found=True,
     )