relay-flow 0.1.0-alpha.0

package/internal/acli/acli.go

@@ -0,0 +1,229 @@
+// Package acli wraps the Atlassian `acli` CLI. Every call is real — no
+// dry-run mode: acli/Jira calls always execute (only orca CLI calls
+// support dry-run).
+package acli
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"os/exec"
+	"strings"
+)
+
+type Client struct{}
+
+func New() *Client {
+	return &Client{}
+}
+
+// rawSearchResult matches acli search's minimal JSON shape: only `key`.
+type rawSearchResult struct {
+	Key string `json:"key"`
+}
+
+// rawTicket matches acli view's JSON shape: `key` is top-level, other
+// fields live under `fields`.
+type rawTicket struct {
+	Key    string `json:"key"`
+	Fields struct {
+		Summary string `json:"summary"`
+		Status  struct {
+			Name string `json:"name"`
+		} `json:"status"`
+		Components []struct {
+			Name string `json:"name"`
+		} `json:"components"`
+		IssueType struct {
+			Name string `json:"name"`
+		} `json:"issuetype"`
+		Description json.RawMessage `json:"description"`
+		Parent      struct {
+			Key string `json:"key"`
+		} `json:"parent"`
+		Labels []string `json:"labels"`
+	} `json:"fields"`
+}
+
+type Ticket struct {
+	Key         string
+	Summary     string
+	Description string
+	Status      string
+	IssueType   string
+	// Component resolves to an Orca repo by matching repo displayName.
+	Component string
+	// ParentKey is the Jira parent ticket's key (native subtask parent
+	// link), if any. Subtasks reuse their parent's worktree/base branch
+	// instead of branching from main.
+	ParentKey string
+	// Labels are the ticket's Jira labels, e.g. "baseBranch:foo" or the
+	// "orca-workflow:<name>" claim label.
+	Labels []string
+}
+
+// LabelValue returns the value portion of a "prefix:value" label on the
+// ticket, if present, e.g. LabelValue("baseBranch") -> "foo" for label
+// "baseBranch:foo".
+func (t Ticket) LabelValue(prefix string) (string, bool) {
+	for _, l := range t.Labels {
+		if strings.HasPrefix(l, prefix+":") {
+			return strings.TrimPrefix(l, prefix+":"), true
+		}
+	}
+	return "", false
+}
+
+// adfText extracts plain text from a Jira ADF (Atlassian Document Format)
+// description by concatenating every "text" node.
+func adfText(raw json.RawMessage) string {
+	var node struct {
+		Text    string            `json:"text"`
+		Content []json.RawMessage `json:"content"`
+	}
+	if err := json.Unmarshal(raw, &node); err != nil {
+		return ""
+	}
+	var parts []string
+	if node.Text != "" {
+		parts = append(parts, node.Text)
+	}
+	for _, c := range node.Content {
+		if t := adfText(c); t != "" {
+			parts = append(parts, t)
+		}
+	}
+	return strings.Join(parts, " ")
+}
+
+// Search runs `acli jira workitem search --jql <jql> --fields key --json`
+// to get matching ticket keys only, then fetches full details for each via
+// `view`. In dry-run mode, no subprocess is executed; caller should treat
+// result as empty.
+func (c *Client) Search(jql string) ([]Ticket, error) {
+	// No --fields flag: default output always includes top-level "key",
+	// which is all we need here. Full details are fetched per-ticket via view.
+	cmd := exec.Command("acli", "jira", "workitem", "search",
+		"--jql", jql,
+		"--json")
+	var stderr strings.Builder
+	cmd.Stderr = &stderr
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("acli search: %w: %s", err, strings.TrimSpace(stderr.String()))
+	}
+	var raw []rawSearchResult
+	if err := json.Unmarshal(out, &raw); err != nil {
+		return nil, fmt.Errorf("acli search: parse json: %w", err)
+	}
+	tickets := make([]Ticket, 0, len(raw))
+	for _, r := range raw {
+		t, err := c.View(r.Key)
+		if err != nil {
+			log.Printf("acli search: could not fetch details for %s: %v", r.Key, err)
+			continue
+		}
+		tickets = append(tickets, t)
+	}
+	return tickets, nil
+}
+
+// ValidateAssignee checks that the given user (display name or accountId)
+// exists by running `assignee = "<user>"` as a JQL fragment — Jira's JQL
+// parser rejects unknown users with a hard error, like unknown statuses.
+func (c *Client) ValidateAssignee(assignee string) error {
+	jql := fmt.Sprintf(`assignee = %q`, assignee)
+	out, err := exec.Command("acli", "jira", "workitem", "search",
+		"--jql", jql, "--json").CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("assignee %q is not a valid Jira user: %s", assignee, strings.TrimSpace(string(out)))
+	}
+	return nil
+}
+
+// ValidateStatus checks that status is a real Jira status in the given
+// project by running `status = "<status>"` as a JQL fragment — Jira's JQL
+// parser rejects unknown status values with a hard error, so a typo in
+// the workflow YAML ("DO Done") fails here instead of silently never
+// matching at runtime. Returns nil if valid, error otherwise.
+func (c *Client) ValidateStatus(projectKey, status string) error {
+	jql := fmt.Sprintf(`project = %s AND status = %q`, projectKey, status)
+	out, err := exec.Command("acli", "jira", "workitem", "search",
+		"--jql", jql, "--json").CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("status %q is not valid in project %s: %s", status, projectKey, strings.TrimSpace(string(out)))
+	}
+	return nil
+}
+
+// view fetches full ticket details via
+// `acli jira workitem view <key> --fields status,assignee,reporter,components --json`.
+func (c *Client) View(key string) (Ticket, error) {
+	out, err := exec.Command("acli", "jira", "workitem", "view", key,
+		"--fields", "summary,description,status,components,issuetype,parent,labels",
+		"--json").Output()
+	if err != nil {
+		return Ticket{}, fmt.Errorf("acli view %s: %w", key, err)
+	}
+	var r rawTicket
+	if err := json.Unmarshal(out, &r); err != nil {
+		return Ticket{}, fmt.Errorf("acli view %s: parse json: %w", key, err)
+	}
+	var t Ticket
+	t.Key = r.Key
+	t.Summary = r.Fields.Summary
+	t.Description = adfText(r.Fields.Description)
+	t.Status = r.Fields.Status.Name
+	t.IssueType = r.Fields.IssueType.Name
+	if len(r.Fields.Components) > 0 {
+		t.Component = r.Fields.Components[0].Name
+	}
+	t.ParentKey = r.Fields.Parent.Key
+	t.Labels = r.Fields.Labels
+	return t, nil
+}
+
+// AddLabel adds label to the ticket's existing labels (acli's --labels
+// flag replaces the set, so the caller/View result must be merged in).
+func (c *Client) AddLabel(key string, existing []string, label string) error {
+	for _, l := range existing {
+		if l == label {
+			return nil // already present
+		}
+	}
+	all := append(append([]string{}, existing...), label)
+	return runAcli("jira", "workitem", "edit", "--key", key, "--labels", strings.Join(all, ","), "--yes", "--json")
+}
+
+func (c *Client) Transition(key, status string) error {
+	return runAcli("jira", "workitem", "transition", "--key", key, "--status", status, "--yes", "--json")
+}
+
+func (c *Client) Comment(key, body string) error {
+	return runAcli("jira", "workitem", "comment", "create", "--key", key, "--body", body, "--json")
+}
+
+func runAcli(args ...string) error {
+	out, err := exec.Command("acli", args...).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("acli %v: %w: %s", args, err, string(out))
+	}
+	// acli exits 0 even when the operation fails server-side — the JSON
+	// envelope carries per-item results with status FAILURE.
+	var env struct {
+		Results []struct {
+			Status  string `json:"status"`
+			Message string `json:"message"`
+			ID      string `json:"id"`
+		} `json:"results"`
+		SuccessCount int `json:"successCount"`
+	}
+	if jsonErr := json.Unmarshal(out, &env); jsonErr == nil && env.Results != nil {
+		for _, r := range env.Results {
+			if !strings.EqualFold(r.Status, "SUCCESS") {
+				return fmt.Errorf("acli %v: %s: %s", args, r.ID, r.Message)
+			}
+		}
+	}
+	return nil
+}

