relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/task/jira/jira.go

@@ -6,13 +6,15 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"regexp"
 	"sort"
 	"strings"
+	"sync"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/retry"
 	"github.com/rajpopat27/relay-flow/internal/task"
-	"github.com/rajpopat27/relay-flow/internal/task/jira/acli"
+	jirarest "github.com/rajpopat27/relay-flow/internal/task/jira/rest"
 )
 
 // Config is the adapter-owned typed config for every scope.
@@ -20,9 +22,16 @@ type Config struct {
 	Assignee   string       `yaml:"assignee,omitempty"`
 	Project    string       `yaml:"project,omitempty"`
 	Component  string       `yaml:"component,omitempty"`
-	Site       string       `yaml:"site,omitempty"`
 	Filters    Filters      `yaml:"filters,omitempty"`
 	Transition TransitionTo `yaml:"transitionTo,omitempty"`
+	Templates  Templates    `yaml:"templates,omitempty"`
+}
+
+// Templates are Jira-owned task-system descriptions and comments.
+type Templates struct {
+	MailboxDescription string `yaml:"mailboxDescription"`
+	SummaryComment     string `yaml:"summaryComment"`
+	FeedbackComment    string `yaml:"feedbackComment"`
 }
 
 // Filters are the structured, locally evaluable workflow ticket matchers.
