relay-flow 0.3.8-alpha → 0.3.10-alpha

package/internal/task/jira/jira.go

@@ -4,6 +4,8 @@ package jira
 
 import (
 	"context"
+	"crypto/sha256"
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -113,6 +115,72 @@ var (
 // claimLabel is the permanent workflow claim label.
 func claimLabel(workflow string) string { return "wf:" + workflow }
 
+// claimOwnerLabel is a durable provider-owned provenance label. The owner
+// identity is hashed so the marker does not expose an email address in Jira
+// labels; the adapter compares it with the same normalized assignee identities
+// used by filters. A marker remains after reassignment, so another server
+// cannot silently take over an existing wf: claim. Only an explicit
+// provider-side handoff may replace it; automatic routing never does.
+const claimOwnerLabelPrefix = "wf-owner:"
+
+func claimOwnerToken(owner string) string {
+	owner = strings.ToLower(strings.TrimSpace(owner))
+	if owner == "" {
+		return ""
+	}
+	sum := sha256.Sum256([]byte(owner))
+	return hex.EncodeToString(sum[:])
+}
+
+func claimOwnerLabel(workflow, owner string) string {
+	token := claimOwnerToken(owner)
+	if token == "" {
+		return ""
+	}
+	return claimOwnerLabelPrefix + workflow + ":" + token
+}
+
+func claimOwnerMarkers(labels []string, workflow string) []string {
+	prefix := claimOwnerLabelPrefix + workflow + ":"
+	markers := make([]string, 0, 1)
+	for _, label := range labels {
+		if strings.HasPrefix(label, prefix) {
+			markers = append(markers, label)
+		}
+	}
+	return markers
+}
+
+func hasForeignClaimOwnerMarker(labels []string, workflow string) bool {
+	currentPrefix := claimOwnerLabelPrefix + workflow + ":"
+	for _, label := range labels {
+		if strings.HasPrefix(label, claimOwnerLabelPrefix) && !strings.HasPrefix(label, currentPrefix) {
+			return true
+		}
+	}
+	return false
+}
+
+func claimOwnerMatches(labels []string, workflow string, assignees []string) bool {
+	markers := claimOwnerMarkers(labels, workflow)
+	if len(markers) != 1 {
+		return false
+	}
+	for _, assignee := range assignees {
+		if markers[0] == claimOwnerLabel(workflow, assignee) {
+			return true
+		}
+	}
+	return false
+}
+
+func claimedWorkflow(ticket task.Ticket) string {
+	if len(ticket.WorkflowClaims) != 1 || !strings.HasPrefix(ticket.WorkflowClaims[0], "wf:") {
+		return ""
+	}
+	return strings.TrimPrefix(ticket.WorkflowClaims[0], "wf:")
+}
+
 func jiraRegistrationFields(ctx context.Context, values config.RawValues) ([]task.RegistrationField, error) {
 	fields := []task.RegistrationField{
 		{Key: "project", Title: "Jira project"},
@@ -566,14 +634,165 @@ func (s *system) resolveAssigneeFilters(values []string) ([]string, error) {
 	return resolved, nil
 }
 
+// CompileOwnershipFilter compiles only the effective assignee predicate used
+// to isolate claimed tickets. Lifecycle fields deliberately do not enter this
+// matcher because claimed routing must survive status and label changes.
+func (s *system) CompileOwnershipFilter(workflowTaskConfig config.RawValues) (func(task.Ticket) bool, error) {
+	merged := config.Merge(s.base, workflowTaskConfig)
+	cfg, err := decodeConfig(merged)
+	if err != nil {
+		return nil, err
+	}
+	assignees, err := s.resolveAssigneeFilters(cfg.Filters.Assignees)
+	if err != nil {
+		return nil, err
+	}
+	return func(ticket task.Ticket) bool {
+		if len(assignees) == 0 {
+			return true
+		}
+		workflow := claimedWorkflow(ticket)
+		owner := strField(ticket.Fields, "assignee")
+		return workflow != "" && containsFold(assignees, owner) &&
+			claimOwnerMatches(strSliceField(ticket.Fields, "labels"), workflow, []string{owner})
+	}, nil
+}
+
+func (s *system) ownershipAssignees(workflowTaskConfig config.RawValues) ([]string, error) {
+	merged := config.Merge(s.base, workflowTaskConfig)
+	cfg, err := decodeConfig(merged)
+	if err != nil {
+		return nil, err
+	}
+	return s.resolveAssigneeFilters(cfg.Filters.Assignees)
+}
+
 // --- Claim ---
 
 // Claim adds wf:<workflow> using the claims already inspected by routing.
-// Jira's label-add operation is idempotent.
+// Jira's label-add operation is idempotent. Automatic routing uses
+// ClaimIfOwned so the final ownership read happens immediately before this
+// write; this narrow method remains the task.System primitive.
 func (s *system) Claim(ctx context.Context, ticket task.TicketRef, workflow string) error {
 	return s.cli.EnsureLabel(ctx, ticket.Key, claimLabel(workflow))
 }
 
+// ValidateOwnership re-reads the current Jira assignee and claim-owner
+// marker. Both must satisfy the effective ownership filter; the provenance
+// marker additionally prevents a different owner from taking over a claim.
+func (s *system) ValidateOwnership(ctx context.Context, ticket task.TicketRef, workflow string, workflowTaskConfig config.RawValues) error {
+	assignees, err := s.ownershipAssignees(workflowTaskConfig)
+	if err != nil {
+		return err
+	}
+	if len(assignees) == 0 {
+		return nil
+	}
+	key := ticket.Key
+	if strings.TrimSpace(key) == "" {
+		key = ticket.ID
+	}
+	raw, err := s.cli.View(ctx, key)
+	if err != nil {
+		return fmt.Errorf("jira: read ticket %s ownership: %w", key, err)
+	}
+	current, err := normalizeIssue(raw)
+	if err != nil {
+		return fmt.Errorf("jira: parse ticket %s ownership: %w", key, err)
+	}
+	owner := strField(current.Fields, "assignee")
+	if !containsFold(assignees, owner) ||
+		!claimOwnerMatches(strSliceField(current.Fields, "labels"), workflow, []string{owner}) {
+		return &task.OwnershipMismatchError{Ticket: key, Workflow: workflow}
+	}
+	return nil
+}
+
+// ClaimIfOwned closes the poll-to-claim race with an adapter-owned final
+// read/check immediately before the idempotent Jira label update. The owner
+// marker is written before the wf: label so a crash cannot leave a new claim
+// with no provenance; a later poll can finish the idempotent label update.
+func (s *system) ClaimIfOwned(ctx context.Context, ticket task.TicketRef, workflow string, workflowTaskConfig config.RawValues) error {
+	assignees, err := s.ownershipAssignees(workflowTaskConfig)
+	if err != nil {
+		return err
+	}
+	if len(assignees) == 0 {
+		return s.Claim(ctx, ticket, workflow)
+	}
+	key := ticket.Key
+	if strings.TrimSpace(key) == "" {
+		key = ticket.ID
+	}
+	raw, err := s.cli.View(ctx, key)
+	if err != nil {
+		return fmt.Errorf("jira: read ticket %s before claim: %w", key, err)
+	}
+	current, err := normalizeIssue(raw)
+	if err != nil {
+		return fmt.Errorf("jira: parse ticket %s before claim: %w", key, err)
+	}
+	owner := strField(current.Fields, "assignee")
+	if !containsFold(assignees, owner) {
+		return &task.OwnershipMismatchError{Ticket: key, Workflow: workflow}
+	}
+	labels := strSliceField(current.Fields, "labels")
+	markers := claimOwnerMarkers(labels, workflow)
+	if hasForeignClaimOwnerMarker(labels, workflow) || len(markers) > 1 || (len(markers) == 1 && !claimOwnerMatches(labels, workflow, []string{owner})) {
+		return &task.OwnershipMismatchError{Ticket: key, Workflow: workflow}
+	}
+	if len(current.WorkflowClaims) > 0 {
+		if len(current.WorkflowClaims) != 1 || current.WorkflowClaims[0] != claimLabel(workflow) || len(markers) != 1 {
+			return &task.OwnershipMismatchError{Ticket: key, Workflow: workflow}
+		}
+		return s.cli.EnsureLabels(ctx, key, []string{markers[0], claimLabel(workflow)})
+	}
+	ownerLabel := claimOwnerLabel(workflow, owner)
+	if ownerLabel == "" {
+		return &task.OwnershipMismatchError{Ticket: key, Workflow: workflow}
+	}
+	return s.cli.EnsureLabels(ctx, key, []string{ownerLabel, claimLabel(workflow)})
+}
+
+// BackfillClaimOwner is an explicit repair operation for a legacy claim that
+// has no provenance marker. It never removes labels or comments and is not
+// called by automatic routing; an operator/provider handoff must invoke it.
+func (s *system) BackfillClaimOwner(ctx context.Context, ticket task.TicketRef, workflow string, workflowTaskConfig config.RawValues) error {
+	assignees, err := s.ownershipAssignees(workflowTaskConfig)
+	if err != nil {
+		return err
+	}
+	if len(assignees) == 0 {
+		return nil
+	}
+	key := ticket.Key
+	if strings.TrimSpace(key) == "" {
+		key = ticket.ID
+	}
+	raw, err := s.cli.View(ctx, key)
+	if err != nil {
+		return fmt.Errorf("jira: read ticket %s for ownership backfill: %w", key, err)
+	}
+	current, err := normalizeIssue(raw)
+	if err != nil {
+		return fmt.Errorf("jira: parse ticket %s for ownership backfill: %w", key, err)
+	}
+	owner := strField(current.Fields, "assignee")
+	if !containsFold(assignees, owner) ||
+		len(current.WorkflowClaims) != 1 || current.WorkflowClaims[0] != claimLabel(workflow) {
+		return &task.OwnershipMismatchError{Ticket: key, Workflow: workflow}
+	}
+	labels := strSliceField(current.Fields, "labels")
+	markers := claimOwnerMarkers(labels, workflow)
+	if len(markers) > 1 || (len(markers) == 1 && !claimOwnerMatches(labels, workflow, []string{owner})) {
+		return &task.OwnershipMismatchError{Ticket: key, Workflow: workflow}
+	}
+	if len(markers) == 1 {
+		return nil
+	}
+	return s.cli.EnsureLabels(ctx, key, []string{claimOwnerLabel(workflow, owner)})
+}
+
 // --- Config validation ---
 
 // ValidateConfig strictly validates the workflow and every node task config
@@ -917,7 +1136,12 @@ func strSliceField(fields map[string]any, key string) []string {
 }
 
 var (
-	_ task.System            = (*system)(nil)
-	_ task.LifecycleDefaults = (*system)(nil)
-	_ task.RestartPreparer   = (*system)(nil)
+	_ task.System                  = (*system)(nil)
+	_ task.OwnershipCapabilities   = (*system)(nil)
+	_ task.OwnershipFilterCompiler = (*system)(nil)
+	_ task.OwnershipValidator      = (*system)(nil)
+	_ task.ConditionalClaimer      = (*system)(nil)
+	_ task.ClaimOwnerBackfiller    = (*system)(nil)
+	_ task.LifecycleDefaults       = (*system)(nil)
+	_ task.RestartPreparer         = (*system)(nil)
 )

package/internal/task/jira/normalize.go

@@ -66,25 +66,40 @@ func normalizeSearchResponse(raw []byte) ([]task.Ticket, error) {
 		if hasOpenBlocker(issue) {
 			continue
 		}
-		fields := map[string]any{
-			"status":    issue.Fields.Status.Name,
-			"issueType": issue.Fields.IssueType.Name,
-			"labels":    append([]string{}, issue.Fields.Labels...),
-		}
-		if issue.Fields.Assignee != nil {
-			fields["assignee"] = issue.Fields.Assignee.EmailAddress
-		}
-		out = append(out, task.Ticket{
-			ID:             issue.ID,
-			Key:            issue.Key,
-			Title:          issue.Fields.Summary,
-			WorkflowClaims: claimLabels(issue.Fields.Labels),
-			Fields:         fields,
-		})
+		out = append(out, normalizeIssueValue(issue))
 	}
 	return out, nil
 }
 
+// normalizeIssue parses a single Jira issue returned by View. Search returns
+// an array, while final claim ownership checks use the task-system's single
+// issue response shape.
+func normalizeIssue(raw []byte) (task.Ticket, error) {
+	var issue rawIssue
+	if err := json.Unmarshal(raw, &issue); err != nil {
+		return task.Ticket{}, err
+	}
+	return normalizeIssueValue(issue), nil
+}
+
+func normalizeIssueValue(issue rawIssue) task.Ticket {
+	fields := map[string]any{
+		"status":    issue.Fields.Status.Name,
+		"issueType": issue.Fields.IssueType.Name,
+		"labels":    append([]string{}, issue.Fields.Labels...),
+	}
+	if issue.Fields.Assignee != nil {
+		fields["assignee"] = issue.Fields.Assignee.EmailAddress
+	}
+	return task.Ticket{
+		ID:             issue.ID,
+		Key:            issue.Key,
+		Title:          issue.Fields.Summary,
+		WorkflowClaims: claimLabels(issue.Fields.Labels),
+		Fields:         fields,
+	}
+}
+
 func hasOpenBlocker(issue rawIssue) bool {
 	for _, link := range issue.Fields.IssueLinks {
 		if link.Type.Name == "Blocks" && link.InwardIssue != nil &&

package/internal/task/jira/rest/client.go

@@ -52,6 +52,7 @@ type Client interface {
 	CreateSubtasks(context.Context, string, string, string, []SubtaskSpec) ([]CreatedSubtask, error)
 	UpdateMailbox(context.Context, string, string, string) error
 	EnsureLabel(context.Context, string, string) error
+	EnsureLabels(context.Context, string, []string) error
 	Transition(context.Context, string, string, string) error
 	ListComments(context.Context, string) ([]string, error)
 	AddComment(context.Context, string, string) error
@@ -265,7 +266,7 @@ func (c *HTTPClient) loadStatuses(ctx context.Context, project string) (map[stri
 }
 
 func (c *HTTPClient) View(ctx context.Context, key string) ([]byte, error) {
-	q := url.Values{"fields": {"summary,status,issuetype,labels,subtasks"}}
+	q := url.Values{"fields": {"summary,status,issuetype,labels,assignee,subtasks"}}
 	var raw json.RawMessage
 	if err := c.request(ctx, http.MethodGet, "/rest/api/3/issue/"+url.PathEscape(key), q, nil, &raw, true); err != nil {
 		return nil, err
@@ -347,7 +348,21 @@ func (c *HTTPClient) UpdateMailbox(ctx context.Context, key, description, label
 }
 
 func (c *HTTPClient) EnsureLabel(ctx context.Context, key, label string) error {
-	body := map[string]any{"update": map[string]any{"labels": []any{map[string]any{"add": label}}}}
+	return c.EnsureLabels(ctx, key, []string{label})
+}
+
+func (c *HTTPClient) EnsureLabels(ctx context.Context, key string, labels []string) error {
+	updates := make([]any, 0, len(labels))
+	for _, label := range labels {
+		if strings.TrimSpace(label) == "" {
+			continue
+		}
+		updates = append(updates, map[string]any{"add": label})
+	}
+	if len(updates) == 0 {
+		return errors.New("at least one Jira label is required")
+	}
+	body := map[string]any{"update": map[string]any{"labels": updates}}
 	return c.request(ctx, http.MethodPut, "/rest/api/3/issue/"+url.PathEscape(key), nil, body, nil, false)
 }
 

package/internal/task/jira/transition_defaults_test.go

@@ -29,7 +29,9 @@ type fakeJira struct {
 	transitionErr     error
 	events            []string
 	// searchJSON is the raw Jira search response Poll serves.
-	searchJSON    []byte
+	searchJSON []byte
+	// viewJSON is the single-issue response used by final ownership checks.
+	viewJSON      []byte
 	comments      []string
 	addedComments []string
 	labelCalls    []string

package/internal/task/task.go

@@ -4,6 +4,8 @@ package task
 
 import (
 	"context"
+	"errors"
+	"fmt"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
 )
@@ -99,6 +101,70 @@ type System interface {
 	ResetForRecovery(ctx context.Context, parent TicketRef, mailboxes []Mailbox, taskConfig config.RawValues) error
 }
 
+// ErrOwnershipMismatch identifies a task-system ownership predicate that did
+// not accept the current ticket. Adapters return OwnershipMismatchError from
+// their last-mile claim check and from claimed-run revalidation; core can
+// classify the race without learning provider-specific owner fields.
+var ErrOwnershipMismatch = errors.New("ticket owner does not match workflow")
+
+// OwnershipMismatchError is the provider-neutral shape of an ownership
+// rejection. It intentionally omits the current owner so diagnostics do not
+// expose unnecessary personal data.
+type OwnershipMismatchError struct {
+	Ticket   string
+	Workflow string
+}
+
+func (e *OwnershipMismatchError) Error() string {
+	return fmt.Sprintf("ticket %s is not owned by workflow %s", e.Ticket, e.Workflow)
+}
+
+func (e *OwnershipMismatchError) Unwrap() error { return ErrOwnershipMismatch }
+
+// OwnershipFilterCompiler is one part of the required automatic-routing
+// ownership capability set. The returned matcher contains only the
+// ownership/assignee predicate from the effective workflow config; it must not
+// repeat lifecycle filters such as status, issue type, or ordinary labels on a
+// claimed-ticket route.
+type OwnershipFilterCompiler interface {
+	CompileOwnershipFilter(workflowTaskConfig config.RawValues) (func(Ticket) bool, error)
+}
+
+// OwnershipValidator is one part of the required automatic-routing
+// ownership capability set. It is used at the last-mile boundary and before
+// claimed-run recovery, re-reading the provider-owned ticket and evaluating
+// the effective ownership predicate.
+type OwnershipValidator interface {
+	ValidateOwnership(ctx context.Context, ticket TicketRef, workflow string, workflowTaskConfig config.RawValues) error
+}
+
+// ConditionalClaimer is one part of the required automatic-routing
+// ownership capability set. It replaces Claim for an unassigned poll result;
+// the adapter performs its final ownership read immediately before the
+// idempotent workflow-label write, closing the poll-to-claim reassignment race.
+type ConditionalClaimer interface {
+	ClaimIfOwned(ctx context.Context, ticket TicketRef, workflow string, workflowTaskConfig config.RawValues) error
+}
+
+// OwnershipCapabilities is the complete capability set required by an
+// adapter that participates in automatic workflow routing. Keeping this as a
+// separate boundary leaves the core System contract focused on task
+// primitives while allowing registration to fail closed when an adapter would
+// otherwise silently fall back to unrestricted Claim behavior.
+type OwnershipCapabilities interface {
+	OwnershipFilterCompiler
+	OwnershipValidator
+	ConditionalClaimer
+}
+
+// ClaimOwnerBackfiller is an explicit provider-side repair capability for a
+// legacy wf: claim that predates ownership provenance. Normal routing never
+// invokes it; an operator/provider workflow may add the durable marker after
+// verifying the live assignee, without removing the existing claim or history.
+type ClaimOwnerBackfiller interface {
+	BackfillClaimOwner(ctx context.Context, ticket TicketRef, workflow string, workflowTaskConfig config.RawValues) error
+}
+
 // AgentEnvironment is an optional adapter capability. It returns the
 // task-system workspace environment an agent process must receive so agent
 // task commands address the same workspace as relay-flow. Values are

package/internal/workflow/report.go

@@ -43,6 +43,9 @@ func (w *Workflow) ValidateReport(node string, report Report) error {
 	if report.Status != OutcomeSuccess && report.Status != OutcomeFailure {
 		return fmt.Errorf("report status %q must be %q or %q", report.Status, OutcomeSuccess, OutcomeFailure)
 	}
+	if report.Status == OutcomeFailure && report.NextStep == EndNode {
+		return fmt.Errorf("failure reports cannot select %q", EndNode)
+	}
 	for _, field := range []struct{ name, value string }{
 		{"summary.completed", report.Summary.Completed},
 		{"summary.commits", report.Summary.Commits},

package/internal/workflow/report_test.go

@@ -181,6 +181,22 @@ func TestValidateReportStatusValues(t *testing.T) {
 	}
 }
 
+func TestValidateReportRejectsFailureToEndEvenIfRouteTableContainsIt(t *testing.T) {
+	wf := parse(t, "basicFlow", minimalValid)
+	node := wf.Nodes["coding"]
+	node.OnFailure = append(node.OnFailure, workflow.Route{Target: workflow.EndNode})
+	wf.Nodes["coding"] = node
+	r := workflow.Report{
+		Status:   workflow.OutcomeFailure,
+		NextStep: workflow.EndNode,
+		Summary:  fullSummary(),
+		Feedback: noneFeedback(),
+	}
+	if err := wf.ValidateReport("coding", r); err == nil {
+		t.Fatal("failure report selecting end accepted")
+	}
+}
+
 func TestValidateReportNextStepMustMatchStatusRoute(t *testing.T) {
 	wf := parse(t, "basicFlow", minimalValid)
 

package/internal/workflow/workflow.go

@@ -65,9 +65,15 @@ type Node struct {
 	Agent       string           `yaml:"agent,omitempty" json:"agent,omitempty"`
 	Description string           `yaml:"description,omitempty" json:"description,omitempty"`
 	NudgePrompt string           `yaml:"nudgePrompt,omitempty" json:"nudgePrompt,omitempty"`
+	AutoReject  bool             `yaml:"autoReject,omitempty" json:"autoReject,omitempty"`
 	TaskConfig  config.RawValues `yaml:"taskConfig,omitempty" json:"taskConfig,omitempty"`
 	OnSuccess   []Route          `yaml:"onSuccess,omitempty" json:"onSuccess,omitempty"`
 	OnFailure   []Route          `yaml:"onFailure,omitempty" json:"onFailure,omitempty"`
+
+	// autoRejectSet lets validation distinguish an explicitly configured false
+	// from an omitted field. The marker is parser metadata and is not part of
+	// the workflow snapshot or JSON/YAML representation.
+	autoRejectSet bool
 }
 
 type Route struct {
@@ -119,6 +125,10 @@ func Parse(name string, yamlBytes []byte) (*Workflow, error) {
 	rawNodes, _ := raw["nodes"].(map[string]any)
 	for nodeName, n := range wf.Nodes {
 		if rn, ok := rawNodes[nodeName].(map[string]any); ok {
+			if _, present := rn["autoReject"]; present {
+				n.autoRejectSet = true
+				wf.Nodes[nodeName] = n
+			}
 			if v, present := rn["taskConfig"]; present && v == nil {
 				return nil, fmt.Errorf("parse workflow %q node %q: taskConfig: explicit null is not allowed", name, nodeName)
 			}
@@ -216,6 +226,9 @@ func (w *Workflow) Validate() error {
 }
 
 func validateStart(n Node) error {
+	if n.AutoReject || n.autoRejectSet {
+		return fmt.Errorf("autoReject is valid only on hitl nodes")
+	}
 	if n.Type != "" || n.Agent != "" || n.Description != "" || n.NudgePrompt != "" {
 		return fmt.Errorf("start must not declare type, agent, description, or nudgePrompt")
 	}
@@ -229,6 +242,9 @@ func validateStart(n Node) error {
 }
 
 func validateEnd(n Node) error {
+	if n.AutoReject || n.autoRejectSet {
+		return fmt.Errorf("autoReject is valid only on hitl nodes")
+	}
 	if n.Type != "" || n.Agent != "" || n.Description != "" || n.NudgePrompt != "" {
 		return fmt.Errorf("end must not declare type, agent, description, or nudgePrompt")
 	}
@@ -242,6 +258,9 @@ func validateWorkNode(wfName, name string, n Node) error {
 	if n.Type != NodeAgent && n.Type != NodeHITL {
 		return fmt.Errorf("workflow %q node %q: type must be %q or %q", wfName, name, NodeAgent, NodeHITL)
 	}
+	if n.Type != NodeHITL && (n.AutoReject || n.autoRejectSet) {
+		return fmt.Errorf("workflow %q node %q: autoReject is valid only on hitl nodes", wfName, name)
+	}
 	if n.Agent == "" {
 		return fmt.Errorf("workflow %q node %q: agent is required", wfName, name)
 	}
@@ -254,6 +273,11 @@ func validateWorkNode(wfName, name string, n Node) error {
 	if len(n.OnFailure) == 0 {
 		return fmt.Errorf("workflow %q node %q: at least one failure route is required", wfName, name)
 	}
+	for _, route := range n.OnFailure {
+		if route.Target == EndNode {
+			return fmt.Errorf("workflow %q node %q: failure routes cannot target %q", wfName, name, EndNode)
+		}
+	}
 	for _, m := range nudgeVarPattern.FindAllStringSubmatch(n.NudgePrompt, -1) {
 		if !knownNudgeVars[m[1]] {
 			return fmt.Errorf("workflow %q node %q: unknown nudge template variable {{%s}}", wfName, name, m[1])

package/internal/workflow/workflow_test.go

@@ -221,6 +221,63 @@ func TestValidateEndNode(t *testing.T) {
 	})
 }
 
+func TestAutoRejectPolicy(t *testing.T) {
+	t.Run("defaults false on HITL", func(t *testing.T) {
+		yaml := strings.Replace(minimalValid, "    type: agent", "    type: hitl", 1)
+		wf := parse(t, "basicFlow", yaml)
+		if err := wf.Validate(); err != nil {
+			t.Fatalf("HITL workflow rejected: %v", err)
+		}
+		if wf.Nodes["coding"].AutoReject {
+			t.Fatal("omitted autoReject defaulted to true")
+		}
+	})
+
+	t.Run("accepts true on HITL", func(t *testing.T) {
+		yaml := strings.Replace(minimalValid, "    type: agent", "    type: hitl\n    autoReject: true", 1)
+		wf := parse(t, "basicFlow", yaml)
+		if err := wf.Validate(); err != nil {
+			t.Fatalf("HITL autoReject workflow rejected: %v", err)
+		}
+		if !wf.Nodes["coding"].AutoReject {
+			t.Fatal("autoReject true was not parsed")
+		}
+	})
+
+	for _, tc := range []struct {
+		name string
+		yaml string
+	}{
+		{
+			name: "agent",
+			yaml: strings.Replace(minimalValid, "    type: agent", "    type: agent\n    autoReject: false", 1),
+		},
+		{
+			name: "start",
+			yaml: strings.Replace(minimalValid, "  start:\n    onSuccess:", "  start:\n    autoReject: false\n    onSuccess:", 1),
+		},
+		{
+			name: "end",
+			yaml: strings.Replace(minimalValid, "  end: {}", "  end:\n    autoReject: false", 1),
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			wf := parse(t, "basicFlow", tc.yaml)
+			if err := wf.Validate(); err == nil {
+				t.Fatal("autoReject accepted outside a HITL node")
+			}
+		})
+	}
+
+	t.Run("rejects failure route to end", func(t *testing.T) {
+		yaml := strings.Replace(minimalValid, "    onFailure:\n      - target: coding", "    onFailure:\n      - target: end", 1)
+		wf := parse(t, "basicFlow", yaml)
+		if err := wf.Validate(); err == nil {
+			t.Fatal("failure route to end accepted")
+		}
+	})
+}
+
 func TestValidateWorkNodes(t *testing.T) {
 	replaceCoding := func(node string) string {
 		return strings.Replace(minimalValid, "  coding:\n    type: agent\n    agent: build\n    description: Do the coding work.\n    onSuccess:\n      - target: end\n    onFailure:\n      - target: coding", node, 1)
@@ -303,7 +360,7 @@ func TestValidateRoutes(t *testing.T) {
 		}
 	})
 	t.Run("several routes for one outcome", func(t *testing.T) {
-		yaml := strings.Replace(minimalValid, "    onFailure:\n      - target: coding", "    onFailure:\n      - target: coding\n        when: retry\n      - target: end\n        when: give up", 1)
+		yaml := strings.Replace(minimalValid, "    onFailure:\n      - target: coding", "    onFailure:\n      - target: coding\n        when: retry\n      - target: coding\n        when: try again", 1)
 		wf := parse(t, "basicFlow", yaml)
 		if err := wf.Validate(); err != nil {
 			t.Fatalf("two failure routes rejected: %v", err)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-flow",
-  "version": "0.3.8-alpha",
+  "version": "0.3.10-alpha",
   "description": "Graph-based agent workflow engine — tracker-agnostic, pluggable runners",
   "bin": {
     "relay-flow": "./bin/relay-flow.js",