relay-flow 0.2.3-alpha → 0.2.4-alpha

package/internal/harness/pi/prompt_test.go

@@ -0,0 +1,121 @@
+package pi
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/harness"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
+)
+
+func TestPiRenderPromptSubstitutesInitialAndFeedbackData(t *testing.T) {
+	h := newPiHarness(t)
+	data := harness.PromptData{
+		TaskSystem:      "jira",
+		Ticket:          "PAY-101",
+		Workflow:        "basicFlow",
+		Repo:            "payments",
+		Node:            "implement",
+		NodeType:        workflow.NodeAgent,
+		Agent:           "default",
+		NodeDescription: "Implement the requested change.",
+		NextSteps:       "review (when: ready)",
+		Mailbox:         "PAY-234",
+	}
+	nudge := "nudge {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nextSteps}}"
+
+	initial, err := h.RenderPrompt(harness.PromptInitial, data, nudge)
+	if err != nil {
+		t.Fatalf("RenderPrompt(initial): %v", err)
+	}
+	wantInitial := "Task system: jira\nUse the jira tools to read the parent ticket PAY-101.\n\nYour mailbox is PAY-234. Read its description and comments for node instructions and feedback.\n\nnudge jira|PAY-101|basicFlow|payments|implement|review (when: ready)"
+	if initial != wantInitial {
+		t.Fatalf("initial prompt = %q, want %q", initial, wantInitial)
+	}
+
+	feedback, err := h.RenderPrompt(harness.PromptFeedback, data, nudge)
+	if err != nil {
+		t.Fatalf("RenderPrompt(feedback): %v", err)
+	}
+	wantFeedback := "New feedback was added to the comments section of your mailbox subtask PAY-234. Read it.\n\nnudge jira|PAY-101|basicFlow|payments|implement|review (when: ready)"
+	if feedback != wantFeedback {
+		t.Fatalf("feedback prompt = %q, want %q", feedback, wantFeedback)
+	}
+}
+
+func TestPiRenderPromptHonorsNodeNudgeTimingInput(t *testing.T) {
+	h, err := harness.New("pi", config.RawValues{
+		"initial":  "initial {{node}}",
+		"feedback": "feedback {{node}}",
+	})
+	if err != nil {
+		t.Fatalf("harness.New(pi): %v", err)
+	}
+	data := harness.PromptData{Node: "implement", Agent: "default"}
+
+	for _, tt := range []struct {
+		name  string
+		kind  harness.PromptKind
+		want  string
+		nudge string
+	}{
+		{name: "initial without nudge", kind: harness.PromptInitial, want: "initial implement"},
+		{name: "initial with nudge", kind: harness.PromptInitial, want: "initial implement\n\nnudge implement", nudge: "nudge {{node}}"},
+		{name: "feedback without nudge", kind: harness.PromptFeedback, want: "feedback implement"},
+		{name: "feedback with nudge", kind: harness.PromptFeedback, want: "feedback implement\n\nnudge implement", nudge: "nudge {{node}}"},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := h.RenderPrompt(tt.kind, data, tt.nudge)
+			if err != nil {
+				t.Fatalf("RenderPrompt: %v", err)
+			}
+			if got != tt.want {
+				t.Fatalf("prompt = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestPiPromptRetainsDefaultAgentLabel(t *testing.T) {
+	h, err := harness.New("pi", config.RawValues{
+		"initial":  "agent={{agent}} node={{node}}",
+		"feedback": "feedback {{agent}}",
+	})
+	if err != nil {
+		t.Fatalf("harness.New(pi): %v", err)
+	}
+	got, err := h.RenderPrompt(harness.PromptInitial, harness.PromptData{
+		Agent: "default",
+		Node:  "implement",
+	}, "")
+	if err != nil {
+		t.Fatalf("RenderPrompt: %v", err)
+	}
+	if got != "agent=default node=implement" {
+		t.Fatalf("prompt = %q, want default agent label", got)
+	}
+}
+
+func TestPiPromptsDoNotIncludeOpenCodeQuestionInstructions(t *testing.T) {
+	h := newPiHarness(t)
+	data := harness.PromptData{
+		TaskSystem: "jira",
+		Ticket:     "PAY-101",
+		Node:       "review",
+		NodeType:   workflow.NodeHITL,
+		Agent:      "default",
+		Mailbox:    "PAY-235",
+	}
+	for _, kind := range []harness.PromptKind{harness.PromptInitial, harness.PromptFeedback} {
+		got, err := h.RenderPrompt(kind, data, "")
+		if err != nil {
+			t.Fatalf("RenderPrompt(%q): %v", kind, err)
+		}
+		for _, forbidden := range []string{"OpenCode", "Question tool", "Approve", "Reject"} {
+			if strings.Contains(got, forbidden) {
+				t.Fatalf("%q prompt contains OpenCode HITL instruction %q: %q", kind, forbidden, got)
+			}
+		}
+	}
+}

package/internal/harness/pi/testdata/pi-0.84.1/capture.json

@@ -0,0 +1,126 @@
+{
+  "capturedAt": "2026-08-31T18:34Z",
+  "version": "0.84.1",
+  "command": "/home/linuxbrew/.linuxbrew/Cellar/pi-coding-agent/0.84.1/bin/pi",
+  "cwd": "/tmp/pi-live-contract/project",
+  "note": "Executed live against installed Pi 0.84.1 with a real provider (github-copilot). Interactive runs used script(1) to supply a PTY. The smoke runs added --session-dir, --model, --thinking, -nt and -e for isolation/observability; the production launch shape itself is argv[0..] below and was validated by the rejection cases in errors.",
+  "argv": {
+    "production": {
+      "fresh": [
+        "pi",
+        "--name",
+        "PAY-101:implement",
+        "<rendered prompt as one positional argument>"
+      ],
+      "resume": [
+        "pi",
+        "--name",
+        "PAY-101:implement",
+        "--session-id",
+        "<persisted session id>",
+        "<rendered prompt as one positional argument>"
+      ]
+    },
+    "smokeObserved": [
+      "/home/linuxbrew/.linuxbrew/Cellar/node/26.7.0/bin/node",
+      "/home/linuxbrew/.linuxbrew/Cellar/pi-coding-agent/0.84.1/libexec/bin/pi",
+      "--name",
+      "PAY-101:implement",
+      "--session-dir",
+      "/tmp/pi-live-contract/sessions",
+      "--model",
+      "github-copilot/claude-haiku-4.5",
+      "--thinking",
+      "off",
+      "-nt",
+      "-e",
+      "<extension path>",
+      "<prompt>"
+    ]
+  },
+  "interactive": {
+    "stdinIsTTY": true,
+    "stdoutIsTTY": true,
+    "mode": "tui",
+    "hasUI": true,
+    "processAliveAfterSettled": true,
+    "observedAliveSecondsAfterSettle": 65,
+    "terminalTitle": "\u03c0 - PAY-101:review - project",
+    "footer": "/tmp/pi-live-contract/project \u2022 PAY-101:review"
+  },
+  "nonInteractive": {
+    "stdinIsTTY": false,
+    "stdoutIsTTY": false,
+    "mode": "print",
+    "hasUI": false,
+    "exitCode": 0,
+    "processExitsAfterResponse": true
+  },
+  "environment": {
+    "childCwd": "/tmp/pi-live-contract/project",
+    "relayFlowVariablesVisibleToExtension": [
+      "RELAY_FLOW_HOME",
+      "RELAY_FLOW_RUN_ID",
+      "RELAY_FLOW_WORKFLOW",
+      "RELAY_FLOW_REPO",
+      "RELAY_FLOW_TICKET",
+      "RELAY_FLOW_NODE",
+      "RELAY_FLOW_NODE_TYPE",
+      "RELAY_FLOW_NUDGE_PROMPT",
+      "RELAY_FLOW_NEXT_STEPS_JSON"
+    ]
+  },
+  "session": {
+    "fresh": {
+      "id": "01a0591c-3747-7075-9bb7-cc89a0f65dcd",
+      "file": "/tmp/pi-live-contract/sessions/2026-08-31T18-36-56-519Z_01a0591c-3747-7075-9bb7-cc89a0f65dcd.jsonl",
+      "branchLengthAtSessionStart": 3
+    },
+    "resumed": {
+      "requestedSessionId": "01a0591b-51a6-7cf0-8a6d-e9b31594cca4",
+      "observedSessionId": "01a0591b-51a6-7cf0-8a6d-e9b31594cca4",
+      "file": "/tmp/pi-live-contract/sessions/2026-08-31T18-35-57-734Z_01a0591b-51a6-7cf0-8a6d-e9b31594cca4.jsonl",
+      "branchLengthAtSessionStart": 6,
+      "priorEntryIdsPreserved": true,
+      "modelRecalledPriorTurn": "I output STATUS: success."
+    },
+    "nameSource": "--name; pi.getSessionName() returns it at session_start, so the extension's rename is a no-op",
+    "entryShape": "SessionEntry { type, id, parentId, timestamp, message }; branch also carries non-message entries session_info, model_change, thinking_level_change; assistant message has role/content[{type:text}]/stopReason=stop"
+  },
+  "extension": {
+    "events": [
+      "session_start",
+      "agent_settled"
+    ],
+    "sessionStartEventShape": [
+      "type",
+      "reason"
+    ],
+    "agentSettledEventShape": [
+      "type"
+    ],
+    "sessionStartContext": {
+      "mode": "tui",
+      "hasUI": true,
+      "cwd": "/tmp/pi-live-contract/project",
+      "uiSelectType": "function"
+    },
+    "actionsExercisedLive": [
+      "pi.getSessionName",
+      "pi.sendUserMessage",
+      "ctx.sessionManager.getSessionId",
+      "ctx.sessionManager.getSessionFile",
+      "ctx.sessionManager.getBranch",
+      "ctx.ui.select"
+    ],
+    "ui": "ctx.ui.select(title, options) -> Promise<string | undefined>; live selector rendered 'Approve relay-flow report for PAY-101:review' with Approve/Reject",
+    "hasUIIsTheRealGuard": "ctx.ui.select remains typeof 'function' in print mode while ctx.hasUI is false"
+  },
+  "errors": {
+    "bareDoubleDash": "Error: Unknown option: --",
+    "agentFlag": "Error: Unknown option: --agent",
+    "interactiveFlag": "Error: Unknown option: --interactive",
+    "reportFlag": "Error: Unknown option: --report",
+    "agentList": "No named-agent listing command; pi --list-models lists models only"
+  }
+}

package/internal/harness/pi/testdata/pi-0.84.1/noninteractive-output.txt

@@ -0,0 +1,11 @@
+Live non-TTY run of installed Pi 0.84.1 (stdin and stdout redirected, real provider):
+
+  $ pi --name "PAY-101:implement" --session-dir <dir> --model github-copilot/claude-haiku-4.5 \
+       --thinking off -nt -e <capture extension> "Reply with exactly: PRINT MODE OK" < /dev/null > out.txt
+  exit=0
+  stdout: PRINT MODE OK
+
+Extension context observed in the same run: mode=print, hasUI=false, stdinIsTTY=false,
+stdoutIsTTY=false, and the process exited after the single response. This is why the
+relay-flow launch path requires the runner's PTY: without both TTY streams Pi selects
+print mode and cannot host an interactive HITL session.

package/internal/harness/pi/testdata/pi-0.84.1/tui-output-sanitized.txt

@@ -0,0 +1,17 @@
+Sanitized excerpts from the live Pi 0.84.1 TUI run (PTY supplied by script(1)); ANSI
+sequences stripped, repeated spinner frames removed.
+
+  π - PAY-101:review - project                     <- terminal title from the session name
+  /tmp/pi-live-contract/project • PAY-101:review   <- footer: cwd • session name (--name)
+  ↑641 ↓107 $0.001 (sub) 0.4%/200k (auto)   claude-haiku-4.5 • thinking off
+
+  STATUS: success
+  ...
+  VERIFICATION: Ran the live Pi smoke test
+
+  Approve relay-flow report for PAY-101:review     <- ctx.ui.select title from plugin/pi.ts
+   Approve
+   Reject
+
+The process stayed alive after the response settled and after the selector was dismissed
+with Escape; it was terminated by the smoke test, not by Pi.

package/internal/harness/pi/validation_test.go

@@ -0,0 +1,168 @@
+package pi
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestPiValidateAgentAcceptsDefaultWithPiOnPATH(t *testing.T) {
+	fakeDir := strictPiAvailabilityCLI(t)
+	t.Setenv("PATH", fakeDir)
+
+	h := newPiHarness(t)
+	if err := h.ValidateAgent(context.Background(), "/srv/payments", "default"); err != nil {
+		t.Fatalf("default agent rejected when pi is available: %v", err)
+	}
+}
+
+func TestPiValidateAgentRejectsUnavailablePi(t *testing.T) {
+	directory := t.TempDir()
+	// Keep PATH controlled and empty of both the fake and any host-installed Pi.
+	t.Setenv("PATH", directory)
+
+	h := newPiHarness(t)
+	err := h.ValidateAgent(context.Background(), "/srv/payments", "default")
+	if err == nil {
+		t.Fatal("default agent accepted when pi is unavailable")
+	}
+	if !strings.Contains(err.Error(), "pi") {
+		t.Fatalf("error = %q, want Pi availability context", err)
+	}
+}
+
+func TestPiValidateAgentAcceptsExistingRoleAndPiOnPath(t *testing.T) {
+	fakeDir := strictPiAvailabilityCLI(t)
+	t.Setenv("PATH", fakeDir)
+	repoPath := t.TempDir()
+	rolePath := writePiRole(t, repoPath, "coder", "You are the coder.\n")
+
+	h := newPiHarness(t)
+	if err := h.ValidateAgent(context.Background(), repoPath, "coder"); err != nil {
+		t.Fatalf("existing role %q rejected: %v", rolePath, err)
+	}
+	if calls := readAvailabilityCalls(t, fakeDir); len(calls) != 0 {
+		t.Fatalf("role validation unexpectedly executed Pi: %v", calls)
+	}
+}
+
+func TestPiValidateAgentRejectsMissingRoleBeforePiLookup(t *testing.T) {
+	fakeDir := strictPiAvailabilityCLI(t)
+	t.Setenv("PATH", fakeDir)
+
+	h := newPiHarness(t)
+	err := h.ValidateAgent(context.Background(), t.TempDir(), "reviewer")
+	if err == nil || !strings.Contains(err.Error(), ".pi/roles/reviewer.md") {
+		t.Fatalf("missing role error = %v, want role path", err)
+	}
+	if calls := readAvailabilityCalls(t, fakeDir); len(calls) != 0 {
+		t.Fatalf("missing role invoked Pi lookup: %v", calls)
+	}
+}
+
+func TestPiValidateAgentRejectsUnsafeRolePath(t *testing.T) {
+	fakeDir := strictPiAvailabilityCLI(t)
+	t.Setenv("PATH", fakeDir)
+
+	h := newPiHarness(t)
+	for _, role := range []string{"../coder", "subdir/coder", `subdir\\coder`, " ", "."} {
+		if err := h.ValidateAgent(context.Background(), t.TempDir(), role); err == nil {
+			t.Errorf("unsafe role %q accepted", role)
+		}
+	}
+	if calls := readAvailabilityCalls(t, fakeDir); len(calls) != 0 {
+		t.Fatalf("unsafe roles invoked Pi lookup: %v", calls)
+	}
+}
+
+func TestPiValidateAgentRejectsEmptyAndNonRegularRoleFiles(t *testing.T) {
+	fakeDir := strictPiAvailabilityCLI(t)
+	t.Setenv("PATH", fakeDir)
+
+	emptyRepo := t.TempDir()
+	emptyPath := filepath.Join(emptyRepo, ".pi", "roles", "coder.md")
+	if err := os.MkdirAll(filepath.Dir(emptyPath), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(emptyPath, nil, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	directoryRepo := t.TempDir()
+	directoryPath := filepath.Join(directoryRepo, ".pi", "roles", "reviewer.md")
+	if err := os.MkdirAll(directoryPath, 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	h := newPiHarness(t)
+	if err := h.ValidateAgent(context.Background(), emptyRepo, "coder"); err == nil || !strings.Contains(err.Error(), "empty") {
+		t.Fatalf("empty role error = %v, want empty-role error", err)
+	}
+	if err := h.ValidateAgent(context.Background(), directoryRepo, "reviewer"); err == nil || !strings.Contains(err.Error(), "regular file") {
+		t.Fatalf("directory role error = %v, want non-regular-role error", err)
+	}
+	if calls := readAvailabilityCalls(t, fakeDir); len(calls) != 0 {
+		t.Fatalf("invalid role files invoked Pi lookup: %v", calls)
+	}
+}
+
+func TestPiValidateAgentRejectsUnsupportedLabelsWithoutAgentDiscovery(t *testing.T) {
+	fakeDir := strictPiAvailabilityCLI(t)
+	t.Setenv("PATH", fakeDir)
+
+	h := newPiHarness(t)
+	for _, label := range []string{"build", "plan", "gpt-4o", ""} {
+		if err := h.ValidateAgent(context.Background(), "/srv/payments", label); err == nil {
+			t.Errorf("unsupported agent label %q accepted", label)
+		}
+	}
+	if calls := readAvailabilityCalls(t, fakeDir); len(calls) != 0 {
+		t.Fatalf("unsupported labels invoked pi instead of rejecting directly: %v", calls)
+	}
+}
+
+func strictPiAvailabilityCLI(t *testing.T) string {
+	t.Helper()
+	directory := t.TempDir()
+	executable := filepath.Join(directory, "pi")
+	calls := filepath.Join(directory, "calls")
+	script := `#!/bin/sh
+set -eu
+printf '%s\000' "$*" >> "${PI_FAKE_CALLS:?}"
+case "$#:$*" in
+  1:--version) printf '0.84.1\n' ;;
+  *) exit 2 ;;
+esac
+`
+	if err := os.WriteFile(executable, []byte(script), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PI_FAKE_CALLS", calls)
+	return directory
+}
+
+func readAvailabilityCalls(t *testing.T, directory string) []string {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(directory, "calls"))
+	if os.IsNotExist(err) {
+		return nil
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	return strings.Split(strings.TrimSuffix(string(data), "\x00"), "\x00")
+}
+
+func writePiRole(t *testing.T, repoPath, name, content string) string {
+	t.Helper()
+	path := filepath.Join(repoPath, ".pi", "roles", name+".md")
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}

package/internal/runner/herdr/baseref.go

@@ -0,0 +1,60 @@
+package herdr
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+// originBaseRef resolves the branch new ticket worktrees are created from.
+// The base is always the repository's origin branch; the ladder is
+// origin/HEAD, then origin/main, then origin/master. A repository without an
+// origin remote falls back to its local main or master.
+//
+// The base only applies when the ticket branch does not exist yet: Herdr
+// checks out an existing branch as-is, so prior agent commits are preserved.
+func originBaseRef(repoPath string) (string, error) {
+	if ref, ok := gitValue(repoPath, "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"); ok && ref != "" {
+		return ref, nil
+	}
+	for _, ref := range []string{"origin/main", "origin/master"} {
+		if gitHasRef(repoPath, "refs/remotes/"+ref) {
+			return ref, nil
+		}
+	}
+	if !gitHasOrigin(repoPath) {
+		for _, ref := range []string{"main", "master"} {
+			if gitHasRef(repoPath, "refs/heads/"+ref) {
+				return ref, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("herdr: repository %q has no origin/HEAD, origin/main, origin/master, or local main/master to branch from; set it with: git -C %s remote set-head origin -a", repoPath, repoPath)
+}
+
+func gitValue(repoPath string, args ...string) (string, bool) {
+	cmd := exec.Command("git", append([]string{"-C", repoPath}, args...)...)
+	out, err := cmd.Output()
+	if err != nil {
+		return "", false
+	}
+	return strings.TrimSpace(string(out)), true
+}
+
+func gitHasRef(repoPath, ref string) bool {
+	_, ok := gitValue(repoPath, "rev-parse", "--verify", "--quiet", ref)
+	return ok
+}
+
+func gitHasOrigin(repoPath string) bool {
+	out, ok := gitValue(repoPath, "remote")
+	if !ok {
+		return false
+	}
+	for _, remote := range strings.Fields(out) {
+		if remote == "origin" {
+			return true
+		}
+	}
+	return false
+}