relay-flow 0.2.8-alpha → 0.2.10-alpha

package/internal/execution/temporal/interpreter.go

@@ -42,6 +42,7 @@ const (
 	activityComment                     = "Comment"
 	activityCompleteMailbox             = "CompleteMailbox"
 	activityProjectionUpdateNodeRuntime = "ProjectionUpdateNodeRuntimeVisit"
+	activityProjectionUpsertStep        = "ProjectionUpsertStep"
 	activityProjectionRecordReport      = "ProjectionRecordProcessedReport"
 	activityProjectionUpdateNode        = "ProjectionUpdateNode"
 	activityProjectionUpdateState       = "ProjectionUpdateState"
@@ -72,6 +73,7 @@ type NodeRuntimeBinding struct {
 type RunStateSnapshot struct {
 	Run             run.Run              `json:"run"`
 	RuntimeBindings []NodeRuntimeBinding `json:"runtimeBindings"`
+	Steps           []run.StepEntry      `json:"steps"`
 }
 
 type ReportStateQuery struct {
@@ -89,6 +91,7 @@ type workflowState struct {
 	run       run.Run
 	bindings  map[string]NodeRuntimeBinding
 	processed map[string]bool
+	steps     []run.StepEntry
 }
 
 func (s *workflowState) snapshot() RunStateSnapshot {
@@ -101,7 +104,53 @@ func (s *workflowState) snapshot() RunStateSnapshot {
 	for _, node := range keys {
 		bindings = append(bindings, s.bindings[node])
 	}
-	return RunStateSnapshot{Run: s.run, RuntimeBindings: bindings}
+	steps := append([]run.StepEntry(nil), s.steps...)
+	return RunStateSnapshot{Run: s.run, RuntimeBindings: bindings, Steps: steps}
+}
+
+func (s *workflowState) upsertStep(step run.StepEntry) {
+	for i := range s.steps {
+		if s.steps[i].Sequence == step.Sequence {
+			previous := s.steps[i]
+			if step.StartedAt == nil {
+				step.StartedAt = previous.StartedAt
+			}
+			if step.FinishedAt == nil {
+				step.FinishedAt = previous.FinishedAt
+			}
+			if step.Duration == 0 {
+				step.Duration = previous.Duration
+			}
+			if step.Message == "" {
+				step.Message = previous.Message
+			}
+			if step.Route == "" {
+				step.Route = previous.Route
+			}
+			if step.Runtime == "" {
+				step.Runtime = previous.Runtime
+			}
+			s.steps[i] = step
+			return
+		}
+	}
+	s.steps = append(s.steps, step)
+	sort.Slice(s.steps, func(i, j int) bool { return s.steps[i].Sequence < s.steps[j].Sequence })
+}
+
+func (s *workflowState) updateLatestStep(status run.StepStatus, message string) {
+	for i := len(s.steps) - 1; i >= 0; i-- {
+		if s.steps[i].Status != run.StepRunning && s.steps[i].Status != run.StepWaiting && s.steps[i].Status != run.StepBlocked {
+			continue
+		}
+		step := s.steps[i]
+		step.Status = status
+		if message != "" {
+			step.Message = message
+		}
+		s.upsertStep(step)
+		return
+	}
 }
 
 var temporalActivityOptions = temporalworkflow.ActivityOptions{
@@ -254,6 +303,23 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		return err
 	}
 
+	// The timeline is a derived display projection. Sequence is deterministic
+	// for Temporal replay and is never consulted for routing.
+	stepSequence := int64(0)
+	target, err := wf.StartTarget()
+	if err != nil {
+		return err
+	}
+	startStarted := temporalworkflow.Now(ctx).UTC()
+	startStep := run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: "start", NodeType: "lifecycle",
+		Status: run.StepRunning, StartedAt: &startStarted, Depth: 1}
+	if _, err := retryActivity(ctx, state, work, "start", func() (struct{}, error) {
+		return executeActivity[struct{}](ctx, activityProjectionUpsertStep, startStep)
+	}); err != nil {
+		return err
+	}
+	state.upsertStep(startStep)
+
 	startNode := wf.Nodes["start"]
 	if _, err := retryActivity(ctx, state, work, "start", func() (struct{}, error) {
 		return executeActivity[struct{}](ctx, activityApplyTaskConfig, work, "start", (*task.Mailbox)(nil), mergeTaskConfig(wf.TaskConfig, startNode.TaskConfig))
@@ -265,12 +331,19 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 	}); err != nil {
 		return err
 	}
-	target, err := wf.StartTarget()
-	if err != nil {
+	startFinished := temporalworkflow.Now(ctx).UTC()
+	startStep.Status, startStep.FinishedAt, startStep.Route = run.StepSucceeded, &startFinished, target
+	startStep.StartedAt = &startStarted
+	if _, err := retryActivity(ctx, state, work, "start", func() (struct{}, error) {
+		return executeActivity[struct{}](ctx, activityProjectionUpsertStep, startStep)
+	}); err != nil {
 		return err
 	}
+	state.upsertStep(startStep)
 
 	current := target
+	lastStepByNode := map[string]int64{}
+	lastDepthByNode := map[string]int{}
 	for current != "end" {
 		node := wf.Nodes[current]
 		var visitID identity.NodeVisitID
@@ -280,6 +353,26 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 			return err
 		}
 		visit := run.NodeVisitID(visitID)
+		stepSequence++
+		stepParent := int64(0)
+		stepDepth := 1
+		if previous, ok := lastStepByNode[current]; ok {
+			stepParent = previous
+			stepDepth = lastDepthByNode[current] + 1
+		}
+		stepStarted := temporalworkflow.Now(ctx).UTC()
+		step := run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: current,
+			NodeVisitID: visit, NodeType: string(node.Type), Status: run.StepRunning,
+			StartedAt: &stepStarted, ParentSequence: stepParent, Depth: stepDepth, Runtime: node.Agent}
+		if _, err := retryActivity(ctx, state, work, current, func() (struct{}, error) {
+			return executeActivity[struct{}](ctx, activityProjectionUpsertStep, step)
+		}); err != nil {
+			return err
+		}
+		state.upsertStep(step)
+		lastStepByNode[current] = stepSequence
+		lastDepthByNode[current] = stepDepth
+
 		runtime, err := retryActivity(ctx, state, work, current, func() (NodeRuntime, error) {
 			return executeActivity[NodeRuntime](ctx, activityLoadNodeRuntime, start.ID, current)
 		})
@@ -347,6 +440,7 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		}
 		state.run.State = run.StateWaiting
 		state.run.UpdatedAt = temporalworkflow.Now(ctx)
+		state.updateLatestStep(run.StepWaiting, "waiting")
 
 		reportCh := temporalworkflow.GetSignalChannel(ctx, reportSignalName)
 		reconcileCh := temporalworkflow.GetSignalChannel(ctx, reconcileSignalName)
@@ -417,6 +511,20 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		}); err != nil {
 			return err
 		}