package/internal/config/demo_test.go

@@ -0,0 +1,17 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestDemoWorkflowYAML(t *testing.T) {
+	b, err := os.ReadFile(filepath.Join("..", "..", "..", ".workflow", "workflow.yaml"))
+	if err != nil {
+		t.Skip("demo yaml not present")
+	}
+	if _, err := Parse("demo", b); err != nil {
+		t.Fatalf("demo .workflow/workflow.yaml must validate: %v", err)
+	}
+}

package/internal/config/machine.go

@@ -0,0 +1,71 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+// MachineConfig is the per-machine, uncommitted config at
+// ~/.relay-flow/config.yaml. It holds settings that are personal to
+// whoever runs the server on this machine — never committed to a repo,
+// unlike workflow YAMLs which the whole team shares.
+type MachineConfig struct {
+	// Assignee is this machine user's Jira identity (display name or
+	// accountId). In distributed mode (workflow yaml without
+	// assigneeIsAgent), every workflow JQL gets `AND assignee = "<this>"`,
+	// so a teammate's server never touches your tickets and vice versa.
+	// Probe-validated against Jira at submit time.
+	Assignee string `yaml:"assignee"`
+}
+
+// MachineConfigPath returns ~/.relay-flow/config.yaml.
+func MachineConfigPath() (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(home, ".relay-flow", "config.yaml"), nil
+}
+
+// Save writes the machine config, creating the dir. Assignee is required.
+func (m *MachineConfig) Save() error {
+	if strings.TrimSpace(m.Assignee) == "" {
+		return fmt.Errorf("assignee must not be empty")
+	}
+	p, err := MachineConfigPath()
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+		return err
+	}
+	b, err := yaml.Marshal(m)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(p, b, 0o600) // personal identity: owner-only
+}
+
+// LoadMachineConfig reads ~/.relay-flow/config.yaml.
+func LoadMachineConfig() (*MachineConfig, error) {
+	p, err := MachineConfigPath()
+	if err != nil {
+		return nil, err
+	}
+	b, err := os.ReadFile(p)
+	if err != nil {
+		return nil, fmt.Errorf("machine config %s not found — run `relay-flow init --assignee \"<your Jira name>\"` first", p)
+	}
+	var m MachineConfig
+	if err := yaml.Unmarshal(b, &m); err != nil {
+		return nil, fmt.Errorf("parse machine config %s: %w", p, err)
+	}
+	if strings.TrimSpace(m.Assignee) == "" {
+		return nil, fmt.Errorf("machine config %s: assignee must not be empty", p)
+	}
+	return &m, nil
+}

