feat(workflow): when conditions, handoff, human approval and forge steps; feasibility and triage ship as YAML

This commit is contained in:
sam committed 2026-10-05 00:06:35 +11:00
1 parent 4efb835eed
commit eeccb2e995
10 files changed
+322 -255

No files matched your search

+17 -2
View File
@@ -4,6 +4,8 @@ import (
"context"
"encoding/json"
"fmt"
"maps"
"slices"
"strings"
"gopkg.in/yaml.v3"
@@ -151,10 +153,23 @@ func agentResultTool(schema map[string]any) (*agentrun.CaptureTool, error) {
required = append(required, name)
}
}
return &agentrun.CaptureTool{
tool := &agentrun.CaptureTool{
Name: resultToolName, Description: "Return this step's result. Call exactly once, before finish.",
Parameters: params, RequiredFields: required, MaxCalls: 1,
}, nil
}
properties, _ := schema["properties"].(map[string]any)
for _, name := range slices.Sorted(maps.Keys(properties)) {
property, _ := properties[name].(map[string]any)
switch property["type"] {
case "boolean":
tool.BooleanFields = append(tool.BooleanFields, name)
case "string":
if slices.Contains(required, name) {
tool.NonEmptyStrings = append(tool.NonEmptyStrings, name)
}
}
}
return tool, nil
}
// missionWithInputs appends the task's workflow inputs to a mission as a JSON
+168
View File
@@ -0,0 +1,168 @@
package workflow
import (
"context"
"fmt"
"strings"
"gopkg.in/yaml.v3"
)
// Control step types: they decide where the task goes next.
const (
HandoffStepName = "workflow.handoff"
ApproveStepName = "human.approve"
CloseIssueStepName = "forge.close-issue"
CommentStepName = "forge.comment"
)
// ControlStepTypes contributes the control and forge step types.
func ControlStepTypes() []StepType {
return []StepType{
{Name: HandoffStepName, Factory: newHandoffStage},
{Name: ApproveStepName, Factory: newApproveStage},
{Name: CloseIssueStepName, Factory: newCloseIssueStage},
{Name: CommentStepName, Factory: newCommentStage},
}
}
type handoffSettings struct {
Workflow string `yaml:"workflow"`
Detail string `yaml:"detail"`
}
// newHandoffStage requeues the task under another workflow: the same task,
// not a child run, so its history stays in one place.
func newHandoffStage(settings yaml.Node) (Stage, error) {
var s handoffSettings
if err := decodeSettings(HandoffStepName, settings, &s); err != nil {
return Stage{}, err
}
if strings.TrimSpace(s.Workflow) == "" {
return Stage{}, fmt.Errorf("%s: settings.workflow is required", HandoffStepName)
}
return Stage{Name: HandoffStepName, Run: func(_ context.Context, tc *TaskContext) error {
tc.Task.Workflow = strings.TrimSpace(s.Workflow)
tc.Outcome = Outcome{Status: StatusQueued, Detail: s.Detail}
return nil
}}, nil
}
type approveSettings struct {
// Plan is what the human decides on. It is kept on the task, and the
// workflow named by Then reads it as task.plan.
Plan string `yaml:"plan"`
// Then is the workflow the task is requeued under once approved.
Then string `yaml:"then"`
}
// newApproveStage delivers the plan to the decision surfaces and waits: the
// task parks in waiting_human until an operator approves or rejects it.
func newApproveStage(settings yaml.Node) (Stage, error) {
var s approveSettings
if err := decodeSettings(ApproveStepName, settings, &s); err != nil {
return Stage{}, err
}
if strings.TrimSpace(s.Plan) == "" || strings.TrimSpace(s.Then) == "" {
return Stage{}, fmt.Errorf("%s: settings.plan and settings.then are required", ApproveStepName)
}
return Stage{Name: ApproveStepName, Run: func(ctx context.Context, tc *TaskContext) error {
tc.Task.Plan = s.Plan
notify(ctx, tc, "approval")
tc.Task.Workflow = s.Then
tc.Outcome = Outcome{Status: StatusWaitingHuman, Detail: "plan delivered, awaiting go/no-go"}
return nil
}}, nil
}
func newCloseIssueStage(yaml.Node) (Stage, error) {
return Stage{Name: CloseIssueStepName, Run: func(ctx context.Context, tc *TaskContext) error {
if !tc.Task.IsForgeBacked() {
return nil
}
return tc.Forge.CloseIssue(ctx, tc.Task.Owner, tc.Task.Repo, tc.Task.IssueNumber, "")
}}, nil
}
type commentSettings struct {
Body string `yaml:"body"`
// On is "issue" (the default) or "pr".
On string `yaml:"on"`
}
func newCommentStage(settings yaml.Node) (Stage, error) {
var s commentSettings
if err := decodeSettings(CommentStepName, settings, &s); err != nil {
return Stage{}, err
}
if strings.TrimSpace(s.Body) == "" {
return Stage{}, fmt.Errorf("%s: settings.body is required", CommentStepName)
}
if s.On != "" && s.On != "issue" && s.On != "pr" {
return Stage{}, fmt.Errorf("%s: settings.on is issue or pr, not %q", CommentStepName, s.On)
}
return Stage{Name: CommentStepName, Run: func(ctx context.Context, tc *TaskContext) error {
number := tc.Task.IssueNumber
if s.On == "pr" {
number = tc.Task.EffectivePRNumber()
}
if !tc.Task.IsForgeBacked() || number == 0 {
return nil
}
_, err := tc.Forge.Comment(ctx, tc.Task.Owner, tc.Task.Repo, number, s.Body)
return err
}}, nil
}
// condition is a step's when: a reference that must be truthy, optionally
// negated with !, or compared with == or != to a literal.
type condition struct {
path string
negate bool
operator string
operand string
}
func parseCondition(source string) (condition, error) {
source = strings.TrimSpace(source)
for _, operator := range []string{"==", "!="} {
if left, right, ok := strings.Cut(source, operator); ok {
return condition{path: strings.TrimSpace(left), operator: operator, operand: strings.Trim(strings.TrimSpace(right), `"'`)}, nil
}
}
c := condition{path: source}
if rest, ok := strings.CutPrefix(source, "!"); ok {
c = condition{path: strings.TrimSpace(rest), negate: true}
}
if c.path == "" {
return condition{}, fmt.Errorf("when names nothing")
}
return c, nil
}
func (c condition) holds(tc *TaskContext) bool {
value := lookup(referenceScope(tc), strings.Split(c.path, "."))
switch c.operator {
case "==":
return stringify(value) == c.operand
case "!=":
return stringify(value) != c.operand
}
return truthy(value) != c.negate
}
func truthy(value any) bool {
switch v := value.(type) {
case nil:
return false
case bool:
return v
case string:
return v != "" && v != "false"
case float64:
return v != 0
case int:
return v != 0
}
return true
}
+23 -2
View File
@@ -32,7 +32,10 @@ type YAMLDefinition struct {
// workflow whose repository is not required may use only these, since it may
// run with no worktree at all. workflow.call needs none of the caller's own:
// the callee's own repository mode decides whether its run clones.
var repoFreeStepTypes = map[string]bool{AgentRunStepName: true, WorkflowCallStepName: true, FinishStepName: true}
var repoFreeStepTypes = map[string]bool{
AgentRunStepName: true, WorkflowCallStepName: true, FinishStepName: true,
HandoffStepName: true, ApproveStepName: true, CloseIssueStepName: true, CommentStepName: true,
}
// NeedsRepository reports whether a step type can run only with a worktree.
func NeedsRepository(stepType string) bool { return !repoFreeStepTypes[stepType] }
@@ -43,6 +46,9 @@ type StepRecord struct {
ID string `yaml:"id,omitempty" json:"id,omitempty"`
Type string `yaml:"type" json:"type"`
Settings yaml.Node `yaml:"settings,omitempty" json:"-"`
// When skips the step unless the condition holds: a reference that must
// be truthy, negated with !, or compared with == or != to a literal.
When string `yaml:"when,omitempty" json:"when,omitempty"`
// OnFailure is "park" (the default) or "continue".
OnFailure string `yaml:"on_failure,omitempty" json:"on_failure,omitempty"`
}
@@ -102,6 +108,15 @@ func checkStep(step StepRecord, mode task.RepositoryMode, earlier map[string]boo
if err := checkReferences(step.Settings, earlier); err != nil {
return err
}
if step.When != "" {
c, err := parseCondition(step.When)
if err != nil {
return err
}
if err := checkReference(c.path, earlier); err != nil {
return fmt.Errorf("when: %w", err)
}
}
if _, err := factory(step.Settings); err != nil {
return fmt.Errorf("%q settings: %w", step.Type, err)
}
@@ -128,8 +143,14 @@ func Compile(definition YAMLDefinition, registry StepRegistry) (Workflow, error)
// compiledStep builds the step's stage at run time from its settings with
// every reference resolved, and records what it leaves for later steps.
func compiledStep(step StepRecord, name string, factory StepFactory) Stage {
// ParseDefinition has already refused a condition that does not parse.
when, _ := parseCondition(step.When)
return Stage{Name: name, ContinueOnFailure: step.OnFailure == onFailureContinue, Run: func(ctx context.Context, tc *TaskContext) error {
tc.stepResult = StepResult{}
if step.When != "" && !when.holds(tc) {
tc.Log.Info("step skipped", "when", step.When)
return nil
}
stage, err := factory(renderSettings(step.Settings, tc))
if err != nil {
return fmt.Errorf("step %q settings: %w", step.Type, err)
@@ -321,7 +342,7 @@ func sortedInputNames(inputs map[string]task.InputSpec) []string {
func legacyBuiltinWorkflows() Registry {
return Registry{
"feasibility": Feasibility(), "triage": Triage(), "remediate": Remediate(),
"remediate": Remediate(),
"pr-review": PRReview(),
}
}
+1 -119
View File
@@ -7,126 +7,8 @@ import (
"fmt"
"net/http"
"time"
"github.com/samcharles93/archie-core/internal/domain/agentrun"
)
// The operator answers in chat or on the dashboard -- the decision surfaces --
// and the approval requeues the feature under the implement workflow or closes
// it. Routed via the "feature" label.
func Feasibility() Workflow {
return Workflow{
Name: "feasibility",
Stages: []Stage{
StagePrepareWorktree(), // read-only stages still need the checkout
AgentStage{
Name: "assess",
Role: "planner",
ReadOnly: true,
CaptureTools: decideCaptureTools,
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Assess whether this feature request fits the project %s.\n\n"+
"%s\n\n"+
"Read the repository's AGENT.md, ROADMAP.md, and README (whichever exist) plus "+
"enough code to judge scope and architectural fit. Then call the decide tool "+
"EXACTLY ONCE with fit=true or fit=false and your reasons, and afterwards call "+
"finish with status \"passed\" summarising the assessment.",
tc.Repo.FullName(), taskPromptBlock(tc.Task),
)
},
OnResult: func(tc *TaskContext, res agentrun.Result) error {
calls := res.Captures["decide"]
if len(calls) != 1 {
return fmt.Errorf("assess stage called the decide tool %d times (want exactly once)", len(calls))
}
var captured struct {
Fit *bool `json:"fit"`
Reasons string `json:"reasons"`
}
if err := json.Unmarshal(calls[0], &captured); err != nil {
return fmt.Errorf("decode feasibility decision: %w", err)
}
if captured.Fit == nil {
return fmt.Errorf("assess stage decision has no boolean fit value")
}
if captured.Reasons == "" {
return fmt.Errorf("assess stage decision has no reasons")
}
tc.decision = &decision{Fit: *captured.Fit, Reasons: captured.Reasons}
if !tc.decision.Fit {
if tc.Task.IsForgeBacked() {
if err := tc.Forge.CloseIssue(context.Background(), tc.Task.Owner, tc.Task.Repo, tc.Task.IssueNumber, ""); err != nil {
return err
}
}
tc.Outcome = Outcome{Status: StatusClosedWontDo, Detail: tc.decision.Reasons}
}
return nil
},
}.Stage(),
AgentStage{
Name: "prd",
Role: "planner",
ReadOnly: true,
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Write a PRD for this accepted feature request on %s.\n\n"+
"%s\n\n<assessment>\n%s\n</assessment>\n\n"+
"Explore the affected code surface, then call finish with status \"passed\" and the "+
"PRD as the summary: problem, proposed solution, files/components affected, "+
"acceptance criteria, explicit non-goals, and estimated diff size. It will be read "+
"by a human deciding whether to green-light implementation.",
tc.Repo.FullName(), taskPromptBlock(tc.Task), tc.decision.Reasons,
)
},
OnResult: func(tc *TaskContext, res agentrun.Result) error {
tc.Task.Plan = res.Summary
return nil
},
}.Stage(),
// Messaging and the Web UI are the decision surfaces, so the issue
// gets a one-way delivery notice (notify) rather than a reply
// channel: the wait is channel-neutral, and the forge issue is not
// a chat log.
{Name: "deliver", Run: func(ctx context.Context, tc *TaskContext) error {
notify(ctx, tc, "feasibility_prd")
// An approval requeues under the workflow recorded here.
tc.Task.Workflow = "implement"
tc.Outcome = Outcome{Status: StatusWaitingHuman, Detail: "PRD delivered, awaiting go/no-go"}
return nil
}},
},
}
}
// decision is the assess stage's structured verdict.
type decision struct {
Fit bool `json:"fit"`
Reasons string `json:"reasons"`
}
// decideCaptureTools gives the assess agent a structured verdict tool. Its
// arguments cross the execution boundary as data and are applied by OnResult.
func decideCaptureTools(*TaskContext) []agentrun.CaptureTool {
params := json.RawMessage(`{
"type": "object",
"properties": {
"fit": {"type": "boolean", "description": "true: fits the project and is worth a PRD. false: close as won't-do."},
"reasons": {"type": "string", "description": "The rationale, written for the human who filed the request."}
},
"required": ["fit", "reasons"]
}`)
return []agentrun.CaptureTool{{
Name: "decide", Description: "Record the feasibility verdict. Call exactly once, before finish.",
Parameters: params, RequiredFields: []string{"fit", "reasons"},
NonEmptyStrings: []string{"reasons"}, BooleanFields: []string{"fit"}, MaxCalls: 1,
}}
}
// notify posts a one-way notice on a forge-backed task's issue and, when
// configured, to the notify webhook.
func notify(ctx context.Context, tc *TaskContext, kind string) {
@@ -173,7 +55,7 @@ func notify(ctx context.Context, tc *TaskContext, kind string) {
// forge-backed task's issue.
func deliveryNotice(tc *TaskContext, kind string) string {
subject := "archie finished a run that needs you"
if kind == "feasibility_prd" {
if kind == "approval" {
subject = "archie's PRD is ready -- awaiting your go/no-go"
}
return fmt.Sprintf("**%s.**\n\n%s\n\n_Decide in chat or on the dashboard._", subject, tc.Task.Plan)
@@ -0,0 +1,50 @@
id: feasibility
steps:
- type: repo.prepare
- id: assess
type: agent.run
settings:
role: planner
read_only: true
mission: |
Assess whether this feature request fits the project {{ task.repository }}.
{{ task.prompt }}
Read the repository's AGENT.md, ROADMAP.md and README (whichever exist) plus enough code to judge scope and architectural fit. Return your result exactly once, then call finish with status "passed" summarising the assessment.
result:
type: object
properties:
fit:
type: boolean
description: "true: fits the project and is worth a PRD. false: close as won't-do."
reasons:
type: string
description: The rationale, written for the human who filed the request.
required: [fit, reasons]
- type: forge.close-issue
when: "!steps.assess.result.fit"
- type: workflow.finish
when: "!steps.assess.result.fit"
settings:
status: declined
detail: "{{ steps.assess.result.reasons }}"
- id: prd
type: agent.run
settings:
role: planner
read_only: true
mission: |
Write a PRD for this accepted feature request on {{ task.repository }}.
{{ task.prompt }}
<assessment>
{{ steps.assess.result.reasons }}
</assessment>
Explore the affected code surface, then call finish with status "passed" and the PRD as the summary: problem, proposed solution, files and components affected, acceptance criteria, explicit non-goals, and estimated diff size. It will be read by a human deciding whether to green-light implementation.
- type: human.approve
settings:
plan: "{{ steps.prd.summary }}"
then: implement
@@ -0,0 +1,42 @@
id: triage
steps:
- type: repo.prepare
- id: classify
type: agent.run
settings:
role: planner
read_only: true
mission: |
Triage this {{ task.kind }} on the repository {{ task.repository }}: decide whether it needs a code change at all, and if so which workflow suits it best.
{{ task.prompt }}
Read only as much as you need to judge this. A title or body that is purely conversational, administrative, or already resolved needs no code change.
If it does need a change, the workflow is a real decision, not a formality. Check whether the repository already has a settled design for what is being asked (a design document, an approved plan, an existing implementation to extend). If it does not, and the request is not a defect, choose feasibility: it writes a design document for a human to approve, which is cheaper than an implementation built on a guess. Choose tdd when there is an observable wrong behaviour a test can reproduce first. Choose implement only when the change is well understood and its shape is already clear.
Return your result exactly once, then call finish with status "passed".
result:
type: object
properties:
needs_code_change:
type: boolean
description: "false: nothing to build, close it. true: route to a workflow that builds something."
workflow:
type: string
enum: [implement, tdd, feasibility]
description: Which workflow fits best, when needs_code_change is true.
reasons:
type: string
description: The rationale, written for the human who filed the request.
required: [needs_code_change, workflow, reasons]
- type: forge.close-issue
when: "!steps.classify.result.needs_code_change"
- type: workflow.finish
when: "!steps.classify.result.needs_code_change"
settings:
detail: "triaged: no code change needed. {{ steps.classify.result.reasons }}"
- type: workflow.handoff
settings:
workflow: "{{ steps.classify.result.workflow }}"
detail: "triaged to {{ steps.classify.result.workflow }}: {{ steps.classify.result.reasons }}"
@@ -63,6 +63,16 @@ steps:
`,
wantErr: `step id "a" is declared twice`,
},
{
name: "when may only read earlier steps",
yaml: `id: w
repository: none
steps:
- {type: workflow.finish, when: "!steps.later.result.fit"}
- {id: later, type: workflow.finish}
`,
wantErr: `when: reference {{ steps.later.result.fit }}: no earlier step has id "later"`,
},
{
name: "on_failure takes park or continue",
yaml: `id: w
-126
View File
@@ -1,126 +0,0 @@
package workflow
import (
"context"
"encoding/json"
"fmt"
"github.com/samcharles93/archie-core/internal/domain/agentrun"
)
// triageWorkflowNames is the set of workflows triage may hand a task to.
// A name outside it is refused, not defaulted -- see Triage's OnResult.
var triageWorkflowNames = map[string]bool{
"implement": true,
"tdd": true,
"feasibility": true,
}
// Triage is a single read-only agent turn that decides whether a task needs a
// code change and, if so, which workflow to run.
func Triage() Workflow {
return Workflow{
Name: "triage",
Stages: []Stage{
StagePrepareWorktree(),
AgentStage{
Name: "classify",
Role: "planner",
ReadOnly: true,
CaptureTools: triageDecideCaptureTools,
Mission: triageMission,
OnResult: func(tc *TaskContext, res agentrun.Result) error {
calls := res.Captures["decide"]
if len(calls) != 1 {
return fmt.Errorf("triage classify stage called the decide tool %d times (want exactly once)", len(calls))
}
var captured struct {
NeedsCodeChange *bool `json:"needs_code_change"`
Workflow string `json:"workflow"`
Reasons string `json:"reasons"`
}
if err := json.Unmarshal(calls[0], &captured); err != nil {
return fmt.Errorf("decode triage decision: %w", err)
}
if captured.NeedsCodeChange == nil {
return fmt.Errorf("triage classify stage decision has no boolean needs_code_change value")
}
if !*captured.NeedsCodeChange {
// OnResult has no ctx of its own (matches
// feasibility.go's identical constraint); Forge
// calls build their own timeout from what they're
// given, same as feasibility.go's CloseIssue call.
if tc.Task.IsForgeBacked() {
if err := tc.Forge.CloseIssue(context.Background(), tc.Task.Owner, tc.Task.Repo, tc.Task.IssueNumber, ""); err != nil {
return err
}
}
tc.Outcome = Outcome{Status: StatusCompleted, Detail: "triaged: no code change needed -- " + captured.Reasons}
return nil
}
// No fallback: an unrecognised workflow is an error.
target := captured.Workflow
if !triageWorkflowNames[target] {
return fmt.Errorf("triage chose workflow %q, which is not one of implement, tdd or feasibility", target)
}
tc.Task.Workflow = target
tc.Outcome = Outcome{
Status: StatusQueued,
Detail: fmt.Sprintf("triaged to %s: %s", target, captured.Reasons),
}
return nil
},
}.Stage(),
},
}
}
// triageDecideCaptureTools gives the classify agent a structured verdict
// tool, mirroring feasibility.go's decideCaptureTools.
func triageDecideCaptureTools(*TaskContext) []agentrun.CaptureTool {
params := json.RawMessage(`{
"type": "object",
"properties": {
"needs_code_change": {"type": "boolean", "description": "false: nothing to build -- close/no-op. true: route to a workflow that builds something."},
"workflow": {"type": "string", "enum": ["implement", "tdd", "feasibility"], "description": "Which workflow fits best, when needs_code_change is true. feasibility: a new capability whose design is not settled, or a request too broad to scope -- it produces a design document for a human to approve before any code is written. tdd: a defect with an observable wrong behaviour that a test can reproduce first. implement: the change is well understood and its shape is already clear. Choose feasibility when no approved design exists and the request is not a defect; do not choose implement merely because nothing else obviously fits. Defaults to implement if omitted or unrecognized."},
"reasons": {"type": "string", "description": "The rationale, written for the human who filed the request."}
},
"required": ["needs_code_change", "reasons"]
}`)
return []agentrun.CaptureTool{{
Name: "decide", Description: "Record the triage verdict. Call exactly once, before finish.",
Parameters: params, RequiredFields: []string{"needs_code_change", "reasons"},
NonEmptyStrings: []string{"reasons"}, BooleanFields: []string{"needs_code_change"},
// Conditional, not flat: a task needing no code change has no
// workflow to name, and forcing one would be a meaningless answer.
RequiredWhenTrue: map[string][]string{"needs_code_change": {"workflow"}},
MaxCalls: 1,
}}
}
// triageMission is the classify stage's prompt. It is a named function so a
// test can assert the selection criteria are actually stated to the model,
// which is the whole of this stage's behaviour.
func triageMission(tc *TaskContext) string {
return fmt.Sprintf(
"Triage this %s on the repository %s: decide whether it needs a code "+
"change at all, and if so which workflow suits it best.\n\n"+
"%s\n\n"+
"Read only as much as you need to judge this -- a title/body that is "+
"purely conversational, administrative, or already resolved needs no code "+
"change.\n\n"+
"If it does need a change, the workflow is a real decision, not a "+
"formality. Check whether the repository already has a settled design "+
"for what is being asked (a design document, an approved plan, an "+
"existing implementation to extend). If it does not, and the request "+
"is not a defect, choose feasibility: it writes a design document for "+
"a human to approve, which is cheaper than an implementation built on "+
"a guess. Choose tdd when there is an observable wrong behaviour a "+
"test can reproduce first. Choose implement only when the change is "+
"well understood and its shape is already clear.\n\n"+
"Then call the decide tool EXACTLY ONCE and afterwards call finish "+
"with status \"passed\".",
taskKind(tc.Task), tc.Repo.FullName(), taskPromptBlock(tc.Task),
)
}
+2 -5
View File
@@ -95,9 +95,8 @@ type TaskContext struct {
// stages.
PRSource PRSource
// prReview is the pr-review workflow's cross-stage scratch state (see
// prreview_stages.go). It is unexported, following the pattern set by
// the feasibility workflow's decision field: pipeline-private state has
// no business being read or set outside its own stages.
// prreview_stages.go). Pipeline-private state has no business being read
// or set outside its own stages.
prReview *prReviewState
Bus *events.Bus // nil-safe via Emit
Log *slog.Logger
@@ -128,8 +127,6 @@ type TaskContext struct {
// ReproProof is the captured failing-test output from a TDD repro
// stage, posted on the PR as evidence the bug was reproduced.
ReproProof string
// decision is the feasibility assess stage's verdict.
decision *decision
// reviewUnit is the remediate workflow's decoded Task.ReviewPayload,
// stashed by its build stage so the commit-push and reply stages that
// follow don't each re-decode the same JSON.
@@ -64,9 +64,17 @@ func (repositorySteps) Name() string { return "repository" }
func (repositorySteps) StepTypes() []workflow.StepType { return workflow.RepoStepTypes() }
// controlSteps provides the step types that route the task: handoff, human
// approval, and forge issue actions.
type controlSteps struct{}
func (controlSteps) Name() string { return "control" }
func (controlSteps) StepTypes() []workflow.StepType { return workflow.ControlStepTypes() }
// Providers returns the step-type providers to register.
func Providers() []workflow.StepTypeProvider {
return []workflow.StepTypeProvider{shippedStages{}, repoHooks{}, eventSteps{}, commandSteps{}, repositorySteps{}}
return []workflow.StepTypeProvider{shippedStages{}, repoHooks{}, eventSteps{}, commandSteps{}, repositorySteps{}, controlSteps{}}
}
// NewManager returns a new manager with Providers registered.