relay-flow 0.3.8-alpha → 0.3.10-alpha

package/internal/execution/projection/projection.go

@@ -257,24 +257,69 @@ func (p *RunProjection) insertStart(ctx context.Context, s run.Start, now time.T
 }
 
 func (p *RunProjection) updateState(ctx context.Context, id run.ID, state run.State, lastErr string, finished *time.Time) error {
+	_, err := p.updateStateCAS(ctx, id, nil, state, lastErr, finished)
+	return err
+}
+
+// beginCancellation atomically claims cancellation of a nonterminal run. A
+// run already in canceling keeps its original reason; completed/canceled runs
+// are never moved backwards. The returned row is read after the conditional
+// update so concurrent cancel/complete callers observe the winner.
+func (p *RunProjection) beginCancellation(ctx context.Context, id run.ID, reason string) (run.Run, error) {
+	_, err := p.DB.ExecContext(ctx, `
+		UPDATE relay_runs SET state = ?, last_error = ?, updated_at = ?
+		WHERE id = ? AND state NOT IN ('completed', 'canceled', 'canceling')`,
+		string(run.StateCanceling), reason, time.Now().UTC(), string(id))
+	if err != nil {
+		return run.Run{}, err
+	}
+	return p.get(ctx, id)
+}
+
+func (p *RunProjection) updateStateCAS(ctx context.Context, id run.ID, expected *run.State, state run.State, lastErr string, finished *time.Time) (bool, error) {
 	terminal := state == run.StateCompleted || state == run.StateCanceled
 	now := time.Now().UTC()
-	_, err := p.DB.ExecContext(ctx, `
+	query := `
 		UPDATE relay_runs SET state = ?, last_error = ?, updated_at = ?, finished_at = COALESCE(?, finished_at),
 			retry_error = CASE WHEN ? THEN NULL ELSE retry_error END,
 			retry_attempt = CASE WHEN ? THEN NULL ELSE retry_attempt END,
 			next_retry_at = CASE WHEN ? THEN NULL ELSE next_retry_at END
-		WHERE id = ?`,
-		string(state), lastErr, now, finished, terminal, terminal, terminal, string(id))
+		WHERE id = ?`
+	args := []any{
+		string(state), lastErr, now, finished, terminal, terminal, terminal,
+		string(id),
+	}
+	if expected == nil {
+		// Ordinary workflow projection updates are fenced after cancellation or
+		// any terminal state has won. Explicit compare-and-set callers below
+		// are allowed to reconcile a known canceling row to its inspected
+		// terminal engine result.
+		query += ` AND NOT (
+			(state = 'canceling' AND ? NOT IN ('canceling', 'canceled'))
+			OR (state IN ('completed', 'canceled') AND state <> ?)
+		)`
+		args = append(args, string(state), string(state))
+	} else {
+		query += ` AND state = ? AND NOT (state IN ('completed', 'canceled') AND state <> ?)`
+		args = append(args, string(*expected), string(state))
+	}
+	result, err := p.DB.ExecContext(ctx, query, args...)
 	if err != nil {
-		return err
+		return false, err
+	}
+	updated, err := result.RowsAffected()
+	if err != nil {
+		return false, err
+	}
+	if updated != 1 {
+		return false, nil
 	}
 	// Keep the derived timeline useful during retries and cancellation without
 	// making it an execution authority. Identify one active row first; a
 	// repeated terminal update with no active row is a no-op for the timeline.
 	stepStatus := stepStatusForRunState(state)
 	if stepStatus == "" {
-		return nil
+		return true, nil
 	}
 	var sequence int64
 	var startedAt sql.NullTime
@@ -283,14 +328,14 @@ func (p *RunProjection) updateState(ctx context.Context, id run.ID, state run.St
 		WHERE run_id = ? AND status IN ('running', 'waiting', 'blocked')
 		ORDER BY sequence DESC LIMIT 1`, string(id)).Scan(&sequence, &startedAt)
 	if errors.Is(lookupErr, sql.ErrNoRows) {
-		return nil
+		return true, nil
 	}
 	if lookupErr != nil {
 		// relay_run_steps is display/cache data. The authoritative relay_runs
 		// state update above has already succeeded and must not be retried just
 		// because this optional projection is unavailable.
 		slog.Warn("step projection state lookup unavailable", "runID", string(id), "state", state, "error", lookupErr)
-		return nil
+		return true, nil
 	}
 	var stepFinished any
 	if terminal {
@@ -300,7 +345,7 @@ func (p *RunProjection) updateState(ctx context.Context, id run.ID, state run.St
 			stepFinished = now
 		}
 	}
-	result, err := p.DB.ExecContext(ctx, `
+	result, err = p.DB.ExecContext(ctx, `
 		UPDATE relay_run_steps SET status = ?, message = CASE WHEN ? <> '' THEN ? ELSE message END,
 			finished_at = CASE WHEN ? THEN COALESCE(finished_at, ?) ELSE finished_at END
 		WHERE run_id = ? AND sequence = ? AND status IN ('running', 'waiting', 'blocked')`,
@@ -308,11 +353,11 @@ func (p *RunProjection) updateState(ctx context.Context, id run.ID, state run.St
 		string(id), sequence)
 	if err != nil {
 		slog.Warn("step projection state update unavailable", "runID", string(id), "state", state, "error", err)
-		return nil
+		return true, nil
 	}
-	updated, err := result.RowsAffected()
+	updated, err = result.RowsAffected()
 	if err != nil || updated != 1 {
-		return nil
+		return true, nil
 	}
 	if terminal && startedAt.Valid {
 		endAt := now
@@ -327,7 +372,7 @@ func (p *RunProjection) updateState(ctx context.Context, id run.ID, state run.St
 			slog.Warn("step projection duration update unavailable", "runID", string(id), "state", state, "error", durationErr)
 		}
 	}
-	return nil
+	return true, nil
 }
 
 func (p *RunProjection) updateRetry(ctx context.Context, id run.ID, status *run.RetryStatus) error {
@@ -352,12 +397,20 @@ func (p *RunProjection) updateNode(ctx context.Context, id run.ID, state run.Sta
 	}
 	defer tx.Rollback()
 	now := time.Now().UTC()
-	if _, err := tx.ExecContext(ctx, `
+	result, err := tx.ExecContext(ctx, `
 		UPDATE relay_runs SET state = ?, current_node = ?, current_node_visit_id = ?, updated_at = ?
-		WHERE id = ?`,
-		string(state), node, string(visit), now, string(id)); err != nil {
+		WHERE id = ? AND state NOT IN ('canceling', 'completed', 'canceled')`,
+		string(state), node, string(visit), now, string(id))
+	if err != nil {
 		return err
 	}
+	updated, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+	if updated != 1 {
+		return tx.Commit()
+	}
 	// A revisit changes only the latest visit ID. Reusable terminal/session
 	// identities remain attached to this run/node row.
 	if _, err := tx.ExecContext(ctx, `
@@ -907,6 +960,18 @@ func (p *RunProjection) UpdateState(ctx context.Context, id run.ID, state run.St
 	return p.updateState(ctx, id, state, lastErr, finished)
 }
 
+// BeginCancellation atomically moves a nonterminal run to canceling and
+// returns the persisted row. Existing canceling rows retain their reason.
+func (p *RunProjection) BeginCancellation(ctx context.Context, id run.ID, reason string) (run.Run, error) {
+	return p.beginCancellation(ctx, id, reason)
+}
+
+// UpdateStateIf applies a lifecycle transition only while the row has the
+// expected state. It returns false when another transition won the race.
+func (p *RunProjection) UpdateStateIf(ctx context.Context, id run.ID, expected, state run.State, lastErr string, finished *time.Time) (bool, error) {
+	return p.updateStateCAS(ctx, id, &expected, state, lastErr, finished)
+}
+
 // UpdateRetry updates or clears active retry metadata.
 func (p *RunProjection) UpdateRetry(ctx context.Context, id run.ID, status *run.RetryStatus) error {
 	return p.updateRetry(ctx, id, status)

package/internal/execution/temporal/interpreter.go

@@ -402,7 +402,8 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		spec := harness.LaunchSpec{
 			RunID: start.ID, NodeVisitID: visit, RepoName: start.Repo, RepoPath: start.RepoPath,
 			Workflow: wf.Name, Ticket: start.Ticket.Key, Node: current, NodeType: node.Type,
-			Agent: node.Agent, Title: start.Ticket.Key + ":" + current, NudgePrompt: node.NudgePrompt,
+			AutoReject: node.AutoReject,
+			Agent:      node.Agent, Title: start.Ticket.Key + ":" + current, NudgePrompt: node.NudgePrompt,
 			PromptData: harness.PromptData{
 				TaskSystem: "", Ticket: start.Ticket.Key, Workflow: wf.Name, Repo: start.Repo,
 				Node: current, NodeType: node.Type, Agent: node.Agent, NodeDescription: node.Description,

package/internal/execution/temporal/recovery.go

@@ -6,10 +6,12 @@ import (
 	"fmt"
 	"log/slog"
 	"sort"
-	"strings"
 	"time"
 
 	"github.com/rajpopat27/relay-flow/internal/identity"
+	"github.com/rajpopat27/relay-flow/internal/repo"
+	"github.com/rajpopat27/relay-flow/internal/router"
+	"github.com/rajpopat27/relay-flow/internal/task"
 	enumspb "go.temporal.io/api/enums/v1"
 	"go.temporal.io/api/serviceerror"
 	workflowpb "go.temporal.io/api/workflow/v1"
@@ -145,52 +147,82 @@ func (e *Engine) reconcileClaimedParents(ctx context.Context, visible map[string
 			slog.Warn("Temporal recovery skipping repository with unavailable task system", "repo", rp.Name, "error", rp.TaskSystemError)
 			continue
 		}
+		capabilities, ok := rp.TaskSystem.(task.OwnershipCapabilities)
+		if !ok {
+			slog.Warn("Temporal recovery skipping repository without ownership capabilities", "repo", rp.Name,
+				"outcome", "ownership-capability-missing")
+			continue
+		}
 		tickets, err := rp.TaskSystem.Poll(ctx)
 		if err != nil {
 			return fmt.Errorf("poll repo %q during Temporal recovery: %w", rp.Name, err)
 		}
 		for _, ticket := range tickets {
-			for _, claim := range ticket.WorkflowClaims {
-				if !strings.HasPrefix(claim, "wf:") {
-					continue
-				}
-				workflowName := strings.TrimPrefix(claim, "wf:")
-				var matched bool
-				for _, binding := range rp.Bindings() {
-					if binding.Workflow != nil && binding.Workflow.Name == workflowName {
-						matched = true
-						break
-					}
-				}
-				if !matched {
-					continue
-				}
-				expectedID := identity.NewRunID(rp.Name, workflowName, ticket.Key)
-				if visible[string(expectedID)] {
-					continue
+			// Projection reconciliation only considers claimed parents. Resolve
+			// through the same router as normal polling so ambiguous, unknown,
+			// and owner-mismatched claims cannot restore an execution.
+			if len(ticket.WorkflowClaims) != 1 {
+				continue
+			}
+			wf, err := router.ResolveWorkflow(rp, ticket)
+			if err != nil {
+				var ownerMismatch *router.ClaimOwnerMismatchError
+				if errors.As(err, &ownerMismatch) {
+					slog.Info("Temporal recovery route outcome", "repo", rp.Name, "ticket", ticket.Key,
+						"workflow", ownerMismatch.Workflow, "outcome", "claim-owner-mismatch")
+				} else {
+					slog.Warn("Temporal recovery skipped claimed ticket", "repo", rp.Name, "ticket", ticket.Key, "outcome", "invalid-claim", "error", err)
 				}
-				info, err := e.client.DescribeWorkflowExecution(ctx, string(expectedID), "")
-				if err != nil {
-					var notFound *serviceerror.NotFound
-					if errors.As(err, &notFound) {
-						// This is the documented claim-before-run gap. Record it
-						// for operators, but leave creation to normal polling after
-						// recovery; this path must never start a replacement.
-						slog.Info("Temporal recovery missing claimed execution", "repo", rp.Name, "workflow", workflowName, "ticket", ticket.Key, "runID", string(expectedID))
-						continue
-					}
-					return fmt.Errorf("describe claimed Temporal workflow %s: %w", expectedID, err)
+				continue
+			}
+			workflowName := wf.Name
+			var matched *repo.WorkflowBinding
+			for _, binding := range rp.Bindings() {
+				if binding.Workflow != nil && binding.Workflow.Name == workflowName {
+					candidate := binding
+					matched = &candidate
+					break
 				}
-				if info == nil || info.WorkflowExecutionInfo == nil || info.WorkflowExecutionInfo.Execution == nil ||
-					info.WorkflowExecutionInfo.Type == nil || info.WorkflowExecutionInfo.Type.Name != TicketWorkflowName || info.WorkflowExecutionInfo.TaskQueue != TaskQueue {
+			}
+			if matched == nil {
+				continue
+			}
+			// Existing Temporal executions are restored only after the same
+			// ownership gate used by normal claimed routing. Lifecycle
+			// filters remain intentionally bypassed.
+			if err := capabilities.ValidateOwnership(ctx, ticket.Ref(), workflowName, matched.Workflow.TaskConfig); err != nil {
+				if errors.Is(err, task.ErrOwnershipMismatch) {
+					slog.Info("Temporal recovery route outcome", "repo", rp.Name, "ticket", ticket.Key,
+						"workflow", workflowName, "outcome", "claim-owner-mismatch", "error", err)
 					continue
 				}
-				if !shouldRestoreTemporalExecution(info.WorkflowExecutionInfo, time.Now().UTC(), e.retention) {
+				return fmt.Errorf("poll repo %q ticket %s validate ownership: %w", rp.Name, ticket.Key, err)
+			}
+			expectedID := identity.NewRunID(rp.Name, workflowName, ticket.Key)
+			if visible[string(expectedID)] {
+				continue
+			}
+			info, err := e.client.DescribeWorkflowExecution(ctx, string(expectedID), "")
+			if err != nil {
+				var notFound *serviceerror.NotFound
+				if errors.As(err, &notFound) {
+					// This is the documented claim-before-run gap. Record it
+					// for operators, but leave creation to normal polling after
+					// recovery; this path must never start a replacement.
+					slog.Info("Temporal recovery missing claimed execution", "repo", rp.Name, "workflow", workflowName, "ticket", ticket.Key, "runID", string(expectedID))
 					continue
 				}
-				if err := e.restoreProjection(ctx, info.WorkflowExecutionInfo); err != nil {
-					return fmt.Errorf("restore claimed Temporal workflow %s: %w", expectedID, err)
-				}
+				return fmt.Errorf("describe claimed Temporal workflow %s: %w", expectedID, err)
+			}
+			if info == nil || info.WorkflowExecutionInfo == nil || info.WorkflowExecutionInfo.Execution == nil ||
+				info.WorkflowExecutionInfo.Type == nil || info.WorkflowExecutionInfo.Type.Name != TicketWorkflowName || info.WorkflowExecutionInfo.TaskQueue != TaskQueue {
+				continue
+			}
+			if !shouldRestoreTemporalExecution(info.WorkflowExecutionInfo, time.Now().UTC(), e.retention) {
+				continue
+			}
+			if err := e.restoreProjection(ctx, info.WorkflowExecutionInfo); err != nil {
+				return fmt.Errorf("restore claimed Temporal workflow %s: %w", expectedID, err)
 			}
 		}
 	}

package/internal/harness/harness.go

@@ -49,6 +49,7 @@ type LaunchSpec struct {
 	Ticket      string
 	Node        string
 	NodeType    workflow.NodeType
+	AutoReject  bool
 	Agent       string
 	Title       string
 	Prompt      string

package/internal/harness/opencode/opencode.go

@@ -17,6 +17,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
@@ -206,6 +207,10 @@ func (h *Harness) BuildCommand(spec harness.LaunchSpec) (runner.Command, error)
 	} {
 		env[key] = value
 	}
+	if spec.NodeType == workflow.NodeHITL {
+		// HITL policy is launch metadata, not part of the report wire object.
+		env["RELAY_FLOW_AUTO_REJECT"] = strconv.FormatBool(spec.AutoReject)
+	}
 	args := []string{}
 	if spec.ResumeID != "" {
 		args = append(args, "--session", spec.ResumeID)

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.3.8-alpha"
+const configuredPlugin = "relay-flow-plugin@0.3.10-alpha"
 
 func TestBuildCommandArgv(t *testing.T) {
 	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")
@@ -57,6 +57,22 @@ func TestBuildCommandArgv(t *testing.T) {
 	}
 }
 
+func TestBuildCommandCarriesHITLAutoRejectPolicy(t *testing.T) {
+	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")
+	cmd, err := opencode.New().BuildCommand(harness.LaunchSpec{
+		NodeType:   workflow.NodeHITL,
+		AutoReject: true,
+		Agent:      "reviewer",
+		Prompt:     "review the ticket",
+	})
+	if err != nil {
+		t.Fatalf("BuildCommand: %v", err)
+	}
+	if got := cmd.Env["RELAY_FLOW_AUTO_REJECT"]; got != "true" {
+		t.Fatalf("RELAY_FLOW_AUTO_REJECT = %q, want true", got)
+	}
+}
+
 func TestRenderPromptTemplatesExposeAllValues(t *testing.T) {
 	raw := config.RawValues{
 		"initial":  "initial {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nodeType}}|{{agent}}|{{nodeDescription}}|{{nextSteps}}|{{mailbox}}",

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.3.8-alpha"
+const relayFlowPlugin = "relay-flow-plugin@0.3.10-alpha"
 
 type jsoncToken struct {
 	kind       byte

package/internal/harness/pi/pi.go

@@ -13,11 +13,13 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/harness"
 	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
 const (
@@ -214,6 +216,10 @@ func (*Harness) BuildCommand(spec harness.LaunchSpec) (runner.Command, error) {
 	} {
 		env[key] = value
 	}
+	if spec.NodeType == workflow.NodeHITL {
+		// HITL policy is launch metadata, not part of the report wire object.
+		env["RELAY_FLOW_AUTO_REJECT"] = strconv.FormatBool(spec.AutoReject)
+	}
 	args := []string{"--name", spec.Title}
 	if spec.Agent != "default" {
 		args = append(args, "--prompt-template", promptTemplatePath(spec.Agent))

package/internal/harness/pi/task_env_test.go

@@ -2,8 +2,24 @@ package pi
 
 import (
 	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
+func TestBuildCommandCarriesHITLAutoRejectPolicy(t *testing.T) {
+	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")
+	spec := launchSpec(t)
+	spec.NodeType = workflow.NodeHITL
+	spec.AutoReject = true
+	cmd, err := (&Harness{}).BuildCommand(spec)
+	if err != nil {
+		t.Fatalf("BuildCommand: %v", err)
+	}
+	if got := cmd.Env["RELAY_FLOW_AUTO_REJECT"]; got != "true" {
+		t.Fatalf("RELAY_FLOW_AUTO_REJECT = %q, want true", got)
+	}
+}
+
 // TestBuildCommandCarriesTaskSystemEnvironment asserts the task-system
 // workspace environment reaches the runner command so agent task commands
 // address the same workspace as relay-flow, and that relay-flow's own

package/internal/recover/recover.go

@@ -50,6 +50,12 @@ func FromTaskSystem(ctx context.Context, repoReg *repo.Registry, rnr runner.Runn
 			slog.Warn("recover: skip repository with unavailable task system", "repo", rp.Name, "error", rp.TaskSystemError)
 			continue
 		}
+		capabilities, ok := rp.TaskSystem.(task.OwnershipCapabilities)
+		if !ok {
+			slog.Warn("recover: skip repository without ownership capabilities", "repo", rp.Name,
+				"outcome", "ownership-capability-missing")
+			continue
+		}
 		tickets, err := rp.TaskSystem.Poll(ctx)
 		if err != nil {
 			return fmt.Errorf("repo %q poll: %w", rp.Name, err)
@@ -65,9 +71,32 @@ func FromTaskSystem(ctx context.Context, repoReg *repo.Registry, rnr runner.Runn
 				continue
 			}
 			if err != nil {
-				slog.Warn("recover: skip ticket with invalid claim", "ticket", ticket.Key, "error", err)
+				var ownerMismatch *router.ClaimOwnerMismatchError
+				var invalid *router.InvalidClaimError
+				if errors.As(err, &ownerMismatch) {
+					slog.Info("recover route outcome", "repo", rp.Name, "ticket", ticket.Key,
+						"workflow", ownerMismatch.Workflow, "outcome", "claim-owner-mismatch", "error", err)
+				} else if errors.As(err, &invalid) {
+					slog.Warn("recover route outcome", "repo", rp.Name, "ticket", ticket.Key,
+						"workflow", invalid.Workflow, "outcome", "invalid-claim", "error", err)
+				} else {
+					slog.Warn("recover route outcome", "repo", rp.Name, "ticket", ticket.Key,
+						"outcome", "error", "error", err)
+				}
 				continue
 			}
+			// Router ownership uses the poll snapshot. Re-read the current
+			// provider-owned ticket before any recovery mutation so a
+			// poll-to-recovery reassignment cannot close terminals or reset
+			// mailboxes for the wrong owner.
+			if err := capabilities.ValidateOwnership(ctx, ticket.Ref(), wf.Name, wf.TaskConfig); err != nil {
+				if errors.Is(err, task.ErrOwnershipMismatch) {
+					slog.Info("recover route outcome", "repo", rp.Name, "ticket", ticket.Key,
+						"workflow", wf.Name, "outcome", "claim-owner-mismatch", "error", err)
+					continue
+				}
+				return fmt.Errorf("repo %q ticket %s validate ownership: %w", rp.Name, ticket.Key, err)
+			}
 			// Skip canceled parents: the cancellation marker is the
 			// task-system recovery record.
 			runID := identity.NewRunID(rp.Name, wf.Name, ticket.Key)

package/internal/repo/binding_test.go

@@ -1,6 +1,7 @@
 package repo
 
 import (
+	"context"
 	"errors"
 	"strings"
 	"testing"
@@ -15,6 +16,21 @@ type bindingTaskSystem struct {
 	compileErr map[string]error
 }
 
+type ownershipBindingTaskSystem struct{ bindingTaskSystem }
+
+type legacyBindingTaskSystem struct{ task.System }
+
+func (legacyBindingTaskSystem) CompileFilter(config.RawValues) (func(task.Ticket) bool, error) {
+	return func(task.Ticket) bool { return true }, nil
+}
+
+func (s ownershipBindingTaskSystem) CompileOwnershipFilter(values config.RawValues) (func(task.Ticket) bool, error) {
+	owner, _ := values["owner"].(string)
+	return func(ticket task.Ticket) bool {
+		return owner == "" || ticket.Fields["assignee"] == owner
+	}, nil
+}
+
 func (s bindingTaskSystem) CompileFilter(values config.RawValues) (func(task.Ticket) bool, error) {
 	if name, ok := values["name"].(string); ok {
 		if err := s.compileErr[name]; err != nil {
@@ -25,6 +41,53 @@ func (s bindingTaskSystem) CompileFilter(values config.RawValues) (func(task.Tic
 	return func(task.Ticket) bool { return true }, nil
 }
 
+func (s bindingTaskSystem) CompileOwnershipFilter(config.RawValues) (func(task.Ticket) bool, error) {
+	return func(task.Ticket) bool { return true }, nil
+}
+
+func (s bindingTaskSystem) ValidateOwnership(context.Context, task.TicketRef, string, config.RawValues) error {
+	return nil
+}
+
+func (s bindingTaskSystem) ClaimIfOwned(ctx context.Context, ticket task.TicketRef, workflow string, _ config.RawValues) error {
+	return s.Claim(ctx, ticket, workflow)
+}
+
+func TestBindWorkflowsRejectsMissingOwnershipCapabilities(t *testing.T) {
+	registered := &Repo{Name: "payments", TaskSystem: legacyBindingTaskSystem{}}
+	registry := NewRegistry()
+	registry.Replace(registered)
+	wf := &workflow.Workflow{Name: "legacyFlow", Repos: []string{"payments"}, Status: workflow.HealthHealthy}
+	if err := registry.BindWorkflows([]*workflow.Workflow{wf}); err == nil || !strings.Contains(err.Error(), "ownership capabilities") {
+		t.Fatalf("BindWorkflows error = %v, want missing-capability failure", err)
+	}
+	if bindings := registered.Bindings(); len(bindings) != 0 {
+		t.Fatalf("bindings = %#v, want none after capability rejection", bindings)
+	}
+}
+
+func TestBindWorkflowsPublishesSeparateOwnershipMatcher(t *testing.T) {
+	system := ownershipBindingTaskSystem{bindingTaskSystem: bindingTaskSystem{}}
+	registered := &Repo{Name: "payments", TaskSystem: system}
+	registry := NewRegistry()
+	registry.Replace(registered)
+	wf := &workflow.Workflow{
+		Name: "ownerFlow", Repos: []string{"payments"}, Status: workflow.HealthHealthy,
+		TaskConfig: config.RawValues{"owner": "alice"},
+	}
+	if err := registry.BindWorkflows([]*workflow.Workflow{wf}); err != nil {
+		t.Fatal(err)
+	}
+	bindings := registered.Bindings()
+	if len(bindings) != 1 || bindings[0].Ownership == nil {
+		t.Fatalf("bindings = %#v, want a published ownership matcher", bindings)
+	}
+	if !bindings[0].Ownership(task.Ticket{Fields: map[string]any{"assignee": "alice"}}) ||
+		bindings[0].Ownership(task.Ticket{Fields: map[string]any{"assignee": "bob"}}) {
+		t.Fatal("published ownership matcher did not enforce the adapter predicate")
+	}
+}
+
 func TestBindWorkflowsIsolatedPublishesHealthyWorkflows(t *testing.T) {
 	system := bindingTaskSystem{compileErr: map[string]error{"bad": errors.New("invalid filter")}}
 	registered := &Repo{Name: "payments", TaskSystem: system}

package/internal/repo/repo.go

@@ -16,8 +16,11 @@ import (
 // repo. Repo.Workflows is a derived in-memory index rebuilt at startup and
 // after workflow submission/removal; Workflow.Repos is the source of truth.
 type WorkflowBinding struct {
-	Workflow *workflow.Workflow
-	Match    func(task.Ticket) bool
+	Workflow  *workflow.Workflow
+	Match     func(task.Ticket) bool
+	// Ownership is compiled from the adapter-owned durable claim-owner
+	// predicate. It is mandatory for published automatic-routing bindings.
+	Ownership func(task.Ticket) bool
 }
 
 type Info struct {
@@ -124,8 +127,9 @@ func (r *Registry) BindWorkflowsIsolated(workflows []*workflow.Workflow) []Bindi
 
 func (r *Registry) bindWorkflows(workflows []*workflow.Workflow, isolate bool) ([]BindingIssue, error) {
 	type binding struct {
-		wf    *workflow.Workflow
-		match func(task.Ticket) bool
+		wf        *workflow.Workflow
+		match     func(task.Ticket) bool
+		ownership func(task.Ticket) bool
 	}
 	byRepo := map[string][]binding{}
 	issues := []BindingIssue{}
@@ -171,7 +175,44 @@ func (r *Registry) bindWorkflows(workflows []*workflow.Workflow, isolate bool) (
 				failed = true
 				break
 			}
-			byRepo[repoName] = append(byRepo[repoName], binding{wf: wf, match: match})
+			// Ownership is a separate matcher so a claimed ticket can bypass
+			// lifecycle filters while still remaining isolated to the adapter's
+			// effective assignee/owner. All automatic-routing adapters must
+			// expose the complete capability set; there is no unrestricted Claim
+			// fallback for a missing capability.
+			capabilities, ok := rp.TaskSystem.(task.OwnershipCapabilities)
+			if !ok {
+				err = fmt.Errorf("workflow %q repo %q: task system lacks required ownership capabilities", wf.Name, repoName)
+				if !isolate {
+					return nil, err
+				}
+				wf.MarkBlocked(err.Error(), wf.RepairCommand)
+				issues = append(issues, BindingIssue{Workflow: wf, Error: err})
+				failed = true
+				break
+			}
+			ownership, err := capabilities.CompileOwnershipFilter(wf.TaskConfig)
+			if err != nil {
+				err = fmt.Errorf("workflow %q repo %q: compile ownership filter: %w", wf.Name, repoName, err)
+				if !isolate {
+					return nil, err
+				}
+				wf.MarkBlocked(err.Error(), wf.RepairCommand)
+				issues = append(issues, BindingIssue{Workflow: wf, Error: err})
+				failed = true
+				break
+			}
+			if ownership == nil {
+				err = fmt.Errorf("workflow %q repo %q: ownership compiler returned a nil matcher", wf.Name, repoName)
+				if !isolate {
+					return nil, err
+				}
+				wf.MarkBlocked(err.Error(), wf.RepairCommand)
+				issues = append(issues, BindingIssue{Workflow: wf, Error: err})
+				failed = true
+				break
+			}
+			byRepo[repoName] = append(byRepo[repoName], binding{wf: wf, match: match, ownership: ownership})
 		}
 		if failed {
 			// A workflow is all-or-nothing across its referenced repositories;
@@ -197,7 +238,7 @@ func (r *Registry) bindWorkflows(workflows []*workflow.Workflow, isolate bool) (
 		binds := byRepo[name]
 		next := make([]WorkflowBinding, 0, len(binds))
 		for _, b := range binds {
-			next = append(next, WorkflowBinding{Workflow: b.wf, Match: b.match})
+			next = append(next, WorkflowBinding{Workflow: b.wf, Match: b.match, Ownership: b.ownership})
 		}
 		sort.Slice(next, func(i, j int) bool { return next[i].Workflow.Name < next[j].Workflow.Name })
 		rp.bindingsMu.Lock()