package/internal/config/schema.go

@@ -0,0 +1,193 @@
+// Package config loads and validates relay-flow workflow YAML files.
+package config
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+// StringList accepts either a scalar or a list of strings in YAML and
+// normalizes both forms to []string, so a single value can be written as
+// `closeOn: done` instead of `closeOn: [done]`.
+type StringList []string
+
+func (s *StringList) UnmarshalYAML(value *yaml.Node) error {
+	if value.Kind == yaml.ScalarNode {
+		if value.Tag != "!!str" {
+			return fmt.Errorf("expected string or list of strings")
+		}
+		*s = []string{value.Value}
+		return nil
+	}
+	var values []string
+	if err := value.Decode(&values); err != nil {
+		return err
+	}
+	*s = values
+	return nil
+}
+
+// Has reports membership (case-insensitive).
+func (s StringList) Has(name string) bool {
+	for _, value := range s {
+		if strings.EqualFold(value, name) {
+			return true
+		}
+	}
+	return false
+}
+
+// AdapterSpec selects a pluggable adapter (tasks or runner) by type name.
+// Config is opaque to core: the adapter's factory unmarshals it strictly.
+type AdapterSpec struct {
+	Type   string         `yaml:"type"`
+	Config map[string]any `yaml:"config"`
+}
+
+// Node is one square on the board: a tracker state (When), the agent that
+// works tickets in that state, and the outcome edges to other nodes.
+type Node struct {
+	// Agent is the OpenCode agent serving this node. Empty = terminal node
+	// (no agent runs; must be listed in closeOn).
+	Agent string `yaml:"agent"`
+	// When is the tracker state string that routes tickets to this node
+	// (poll-time condition). Unique across the file, case-insensitive.
+	When string `yaml:"when"`
+	// OnSuccess / OnFailure are the outcome edges: node names the ticket
+	// moves to when its agent reports success/failure. Self-loops allowed.
+	OnSuccess string `yaml:"onSuccess"`
+	OnFailure string `yaml:"onFailure"`
+	// NudgePrompt is sent into the ticket's existing terminal when it
+	// lands back on this node (bounce). Supports {{ticket}} and {{node}}
+	// placeholders; defaults to DefaultNudgePrompt.
+	NudgePrompt string `yaml:"nudgePrompt"`
+}
+
+// DefaultNudgePrompt is used when a node declares no nudgePrompt.
+const DefaultNudgePrompt = "Ticket {{ticket}} is at node '{{node}}' again. Read the tracker's latest feedback, continue your work, and end your reply with the STATUS/SUMMARY block as before."
+
+// Config is one workflow file: name, adapters, nodes, closeOn.
+type Config struct {
+	// Name is the workflow's identity: server registry key, claim-label
+	// component (`wf:<name>`), CLI argument. CamelCase, unique per server.
+	Name                string `yaml:"name"`
+	PollIntervalSeconds int    `yaml:"pollIntervalSeconds"`
+	// Tasks selects the ticket-system adapter (jira, beads, ...).
+	Tasks AdapterSpec `yaml:"tasks"`
+	// Runner selects the execution backend (orca, tmux, ...).
+	Runner AdapterSpec `yaml:"runner"`
+	// CloseOn lists terminal nodes: tickets reaching them get their
+	// terminals closed. Nodes here must have no agent.
+	CloseOn StringList `yaml:"closeOn"`
+	// Nodes maps node names to their definitions. The graph: each agent
+	// node's edges point at other nodes; terminal nodes have no agent.
+	Nodes map[string]Node `yaml:"nodes"`
+}
+
+var namePattern = regexp.MustCompile(`^[a-z][A-Za-z0-9]*$`)
+
+// NodeForState returns the node whose When matches tracker state
+// (case-insensitive), or "" if none.
+func (c *Config) NodeForState(state string) string {
+	for name, n := range c.Nodes {
+		if strings.EqualFold(n.When, state) {
+			return name
+		}
+	}
+	return ""
+}
+
+// Validate cross-checks the graph so broken configs fail at submit, before
+// any goroutine starts.
+func (c *Config) Validate() error {
+	if !namePattern.MatchString(c.Name) {
+		return fmt.Errorf("name %q must be camelCase with no spaces", c.Name)
+	}
+	if strings.TrimSpace(c.Tasks.Type) == "" {
+		return fmt.Errorf("tasks.type must not be empty")
+	}
+	if strings.TrimSpace(c.Runner.Type) == "" {
+		return fmt.Errorf("runner.type must not be empty")
+	}
+	if len(c.Nodes) == 0 {
+		return fmt.Errorf("nodes must not be empty")
+	}
+	if len(c.CloseOn) == 0 {
+		return fmt.Errorf("closeOn must not be empty (terminal nodes that close ticket terminals)")
+	}
+	for _, co := range c.CloseOn {
+		n, ok := c.Nodes[co]
+		if !ok {
+			return fmt.Errorf("closeOn: unknown node %q", co)
+		}
+		if n.Agent != "" {
+			return fmt.Errorf("closeOn: node %q has an agent; closeOn nodes must be terminal (no agent)", co)
+		}
+	}
+	seenWhen := map[string]string{}
+	for name, n := range c.Nodes {
+		if strings.TrimSpace(n.When) == "" {
+			return fmt.Errorf("nodes[%s].when must not be empty", name)
+		}
+		key := strings.ToLower(strings.TrimSpace(n.When))
+		if other, dup := seenWhen[key]; dup {
+			return fmt.Errorf("nodes[%s].when %q duplicates nodes[%s].when", name, n.When, other)
+		}
+		seenWhen[key] = name
+		if n.Agent == "" {
+			// Agentless = human gate / pause node: no automation, no
+			// edges required. Whether it also closes terminals is
+			// controlled solely by closeOn.
+			continue
+		}
+		if n.OnSuccess == "" {
+			return fmt.Errorf("nodes[%s].onSuccess must not be empty (agent nodes need both outcome edges)", name)
+		}
+		if n.OnFailure == "" {
+			return fmt.Errorf("nodes[%s].onFailure must not be empty (agent nodes need both outcome edges)", name)
+		}
+		if _, ok := c.Nodes[n.OnSuccess]; !ok {
+			return fmt.Errorf("nodes[%s].onSuccess: unknown node %q", name, n.OnSuccess)
+		}
+		if _, ok := c.Nodes[n.OnFailure]; !ok {
+			return fmt.Errorf("nodes[%s].onFailure: unknown node %q", name, n.OnFailure)
+		}
+		if n.NudgePrompt == "" {
+			n.NudgePrompt = DefaultNudgePrompt
+			c.Nodes[name] = n
+		}
+	}
+	return nil
+}
+
+// Parse decodes and validates workflow YAML bytes. name is only used in
+// error messages.
+func Parse(name string, b []byte) (*Config, error) {
+	var c Config
+	dec := yaml.NewDecoder(bytes.NewReader(b))
+	dec.KnownFields(true)
+	if err := dec.Decode(&c); err != nil {
+		return nil, fmt.Errorf("parse config %s: %w", name, err)
+	}
+	if c.PollIntervalSeconds <= 0 {
+		c.PollIntervalSeconds = 15
+	}
+	if err := c.Validate(); err != nil {
+		return nil, fmt.Errorf("config %s: %w", name, err)
+	}
+	return &c, nil
+}
+
+// Load reads and parses a workflow YAML file.
+func Load(path string) (*Config, error) {
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("read config %s: %w", path, err)
+	}
+	return Parse(path, b)
+}