+		stepStatus := run.StepSucceeded
+		stepMessage := accepted.Report.Summary.Completed
+		if accepted.Report.Status == domainworkflow.OutcomeFailure {
+			stepStatus = run.StepFailed
+			stepMessage = accepted.Report.Summary.IssuesDiscovered
+		}
+		stepFinished := temporalworkflow.Now(ctx).UTC()
+		step.Status, step.FinishedAt, step.Message, step.Route = stepStatus, &stepFinished, stepMessage, accepted.Report.NextStep
+		if _, err := retryActivity(ctx, state, work, current, func() (struct{}, error) {
+			return executeActivity[struct{}](ctx, activityProjectionUpsertStep, step)
+		}); err != nil {
+			return err
+		}
+		state.upsertStep(step)
 
 		if _, err := retryActivity(ctx, state, work, current, func() (struct{}, error) {
 			return executeActivity[struct{}](ctx, activityComment, start.Repo, run.CommentWork{
@@ -463,6 +571,17 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		current = next
 	}
 
+	stepSequence++
+	endStarted := temporalworkflow.Now(ctx).UTC()
+	endStep := run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: "end", NodeType: "lifecycle",
+		Status: run.StepRunning, StartedAt: &endStarted, Depth: 1}
+	if _, err := retryActivity(ctx, state, work, "end", func() (struct{}, error) {
+		return executeActivity[struct{}](ctx, activityProjectionUpsertStep, endStep)
+	}); err != nil {
+		return err
+	}
+	state.upsertStep(endStep)
+
 	endNode := wf.Nodes["end"]
 	if _, err := retryActivity(ctx, state, work, "end", func() (struct{}, error) {
 		return executeActivity[struct{}](ctx, activityApplyTaskConfig, work, "end", (*task.Mailbox)(nil), mergeTaskConfig(wf.TaskConfig, endNode.TaskConfig))
@@ -494,6 +613,13 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		}
 	}
 	now := temporalworkflow.Now(ctx).UTC()
+	endStep.Status, endStep.FinishedAt = run.StepSucceeded, &now
+	if _, err := retryActivity(ctx, state, work, "end", func() (struct{}, error) {
+		return executeActivity[struct{}](ctx, activityProjectionUpsertStep, endStep)
+	}); err != nil {
+		return err
+	}
+	state.upsertStep(endStep)
 	if _, err := retryActivity(ctx, state, work, "", func() (struct{}, error) {
 		return executeActivity[struct{}](ctx, activityProjectionUpdateState, start.ID, run.StateCompleted, "", &now)
 	}); err != nil {
@@ -566,6 +692,7 @@ func retryActivity[T any](ctx temporalworkflow.Context, state *workflowState, wo
 					return zero, stateErr
 				}
 				state.run.State = run.StateWaiting
+				state.updateLatestStep(run.StepWaiting, "waiting")
 			}
 			return result, nil
 		}
@@ -580,6 +707,7 @@ func retryActivity[T any](ctx temporalworkflow.Context, state *workflowState, wo
 			failure.Message = blockedMessage(work, node, failure.Message)
 			blocked = true
 			state.run.State = run.StateBlocked
+			state.updateLatestStep(run.StepBlocked, failure.Message)
 			if _, stateErr := retryProjectionActivity(ctx, state, work, node, func() (struct{}, error) {
 				return executeActivity[struct{}](ctx, activityProjectionUpdateState, work.RunID, run.StateBlocked, failure.Message, (*time.Time)(nil))
 			}); stateErr != nil {

package/internal/execution/temporal/operations.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
+	"sort"
 	"time"
 
 	"github.com/rajpopat27/relay-flow/internal/execution/projection"
@@ -375,6 +377,160 @@ func (e *Engine) workflowStart(ctx context.Context, id, temporalRunID string) (r
 	return run.Start{}, fmt.Errorf("Temporal workflow %s has no WorkflowExecutionStarted snapshot", id)
 }
 
+func temporalStepRank(status run.StepStatus) int {
+	switch status {
+	case run.StepSucceeded, run.StepFailed, run.StepCanceled:
+		return 4
+	case run.StepBlocked:
+		return 3
+	case run.StepWaiting:
+		return 2
+	case run.StepRunning:
+		return 1
+	default:
+		return 0
+	}
+}
+
+func mergeTemporalStep(existing, incoming run.StepEntry) run.StepEntry {
+	if existing.RunID == "" {
+		return incoming
+	}
+	if temporalStepRank(existing.Status) >= 4 || temporalStepRank(incoming.Status) < temporalStepRank(existing.Status) {
+		return existing
+	}
+	if incoming.StartedAt == nil {
+		incoming.StartedAt = existing.StartedAt
+	}
+	if incoming.FinishedAt == nil {
+		incoming.FinishedAt = existing.FinishedAt
+	}
+	if incoming.Duration == 0 {
+		incoming.Duration = existing.Duration
+	}
+	incoming.DurationKnown = incoming.DurationKnown || existing.DurationKnown
+	if incoming.Message == "" {
+		incoming.Message = existing.Message
+	}
+	if incoming.Route == "" {
+		incoming.Route = existing.Route
+	}
+	if incoming.Runtime == "" {
+		incoming.Runtime = existing.Runtime
+	}
+	if incoming.Resource == "" {
+		incoming.Resource = existing.Resource
+	}
+	if incoming.ParentSequence == 0 {
+		incoming.ParentSequence = existing.ParentSequence
+	}
+	if incoming.Depth == 0 {
+		incoming.Depth = existing.Depth
+	}
+	return incoming
+}
+
+func applyTemporalProjectionState(steps map[int64]run.StepEntry, state run.State, message string, finished *time.Time) {
+	var selected int64
+	found := false
+	for sequence, step := range steps {
+		if step.Status != run.StepRunning && step.Status != run.StepWaiting && step.Status != run.StepBlocked {
+			continue
+		}
+		if !found || sequence > selected {
+			selected, found = sequence, true
+		}
+	}
+	if !found {
+		return
+	}
+	step := steps[selected]
+	switch state {
+	case run.StateWaiting:
+		step.Status = run.StepWaiting
+	case run.StateBlocked:
+		step.Status = run.StepBlocked
+	case run.StateCanceled, run.StateCanceling:
+		step.Status = run.StepCanceled
+	default:
+		return
+	}
+	if message != "" {
+		step.Message = message
+	}
+	if finished != nil && step.FinishedAt == nil {
+		finish := finished.UTC()
+		step.FinishedAt = &finish
+		if step.StartedAt != nil && !step.DurationKnown {
+			duration := finish.Sub(*step.StartedAt)
+			if duration < 0 {
+				duration = 0
+			}
+			step.Duration = duration
+			step.DurationKnown = true
+		}
+	}
+	steps[selected] = step
+}
+
+// stepsFromHistory reconstructs the display projection for a closed Temporal
+// execution when its workflow query handler is unavailable. It reads only
+// durable Temporal history; it does not call task-system, runner, or harness
+// boundaries and cannot affect execution.
+func (e *Engine) stepsFromHistory(ctx context.Context, id run.ID, temporalRunID string) ([]run.StepEntry, error) {
+	c, err := e.ready()
+	if err != nil {
+		return nil, err
+	}
+	iterator := c.GetWorkflowHistory(ctx, string(id), temporalRunID, false, enumspb.HISTORY_EVENT_FILTER_TYPE_ALL_EVENT)
+	bySequence := map[int64]run.StepEntry{}
+	for iterator.HasNext() {
+		event, err := iterator.Next()
+		if err != nil {
+			return nil, fmt.Errorf("read Temporal history for %s: %w", id, err)
+		}
+		attrs := event.GetActivityTaskScheduledEventAttributes()
+		if attrs == nil || attrs.GetActivityType() == nil || attrs.GetInput() == nil {
+			continue
+		}
+		name := attrs.GetActivityType().GetName()
+		payloads := attrs.GetInput().GetPayloads()
+		if len(payloads) == 0 {
+			continue
+		}
+		switch name {
+		case activityProjectionUpsertStep:
+			var step run.StepEntry
+			if err := converter.GetDefaultDataConverter().FromPayload(payloads[0], &step); err != nil {
+				continue
+			}
+			if step.RunID == "" {
+				step.RunID = id
+			}
+			bySequence[step.Sequence] = mergeTemporalStep(bySequence[step.Sequence], step)
+		case activityProjectionUpdateState:
+			var activityID run.ID
+			var state run.State
+			var message string
+			var finished *time.Time
+			if err := converter.GetDefaultDataConverter().FromPayloads(attrs.GetInput(), &activityID, &state, &message, &finished); err != nil || activityID != id {
+				continue
+			}
+			applyTemporalProjectionState(bySequence, state, message, finished)
+		}
+	}
+	sequences := make([]int64, 0, len(bySequence))
+	for sequence := range bySequence {
+		sequences = append(sequences, sequence)
+	}
+	sort.Slice(sequences, func(i, j int) bool { return sequences[i] < sequences[j] })
+	out := make([]run.StepEntry, 0, len(sequences))
+	for _, sequence := range sequences {
+		out = append(out, bySequence[sequence])
+	}
+	return out, nil
+}
+
 func stateForTemporalStatus(status enumspb.WorkflowExecutionStatus, closeTime *timestamppb.Timestamp) (run.State, *time.Time) {
 	var finished *time.Time
 	if closeTime != nil {
@@ -424,6 +580,12 @@ func (e *Engine) restoreProjection(ctx context.Context, info *workflowpb.Workflo
 				return err
 			}
 		}
+		for _, step := range state.Steps {
+			step.RunID = id
+			if err := e.runs.UpsertStep(ctx, step); err != nil {
+				slog.Warn("Temporal step projection restore write unavailable", "runID", string(id), "sequence", step.Sequence, "error", err)
+			}
+		}
 		if state.Run.State == run.StateCompleted || state.Run.State == run.StateCanceled {
 			finished := state.Run.FinishedAt
 			if finished == nil && info.CloseTime != nil {
@@ -451,5 +613,17 @@ func (e *Engine) restoreProjection(ctx context.Context, info *workflowpb.Workflo
 	if info.Status == enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING {
 		return fmt.Errorf("query Temporal run-state for active workflow %s: %w", id, queryErr)
 	}
+	// Closed executions cannot always serve workflow queries. Rebuild the
+	// display timeline from scheduled projection activities in retained
+	// Temporal history instead of dropping all historical visits.
+	if steps, historyErr := e.stepsFromHistory(ctx, id, info.Execution.RunId); historyErr != nil {
+		slog.Warn("Temporal step projection history unavailable", "runID", string(id), "error", historyErr)
+	} else {
+		for _, step := range steps {
+			if err := e.runs.UpsertStep(ctx, step); err != nil {
+				slog.Warn("Temporal step projection rebuild write unavailable", "runID", string(id), "sequence", step.Sequence, "error", err)
+			}
+		}
+	}
 	return e.runs.UpdateState(ctx, id, stateValue, "", finished)
 }

package/internal/execution/temporal/operations_test.go

@@ -15,6 +15,42 @@ import (
 	_ "modernc.org/sqlite"
 )
 
+func TestApplyTemporalProjectionStateRebuildsCanceledTimingIdempotently(t *testing.T) {
+	started := time.Now().UTC().Add(-time.Minute)
+	finished := started.Add(30 * time.Second)
+	later := finished.Add(time.Minute)
+	steps := map[int64]run.StepEntry{1: {RunID: "run", Sequence: 1, Node: "coding", Status: run.StepRunning, StartedAt: &started}}
+	applyTemporalProjectionState(steps, run.StateCanceled, "operator canceled", &finished)
+	first := steps[1]
+	if first.Status != run.StepCanceled || first.FinishedAt == nil || !first.FinishedAt.Equal(finished) || first.Duration <= 0 {
+		t.Fatalf("rebuilt canceled step = %#v", first)
+	}
+	applyTemporalProjectionState(steps, run.StateCanceled, "operator canceled", &later)
+	second := steps[1]
+	if !second.FinishedAt.Equal(finished) || second.Duration != first.Duration {
+		t.Fatalf("repeated canceled rebuild changed timing: first=%#v second=%#v", first, second)
+	}
+	terminalFinished := started.Add(10 * time.Second)
+	steps[2] = run.StepEntry{RunID: "run", Sequence: 2, Node: "already-done", Status: run.StepSucceeded, StartedAt: &started, FinishedAt: &terminalFinished, Duration: 10 * time.Second, DurationKnown: true}
+	applyTemporalProjectionState(steps, run.StateCanceled, "operator canceled", &later)
+	if steps[2].Status != run.StepSucceeded || !steps[2].FinishedAt.Equal(terminalFinished) {
+		t.Fatalf("already-terminal step changed: %#v", steps[2])
+	}
+}
+
+func TestMergeTemporalStepPreservesResourceLabel(t *testing.T) {
+	existing := run.StepEntry{RunID: "run", Sequence: 1, Node: "coding", Status: run.StepRunning, Resource: "harness"}
+	incoming := run.StepEntry{RunID: "run", Sequence: 1, Node: "coding", Status: run.StepSucceeded, Message: "done"}
+	merged := mergeTemporalStep(existing, incoming)
+	if merged.Resource != "harness" || merged.Status != run.StepSucceeded || merged.Message != "done" {
+		t.Fatalf("merged step = %#v", merged)
+	}
+	withNewResource := mergeTemporalStep(merged, run.StepEntry{RunID: "run", Sequence: 1, Node: "coding", Status: run.StepSucceeded, Resource: "runner"})
+	if withNewResource.Resource != "harness" {
+		t.Fatalf("terminal resource was overwritten: %#v", withNewResource)
+	}
+}
+
 func TestValidateTemporalExecutionIdentity(t *testing.T) {
 	valid := func(workflowID, workflowType, taskQueue string) *workflowpb.WorkflowExecutionInfo {
 		return &workflowpb.WorkflowExecutionInfo{

package/internal/harness/opencode/opencode_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
-const configuredPlugin = "relay-flow-plugin@0.2.8-alpha"
+const configuredPlugin = "relay-flow-plugin@0.2.10-alpha"
 
 func TestBuildCommandArgv(t *testing.T) {
 	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")
@@ -71,12 +71,12 @@ func TestRenderPromptTemplatesExposeAllValues(t *testing.T) {
 		Node: "review", NodeType: workflow.NodeHITL, Agent: "build", NodeDescription: "Review it.",
 		NextSteps: "end (when: approved)", Mailbox: "PAY-234",
 	}
-	nudge := "nudge {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nextSteps}}"
+	nudge := "nudge {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{mailbox}}|{{nextSteps}}"
 	initial, err := h.RenderPrompt(harness.PromptInitial, data, nudge)
 	if err != nil {
 		t.Fatal(err)
 	}
-	wantInitial := "initial linear|PAY-101|basicFlow|payments|review|hitl|build|Review it.|end (when: approved)|PAY-234\n\nReturn the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval.\n\nnudge linear|PAY-101|basicFlow|payments|review|end (when: approved)"
+	wantInitial := "initial linear|PAY-101|basicFlow|payments|review|hitl|build|Review it.|end (when: approved)|PAY-234\n\nReturn the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval.\n\nnudge linear|PAY-101|basicFlow|payments|review|PAY-234|end (when: approved)"
 	if initial != wantInitial {
 		t.Fatalf("initial prompt = %q, want %q", initial, wantInitial)
 	}
@@ -84,7 +84,7 @@ func TestRenderPromptTemplatesExposeAllValues(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if want := "feedback PAY-234\n\nReturn the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval.\n\nnudge linear|PAY-101|basicFlow|payments|review|end (when: approved)"; feedback != want {
+	if want := "feedback PAY-234\n\nReturn the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval.\n\nnudge linear|PAY-101|basicFlow|payments|review|PAY-234|end (when: approved)"; feedback != want {
 		t.Fatalf("feedback prompt = %q, want %q", feedback, want)
 	}
 }

package/internal/harness/opencode/repo_setup.go

@@ -10,7 +10,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/config"
 )
 
-const relayFlowPlugin = "relay-flow-plugin@0.2.8-alpha"
+const relayFlowPlugin = "relay-flow-plugin@0.2.10-alpha"
 
 type jsoncToken struct {
 	kind       byte

package/internal/harness/pi/prompt_test.go

@@ -23,13 +23,13 @@ func TestPiRenderPromptSubstitutesInitialAndFeedbackData(t *testing.T) {
 		NextSteps:       "review (when: ready)",
 		Mailbox:         "PAY-234",
 	}
-	nudge := "nudge {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nextSteps}}"
+	nudge := "nudge {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{mailbox}}|{{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\nKeep the summary brief, and make the feedback as detailed and actionable as possible for the next agent.\n\nnudge jira|PAY-101|basicFlow|payments|implement|review (when: ready)"
+	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\nKeep the summary brief, and make the feedback as detailed and actionable as possible for the next agent.\n\nnudge jira|PAY-101|basicFlow|payments|implement|PAY-234|review (when: ready)"
 	if initial != wantInitial {
 		t.Fatalf("initial prompt = %q, want %q", initial, wantInitial)
 	}
@@ -38,7 +38,7 @@ func TestPiRenderPromptSubstitutesInitialAndFeedbackData(t *testing.T) {
 	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)"
+	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|PAY-234|review (when: ready)"
 	if feedback != wantFeedback {
 		t.Fatalf("feedback prompt = %q, want %q", feedback, wantFeedback)
 	}

package/internal/repo/service.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"path/filepath"
+	"strings"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/harness"
@@ -70,6 +71,25 @@ func (s *Service) Discover(ctx context.Context) ([]runner.RepoCandidate, error)
 	return s.runner.DiscoverRepos(ctx)
 }
 
+// EnsureRepo makes the runner resource for a repository available without
+// changing relay-flow's machine configuration. Runner adapters that expose
+// RepoRegistrar perform their idempotent external provisioning; other
+// runners validate the repository through the existing read-only contract.
+func (s *Service) EnsureRepo(ctx context.Context, name, path string) error {
+	name = strings.TrimSpace(name)
+	path = strings.TrimSpace(path)
+	if name == "" {
+		return fmt.Errorf("repo: name is required")
+	}
+	if path == "" {
+		return fmt.Errorf("repo %q: path is required", name)
+	}
+	if registrar, ok := s.runner.(runner.RepoRegistrar); ok {
+		return registrar.EnsureRepo(ctx, name, path)
+	}
+	return s.runner.ValidateRepo(ctx, name, path)
+}
+
 // RequiredRepoKeys delegates to the task factory's method of the same name.
 func (s *Service) RequiredRepoKeys() []string {
 	keys, err := task.RequiredRepoKeys(s.taskPlugin)
@@ -95,9 +115,14 @@ type RegisterInput struct {
 // connectivity, duplicate names, canonical paths, and the task plugin's
 // registration identity before atomically writing machine config.
 func (s *Service) Register(ctx context.Context, input RegisterInput) (Info, error) {
+	input.Name = strings.TrimSpace(input.Name)
+	input.Path = strings.TrimSpace(input.Path)
 	if input.Name == "" {
 		return Info{}, fmt.Errorf("repo: name is required")
 	}
+	if input.Path == "" {
+		return Info{}, fmt.Errorf("repo %q: path is required", input.Name)
+	}
 	cfg, err := config.LoadMachine(s.cfgPath)
 	if err != nil {
 		return Info{}, err
@@ -154,8 +179,10 @@ func (s *Service) Register(ctx context.Context, input RegisterInput) (Info, erro
 			return Info{}, fmt.Errorf("repo %q: task registration identity already used by repo %q", input.Name, name)
 		}
 	}
-	// Runner validates the repo.
-	if err := s.runner.ValidateRepo(ctx, input.Name, input.Path); err != nil {
+	// Runner validates or provisions the repo, depending on the adapter
+	// capability. Provisioning is idempotent so explicit registration and the
+	// interactive Add action share one runner-owned path.
+	if err := s.EnsureRepo(ctx, input.Name, input.Path); err != nil {
 		return Info{}, fmt.Errorf("repo %q: runner validation: %w", input.Name, err)
 	}
 	// Task-system connectivity: construct the repo-bound System.
@@ -245,5 +272,9 @@ func canonicalPath(p string) string {
 	if err != nil {
 		return filepath.Clean(p)
 	}
-	return filepath.Clean(abs)
+	abs = filepath.Clean(abs)
+	if resolved, err := filepath.EvalSymlinks(abs); err == nil {
+		return filepath.Clean(resolved)
+	}
+	return abs
 }

package/internal/repo/service_test.go

@@ -23,6 +23,17 @@ type fakeRunnerDiscovery struct {
 	validErr   error
 }
 
+type fakeRunnerRegistrar struct {
+	*fakeRunnerDiscovery
+	ensureErr   error
+	ensureCalls []runner.RepoCandidate
+}
+
+func (f *fakeRunnerRegistrar) EnsureRepo(_ context.Context, name, path string) error {
+	f.ensureCalls = append(f.ensureCalls, runner.RepoCandidate{Name: name, Path: path})
+	return f.ensureErr
+}
+
 func (f *fakeRunnerDiscovery) DiscoverRepos(context.Context) ([]runner.RepoCandidate, error) {
 	return f.candidates, nil
 }
@@ -228,6 +239,17 @@ func TestRegisterValidatesRunnerRepo(t *testing.T) {
 	}
 }
 
+func TestRegisterUsesRunnerRepoProvisioningCapability(t *testing.T) {
+	rn := &fakeRunnerRegistrar{fakeRunnerDiscovery: &fakeRunnerDiscovery{validErr: errInvalidRepo{}}}
+	fx := newServiceFixture(t, rn)
+	if _, err := fx.svc.Register(context.Background(), repo.RegisterInput{Name: "payments", Path: "/srv/payments", TaskConfig: config.RawValues{"project": "P", "component": "c"}}); err != nil {
+		t.Fatal(err)
+	}
+	if len(rn.ensureCalls) != 1 || rn.ensureCalls[0] != (runner.RepoCandidate{Name: "payments", Path: "/srv/payments"}) {
+		t.Fatalf("EnsureRepo calls = %+v", rn.ensureCalls)
+	}
+}
+
 func TestRegisterValidatesTaskConnectivity(t *testing.T) {
 	// The task factory's New is invoked to validate connectivity; its error
 	// must reject registration before persisting.