@@ -41,9 +50,53 @@ type TransitionTo struct {
 
 // Deterministic transition defaults for omitted values.
 const (
-	defaultStartParentStatus = "In Progress"
-	defaultWorkTaskStatus    = "In Progress"
-	defaultEndParentStatus   = "Done"
+	defaultStartParentStatus  = "In Progress"
+	defaultWorkTaskStatus     = "In Progress"
+	defaultEndParentStatus    = "Done"
+	defaultMailboxDescription = `Parent ticket: {{ticket}}
+Workflow: {{workflow}}
+Node: {{node}}
+Node type: {{nodeType}}
+Agent: {{agent}}
+Mailbox: {{mailbox}}
+
+Node work:
+{{nodeDescription}}
+
+Read this mailbox's comments for feedback from previous nodes.`
+	defaultSummaryComment = `Summary for {{node}}
+
+{{summaryReport}}`
+	defaultFeedbackComment = `Feedback from {{sourceNode}} to {{targetNode}} mailbox {{mailbox}}
+
+{{feedbackReport}}`
+)
+
+var textVarPattern = regexp.MustCompile(`\{\{([^{}]*)\}\}`)
+
+var knownTextVars = map[string]bool{
+	"runID": true, "ticket": true, "workflow": true,
+	"repo": true, "node": true, "nodeType": true, "agent": true,
+	"nodeDescription": true, "nextSteps": true, "successRoutes": true,
+	"failureRoutes": true, "mailbox": true, "sourceNode": true,
+	"targetNode": true, "summaryReport": true, "feedbackReport": true,
+}
+
+// DefaultConfig supplies Jira task-system text defaults for relay-flow init.
+func DefaultConfig() config.RawValues {
+	return config.RawValues{"templates": map[string]any{
+		"mailboxDescription": defaultMailboxDescription,
+		"summaryComment":     defaultSummaryComment,
+		"feedbackComment":    defaultFeedbackComment,
+	}}
+}
+
+var (
+	clientsMu sync.Mutex
+	clients   = map[string]struct {
+		token  string
+		client *jirarest.HTTPClient
+	}{}
 )
 
 // claimLabel is the permanent workflow claim label.
@@ -52,6 +105,14 @@ func claimLabel(workflow string) string { return "wf:" + workflow }
 func init() {
 	task.Register("jira", task.Factory{
 		RequiredRepoKeys: func() []string { return []string{"project", "component"} },
+		DefaultConfig:    DefaultConfig,
+		ValidateTextConfig: func(raw config.RawValues) error {
+			var cfg Config
+			if err := config.DecodeStrict(raw, &cfg); err != nil {
+				return err
+			}
+			return validateTemplates(cfg.Templates)
+		},
 		TaskScopeKey: func(rootConfig, repoConfig config.RawValues) (string, error) {
 			var root, repoCfg Config
 			if err := config.DecodeStrict(rootConfig, &root); err != nil {
@@ -65,34 +126,73 @@ func init() {
 			if proj == "" || comp == "" {
 				return "", fmt.Errorf("jira task scope requires repo project and component")
 			}
-			return strings.Join([]string{root.Site, proj, comp}, "/"), nil
+			creds, err := loadCredentialsDefault()
+			if err != nil {
+				return "", fmt.Errorf("jira credentials: %w", err)
+			}
+			return strings.Join([]string{creds.Site, proj, comp}, "/"), nil
 		},
+		Auth: auth,
 		New: func(ctx context.Context, spec task.RepoSpec) (task.System, error) {
-			return newSystem(ctx, acli.New(), spec)
+			merged := config.Merge(spec.RootConfig, spec.RepoConfig)
+			var cfg Config
+			if err := config.DecodeStrict(merged, &cfg); err != nil {
+				return nil, fmt.Errorf("jira repo %q config: %w", spec.Name, err)
+			}
+			creds, err := loadCredentialsDefault()
+			if err != nil {
+				return nil, fmt.Errorf("jira credentials: %w", err)
+			}
+			client, err := sharedClient(creds.Site, creds.Email, creds.Token)
+			if err != nil {
+				return nil, err
+			}
+			return newSystem(ctx, client, spec)
 		},
 	})
 }
 
+func sharedClient(site, email, token string) (*jirarest.HTTPClient, error) {
+	key := strings.TrimRight(site, "/") + "\x00" + email
+	clientsMu.Lock()
+	defer clientsMu.Unlock()
+	if cached := clients[key]; cached.client != nil && cached.token == token {
+		return cached.client, nil
+	}
+	client, err := jirarest.New(site, email, token)
+	if err != nil {
+		return nil, err
+	}
+	clients[key] = struct {
+		token  string
+		client *jirarest.HTTPClient
+	}{token: token, client: client}
+	return client, nil
+}
+
 // system is the repo-bound Jira task.System. It is safe for concurrent use;
-// the ACLI client owns any subprocess serialization.
+// the REST client owns connection reuse, caches, and request limiting.
 type system struct {
-	cli       acli.Client
+	cli       jirarest.Client
 	repoName  string
 	base      config.RawValues
 	effective Config // root+repo merged
 }
 
-func newSystem(ctx context.Context, cli acli.Client, spec task.RepoSpec) (*system, error) {
+func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*system, error) {
 	if spec.Name == "" {
 		return nil, fmt.Errorf("jira: repo name is required")
 	}
-	merged := config.Merge(spec.RootConfig, spec.RepoConfig)
+	merged := config.Merge(DefaultConfig(), spec.RootConfig, spec.RepoConfig)
 	var cfg Config
 	if err := config.DecodeStrict(merged, &cfg); err != nil {
 		return nil, fmt.Errorf("jira repo %q config: %w", spec.Name, err)
 	}
+	if err := validateTemplates(cfg.Templates); err != nil {
+		return nil, fmt.Errorf("jira repo %q taskConfig.templates: %w", spec.Name, err)
+	}
 	if cfg.Assignee != "" {
-		if err := cli.ValidateAssignee(ctx, cfg.Assignee); err != nil {
+		if err := cli.ValidateAssignee(ctx, cfg.Project, cfg.Assignee); err != nil {
 			return nil, fmt.Errorf("jira repo %q assignee %q: %w", spec.Name, cfg.Assignee, err)
 		}
 	}
@@ -110,11 +210,10 @@ func newSystem(ctx context.Context, cli acli.Client, spec task.RepoSpec) (*syste
 	return s, nil
 }
 
-// newSystemForCLI constructs a system around an explicit CLI seam (tests).
-func newSystemForCLI(cli acli.Client) (task.System, error) {
+// newSystemForCLI constructs a system around an explicit Jira client seam.
+func newSystemForCLI(cli jirarest.Client) (task.System, error) {
 	return newSystem(context.Background(), cli, task.RepoSpec{
 		Name:       "payments",
-		RootConfig: config.RawValues{},
 		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
 	})
 }
@@ -128,6 +227,55 @@ func decodeConfig(raw config.RawValues) (Config, error) {
 	return cfg, nil
 }
 
+func validateTemplates(templates Templates) error {
+	for name, tmpl := range map[string]string{
+		"mailboxDescription": templates.MailboxDescription,
+		"summaryComment":     templates.SummaryComment,
+		"feedbackComment":    templates.FeedbackComment,
+	} {
+		for _, match := range textVarPattern.FindAllStringSubmatch(tmpl, -1) {
+			if !knownTextVars[match[1]] {
+				return fmt.Errorf("%s: unknown template variable {{%s}}", name, match[1])
+			}
+		}
+	}
+	if !strings.Contains(templates.SummaryComment, "{{summaryReport}}") {
+		return fmt.Errorf("summaryComment must contain {{summaryReport}}")
+	}
+	if !strings.Contains(templates.FeedbackComment, "{{feedbackReport}}") {
+		return fmt.Errorf("feedbackComment must contain {{feedbackReport}}")
+	}
+	return nil
+}
+
+// RenderText renders Jira-owned mailbox descriptions and comments.
+func (s *system) RenderText(kind task.TextKind, data task.TextData) (string, error) {
+	var tmpl string
+	switch kind {
+	case task.TextMailboxDescription:
+		tmpl = s.effective.Templates.MailboxDescription
+	case task.TextSummaryComment:
+		tmpl = s.effective.Templates.SummaryComment
+	case task.TextFeedbackComment:
+		tmpl = s.effective.Templates.FeedbackComment
+	default:
+		return "", fmt.Errorf("jira: unknown task text kind %q", kind)
+	}
+	values := map[string]string{
+		"runID": data.RunID, "ticket": data.Ticket,
+		"workflow": data.Workflow, "repo": data.Repo, "node": data.Node,
+		"nodeType": data.NodeType, "agent": data.Agent,
+		"nodeDescription": data.NodeDescription, "nextSteps": data.NextSteps,
+		"successRoutes": data.SuccessRoutes, "failureRoutes": data.FailureRoutes,
+		"mailbox": data.Mailbox, "sourceNode": data.SourceNode,
+		"targetNode": data.TargetNode, "summaryReport": data.SummaryReport,
+		"feedbackReport": data.FeedbackReport,
+	}
+	return textVarPattern.ReplaceAllStringFunc(tmpl, func(match string) string {
+		return values[textVarPattern.FindStringSubmatch(match)[1]]
+	}), nil
+}
+
 // --- Poll / filters ---
 
 // buildJQL scopes the parent poll by project/component and active statuses.
@@ -169,11 +317,15 @@ func (s *system) Poll(ctx context.Context) ([]task.Ticket, error) {
 // CompileFilter compiles workflow taskConfig.filters into an in-memory
 // matcher over normalized ticket fields. Unknown filter fields are rejected.
 func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.Ticket) bool, error) {
-	cfg, err := decodeConfig(workflowTaskConfig)
+	merged := config.Merge(s.base, workflowTaskConfig)
+	cfg, err := decodeConfig(merged)
 	if err != nil {
 		return nil, err
 	}
 	f := cfg.Filters
+	if !hasAssigneeFilter(merged) && cfg.Assignee != "" {
+		f.Assignees = []string{cfg.Assignee}
+	}
 	return func(t task.Ticket) bool {
 		if len(f.ParentStatuses) > 0 && !contains(f.ParentStatuses, strField(t.Fields, "status")) {
 			return false
@@ -189,36 +341,32 @@ func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.T
 				}
 			}
 		}
-		if len(f.Assignees) > 0 && !contains(f.Assignees, strField(t.Fields, "assignee")) {
+		if len(f.Assignees) > 0 && !containsFold(f.Assignees, strField(t.Fields, "assignee")) {
 			return false
 		}
 		return true
 	}, nil
 }
 
+func hasAssigneeFilter(raw config.RawValues) bool {
+	switch filters := raw["filters"].(type) {
+	case map[string]any:
+		_, ok := filters["assignees"]
+		return ok
+	case config.RawValues:
+		_, ok := filters["assignees"]
+		return ok
+	default:
+		return false
+	}
+}
+
 // --- Claim ---
 
-// Claim adds wf:<workflow> to the parent. It re-reads the parent's claims,
-// treats the same claim as idempotent, and rejects a conflicting claim.
+// Claim adds wf:<workflow> using the claims already inspected by routing.
+// Jira's label-add operation is idempotent.
 func (s *system) Claim(ctx context.Context, ticket task.TicketRef, workflow string) error {
-	raw, err := s.cli.View(ctx, ticket.Key)
-	if err != nil {
-		return err
-	}
-	labels, err := labelsOf(raw)
-	if err != nil {
-		return err
-	}
-	want := claimLabel(workflow)
-	for _, l := range labels {
-		if l == want {
-			return nil // idempotent
-		}
-		if strings.HasPrefix(l, "wf:") {
-			return fmt.Errorf("ticket %s already claimed by %s", ticket.Key, l)
-		}
-	}
-	return s.cli.EnsureLabel(ctx, ticket.Key, want)
+	return s.cli.EnsureLabel(ctx, ticket.Key, claimLabel(workflow))
 }
 
 // --- Config validation ---
@@ -231,7 +379,10 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 	if err != nil {
 		return fmt.Errorf("workflow taskConfig: %w", err)
 	}
-	if err := s.validateAssignee(ctx, "workflow", workflowCfg.Assignee); err != nil {
+	if err := validateTemplates(workflowCfg.Templates); err != nil {
+		return fmt.Errorf("workflow taskConfig.templates: %w", err)
+	}
+	if err := s.validateAssignee(ctx, "workflow", workflowCfg.Project, workflowCfg.Assignee); err != nil {
 		return err
 	}
 	if err := s.validateTransition(ctx, "workflow", workflowCfg.Project, workflowCfg.Transition); err != nil {
@@ -247,7 +398,10 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 		if err != nil {
 			return fmt.Errorf("node %q taskConfig: %w", n, err)
 		}
-		if err := s.validateAssignee(ctx, fmt.Sprintf("node %q", n), cfg.Assignee); err != nil {
+		if err := validateTemplates(cfg.Templates); err != nil {
+			return fmt.Errorf("node %q taskConfig.templates: %w", n, err)
+		}
+		if err := s.validateAssignee(ctx, fmt.Sprintf("node %q", n), cfg.Project, cfg.Assignee); err != nil {
 			return err
 		}
 		if err := s.validateTransition(ctx, fmt.Sprintf("node %q", n), cfg.Project, cfg.Transition); err != nil {
@@ -257,11 +411,11 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 	return nil
 }
 
-func (s *system) validateAssignee(ctx context.Context, scope, assignee string) error {
+func (s *system) validateAssignee(ctx context.Context, scope, project, assignee string) error {
 	if assignee == "" {
 		return nil
 	}
-	if err := s.cli.ValidateAssignee(ctx, assignee); err != nil {
+	if err := s.cli.ValidateAssignee(ctx, project, assignee); err != nil {
 		return fmt.Errorf("%s assignee %q: %w", scope, assignee, err)
 	}
 	return nil
@@ -289,47 +443,47 @@ func (s *system) validateTransition(ctx context.Context, scope, project string,
 // LifecycleDefaults exposure: the deterministic Jira transition defaults per
 // lifecycle point (spec: Jira transition defaults are deterministic). Run
 // orchestration merges these raw values under the effective node config
-// before ApplyTaskConfig; omitted values inherit the default, explicit
-// values win (map merge with defaults as the lower layer).
+// before ApplyTaskConfig, so the effective precedence is
+// built-in default < root < repo < workflow < node.
+//
+// The methods also carry the inherited root/repository transitionTo and
+// assignee values. ApplyTaskConfig receives only the workflow/node config the
+// caller assembles, so returning inherited values here is what makes a
+// repo-scoped value take effect at runtime instead of being validated and then
+// silently discarded. internal/task/beads implements the same rule; keep the
+// two adapters aligned.
 
 // StartDefaults defaults the parent to In Progress.
 func (s *system) StartDefaults() config.RawValues {
-	return config.RawValues{"transitionTo": map[string]any{"parentStatus": defaultStartParentStatus}}
+	return s.lifecycleDefaults(transitionDefault("parentStatus", defaultStartParentStatus))
 }
 
 // WorkDefaults defaults the mailbox task status to In Progress; the parent
 // is left unchanged when parentStatus is omitted.
 func (s *system) WorkDefaults() config.RawValues {
-	return config.RawValues{"transitionTo": map[string]any{"taskStatus": defaultWorkTaskStatus}}
+	return s.lifecycleDefaults(transitionDefault("taskStatus", defaultWorkTaskStatus))
 }
 
 // EndDefaults defaults the parent to Done.
 func (s *system) EndDefaults() config.RawValues {
-	return config.RawValues{"transitionTo": map[string]any{"parentStatus": defaultEndParentStatus}}
+	return s.lifecycleDefaults(transitionDefault("parentStatus", defaultEndParentStatus))
 }
 
-// endConfig applies the deterministic end default: omitted parentStatus
-// becomes Done.
-func endConfig(cfg config.RawValues) config.RawValues {
-	return withTransitionDefault(cfg, "parentStatus", defaultEndParentStatus)
+func transitionDefault(key, value string) config.RawValues {
+	return config.RawValues{"transitionTo": map[string]any{key: value}}
 }
 
-func withTransitionDefault(cfg config.RawValues, key, value string) config.RawValues {
-	out := config.RawValues{}
-	for k, v := range cfg {
-		out[k] = v
-	}
-	merged := map[string]any{}
-	if tr, ok := out["transitionTo"].(map[string]any); ok {
-		for k, v := range tr {
-			merged[k] = v
+// lifecycleDefaults layers the inherited root/repository operation values over
+// the built-in lifecycle default. Only the keys ApplyTaskConfig consumes are
+// carried, so unrelated configuration never enters durable activity inputs.
+func (s *system) lifecycleDefaults(builtin config.RawValues) config.RawValues {
+	inherited := config.RawValues{}
+	for _, key := range []string{"transitionTo", "assignee"} {
+		if value, ok := s.base[key]; ok {
+			inherited[key] = value
 		}
 	}
-	if _, ok := merged[key]; !ok {
-		merged[key] = value
-	}
-	out["transitionTo"] = merged
-	return out
+	return config.Merge(builtin, inherited)
 }
 
 // --- Mailboxes ---
@@ -347,28 +501,38 @@ func (s *system) EnsureMailboxes(ctx context.Context, parent task.TicketRef, wor
 		return nil, err
 	}
 	out := map[string]task.Mailbox{}
+	missing := make([]task.MailboxSpec, 0)
 	for _, spec := range specs {
 		if mb, ok := existing[spec.Title]; ok {
-			// Found existing: reconcile the workflow label and description,
-			// and return the complete node-identified value.
-			if err := s.cli.EnsureLabel(ctx, mb.Key, claimLabel(workflow)); err != nil {
-				return nil, fmt.Errorf("label mailbox %q: %w", mb.Key, err)
-			}
-			if err := s.cli.UpdateDescription(ctx, mb.Key, spec.Description); err != nil {
-				return nil, fmt.Errorf("describe mailbox %q: %w", mb.Key, err)
+			if err := s.cli.UpdateMailbox(ctx, mb.Key, spec.Description, claimLabel(workflow)); err != nil {
+				return nil, fmt.Errorf("reconcile mailbox %q: %w", mb.Key, err)
 			}
 			mb.Node = spec.Node
 			out[spec.Node] = mb
 			continue
 		}
-		id, key, err := s.cli.CreateSubtask(ctx, parent.Key, spec.Title, spec.Description)
-		if err != nil {
-			return nil, fmt.Errorf("create mailbox %q: %w", spec.Title, err)
-		}
-		if err := s.cli.EnsureLabel(ctx, key, claimLabel(workflow)); err != nil {
-			return nil, fmt.Errorf("label mailbox %q: %w", key, err)
+		missing = append(missing, spec)
+	}
+	if len(missing) == 0 {
+		return out, nil
+	}
+	createSpecs := make([]jirarest.SubtaskSpec, 0, len(missing))
+	for _, spec := range missing {
+		createSpecs = append(createSpecs, jirarest.SubtaskSpec{Title: spec.Title, Description: spec.Description})
+	}
+	created, err := s.cli.CreateSubtasks(ctx, parent.Key, s.effective.Project, claimLabel(workflow), createSpecs)
+	if err != nil {
+		return nil, fmt.Errorf("create mailboxes: %w", err)
+	}
+	if len(created) != len(missing) {
+		return nil, fmt.Errorf("create mailboxes: created %d of %d", len(created), len(missing))
+	}
+	for i, mailbox := range created {
+		spec := missing[i]
+		if mailbox.ID == "" || mailbox.Key == "" {
+			return nil, fmt.Errorf("create mailbox %q: Jira returned no id/key", spec.Title)
 		}
-		out[spec.Node] = task.Mailbox{ID: id, Key: key, Node: spec.Node}
+		out[spec.Node] = task.Mailbox{ID: mailbox.ID, Key: mailbox.Key, Node: spec.Node}
 	}
 	return out, nil
 }
@@ -388,20 +552,15 @@ func (s *system) ApplyTaskConfig(ctx context.Context, target task.Target, taskCo
 	}
 	tr := cfg.Transition
 	if target.Mailbox != nil {
-		if cfg.Assignee != "" {
-			if err := s.cli.Assign(ctx, target.Mailbox.Key, cfg.Assignee); err != nil {
-				return err
-			}
-		}
 		status := tr.TaskStatus
 		if status == "" {
 			status = defaultWorkTaskStatus
 		}
-		if err := s.transition(ctx, target.Mailbox.Key, status); err != nil {
+		if err := s.transition(ctx, target.Mailbox.Key, status, cfg.Assignee); err != nil {
 			return err
 		}
 		if tr.ParentStatus != "" {
-			return s.transition(ctx, target.Parent.Key, tr.ParentStatus)
+			return s.transition(ctx, target.Parent.Key, tr.ParentStatus, "")
 		}
 		return nil
 	}
@@ -410,13 +569,13 @@ func (s *system) ApplyTaskConfig(ctx context.Context, target task.Target, taskCo
 	if status == "" {
 		status = defaultStartParentStatus
 	}
-	return s.transition(ctx, target.Parent.Key, status)
+	return s.transition(ctx, target.Parent.Key, status, "")
 }
 
 // transition applies a Jira status transition, mapping a human-incompatible
 // current state to a conflict.
-func (s *system) transition(ctx context.Context, key, status string) error {
-	err := s.cli.Transition(ctx, key, status)
+func (s *system) transition(ctx context.Context, key, status, assignee string) error {
+	err := s.cli.Transition(ctx, key, status, assignee)
 	if err != nil && isConflict(err) {
 		return retry.ConflictError(err)
 	}
@@ -431,7 +590,7 @@ func isConflict(err error) bool {
 
 // CompleteMailbox marks the mailbox Done using task-system semantics.
 func (s *system) CompleteMailbox(ctx context.Context, mailbox task.Mailbox) error {
-	return s.transition(ctx, mailbox.Key, "Done")
+	return s.transition(ctx, mailbox.Key, "Done", "")
 }
 
 // --- Comments ---
@@ -480,7 +639,7 @@ func (s *system) Comment(ctx context.Context, target task.Target, body, marker s
 // comments, labels, and history. No parent rollback runs.
 func (s *system) ResetForRecovery(ctx context.Context, _ task.TicketRef, mailboxes []task.Mailbox, _ config.RawValues) error {
 	for _, mb := range mailboxes {
-		if err := s.transition(ctx, mb.Key, "To Do"); err != nil {
+		if err := s.transition(ctx, mb.Key, "To Do", ""); err != nil {
 			return fmt.Errorf("reset mailbox %s: %w", mb.Key, err)
 		}
 	}
@@ -496,6 +655,15 @@ func contains(xs []string, want string) bool {
 	return false
 }
 
+func containsFold(xs []string, want string) bool {
+	for _, x := range xs {
+		if strings.EqualFold(x, want) {
+			return true
+		}
+	}
+	return false
+}
+
 func strField(fields map[string]any, key string) string {
 	s, _ := fields[key].(string)
 	return s
@@ -505,3 +673,8 @@ func strSliceField(fields map[string]any, key string) []string {
 	out, _ := fields[key].([]string)
 	return out
 }
+
+var (
+	_ task.System            = (*system)(nil)
+	_ task.LifecycleDefaults = (*system)(nil)
+)