package/internal/config/schema_test.go

@@ -0,0 +1,162 @@
+package config
+
+import (
+	"strings"
+	"testing"
+)
+
+const validYAML = `
+name: xyzTaskFlow
+pollIntervalSeconds: 15
+tasks:
+  type: jira
+  config:
+    query: project = xyz
+    issueTypes: [Task]
+runner:
+  type: orca
+closeOn: [done]
+nodes:
+  coding:
+    agent: build
+    when: "In Progress"
+    onSuccess: reviewing
+    onFailure: coding
+  reviewing:
+    agent: build
+    when: "In Review"
+    onSuccess: done
+    onFailure: coding
+  done:
+    when: "Done"
+`
+
+func TestParseValid(t *testing.T) {
+	cfg, err := Parse("test", []byte(validYAML))
+	if err != nil {
+		t.Fatalf("valid config rejected: %v", err)
+	}
+	if cfg.Name != "xyzTaskFlow" {
+		t.Errorf("name = %q", cfg.Name)
+	}
+	if cfg.PollIntervalSeconds != 15 {
+		t.Errorf("pollIntervalSeconds = %d", cfg.PollIntervalSeconds)
+	}
+	if cfg.Tasks.Type != "jira" || cfg.Runner.Type != "orca" {
+		t.Errorf("tasks=%q runner=%q", cfg.Tasks.Type, cfg.Runner.Type)
+	}
+	if cfg.Tasks.Config["query"] != "project = xyz" {
+		t.Errorf("opaque tasks config not preserved: %v", cfg.Tasks.Config)
+	}
+	if len(cfg.Nodes) != 3 {
+		t.Fatalf("nodes = %v", cfg.Nodes)
+	}
+	n := cfg.Nodes["coding"]
+	if n.Agent != "build" || n.When != "In Progress" || n.OnSuccess != "reviewing" || n.OnFailure != "coding" {
+		t.Errorf("coding node = %+v", n)
+	}
+	if cfg.Nodes["done"].Agent != "" {
+		t.Errorf("done should have no agent")
+	}
+	if len(cfg.CloseOn) != 1 || cfg.CloseOn[0] != "done" {
+		t.Errorf("closeOn = %v", cfg.CloseOn)
+	}
+}
+
+func TestParseDefaultPollInterval(t *testing.T) {
+	yaml := strings.Replace(validYAML, "pollIntervalSeconds: 15\n", "", 1)
+	cfg, err := Parse("test", []byte(yaml))
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if cfg.PollIntervalSeconds != 15 {
+		t.Errorf("default pollIntervalSeconds = %d, want 15", cfg.PollIntervalSeconds)
+	}
+}
+
+func TestCloseOnScalar(t *testing.T) {
+	yaml := strings.Replace(validYAML, "closeOn: [done]", "closeOn: done", 1)
+	cfg, err := Parse("test", []byte(yaml))
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if len(cfg.CloseOn) != 1 || cfg.CloseOn[0] != "done" {
+		t.Errorf("closeOn = %v", cfg.CloseOn)
+	}
+}
+
+func TestParseErrors(t *testing.T) {
+	rep := func(old, new string) string { return strings.Replace(validYAML, old, new, 1) }
+	cases := []struct {
+		name string
+		yaml string
+		want string
+	}{
+		{"empty name", rep("name: xyzTaskFlow", "name: \"\""), "name"},
+		{"bad name", rep("name: xyzTaskFlow", "name: My Flow"), "camelCase"},
+		{"unknown top field", validYAML + "bogus: 1\n", "field bogus"},
+		{"unknown node field", rep("onFailure: coding\n  reviewing:", "onFailure: coding\n    bogus: 1\n  reviewing:"), "field bogus"},
+		{"no tasks type", rep("type: jira", "type: \"\""), "tasks.type"},
+		{"no runner type", rep("type: orca", "type: \"\""), "runner.type"},
+		{"empty closeOn", rep("closeOn: [done]", "closeOn: []"), "closeOn"},
+		{"closeOn unknown node", rep("closeOn: [done]", "closeOn: [nope]"), "closeOn"},
+		{"closeOn node has agent", rep("closeOn: [done]", "closeOn: [coding]"), "closeOn"},
+
+		{"edge target missing", rep("onSuccess: reviewing", "onSuccess: nowhere"), "onSuccess"},
+		{"agent node missing onSuccess", rep("    onSuccess: reviewing\n", ""), "onSuccess"},
+		{"agent node missing onFailure", rep("    onFailure: coding\n  reviewing", "  reviewing"), "onFailure"},
+		{"dup when", rep("when: \"In Review\"", "when: \"In Progress\""), "duplicat"},
+		{"empty when", rep("when: \"In Progress\"", "when: \"\""), "when"},
+		{"no nodes", rep("nodes:\n", "nodes: {}\n#") + "", "nodes"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			yaml := tc.yaml
+			if tc.name == "no nodes" {
+				// strip the entire nodes block
+				yaml = validYAML[:strings.Index(validYAML, "nodes:")]
+			}
+			_, err := Parse("test", []byte(yaml))
+			if err == nil {
+				t.Fatalf("expected error containing %q, got nil", tc.want)
+			}
+			if !strings.Contains(strings.ToLower(err.Error()), strings.ToLower(tc.want)) {
+				t.Fatalf("error %q missing %q", err, tc.want)
+			}
+		})
+	}
+}
+
+func TestSelfLoopEdgeAllowed(t *testing.T) {
+	// coding.onFailure == coding: already in validYAML, must parse.
+	if _, err := Parse("test", []byte(validYAML)); err != nil {
+		t.Fatalf("%v", err)
+	}
+}
+
+func TestNodeForState(t *testing.T) {
+	cfg, err := Parse("test", []byte(validYAML))
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	if got := cfg.NodeForState("in progress"); got != "coding" {
+		t.Errorf("NodeForState(in progress) = %q, want coding", got)
+	}
+	if got := cfg.NodeForState("Done"); got != "done" {
+		t.Errorf("NodeForState(Done) = %q, want done", got)
+	}
+	if got := cfg.NodeForState("Backlog"); got != "" {
+		t.Errorf("NodeForState(Backlog) = %q, want empty", got)
+	}
+}
+
+func TestDefaultNudgePrompt(t *testing.T) {
+	cfg, err := Parse("test", []byte(validYAML))
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+	p := cfg.Nodes["coding"].NudgePrompt
+	if !strings.Contains(p, "{{ticket}}") || !strings.Contains(p, "{{node}}") {
+		t.Errorf("default nudgePrompt missing templates: %q", p)
+	}
+}