relay-flow 0.0.1 → 0.2.0-alpha

package/internal/runner/orca/README.md

@@ -1,64 +0,0 @@
-# runner/orca — Orca adapter
-
-Implements `runner.Runner` over the Orca CLI: each ticket gets an Orca
-worktree; each node visit gets a fresh terminal titled
-`<key>:<agent>:<node>` running opencode.
-
-## Config (runner.config)
-
-Empty — the adapter takes no YAML fields. Repo binding arrives at runtime:
-the server resolves the submitter's repo and calls `WithRepo(repoID,
-displayName, dryRun)` after construction.
-
-## Behavior
-
-- **Spawn** — verifies the opencode agent exists (`opencode agent list`),
-  ensures the ticket's worktree (creates off the repo's main worktree branch;
-  reuses an existing ticket branch if one exists; verifies the exact name
-  landed because Orca silently auto-suffixes on collisions), then creates the
-  terminal running `opencode --agent <agent> --prompt <p>` with `RELAY_FLOW_*` env
-  markers (`RELAY_FLOW_WORKFLOW/TICKET/NODE/AGENT`) so the plugin can report back.
-- **Find** — exact-title match on the ticket's terminal list. A missing
-  worktree (`selector_not_found`) means "no session", not an error — that's
-  what lets bounce respawn after a crash.
-- **Nudge** — waits for `tui-idle` (typed text mid-turn corrupts the input
-  box), then sends the prompt flattened to one line (keystroke simulation
-  submits on newline).
-- **Close** — closes every terminal titled `<key>:*`; scaffolding tabs
-  ("Terminal 1", "Setup") survive.
-
-## Writing a new runner (tmux, ...)
-
-1. Create `internal/runner/<name>/` with:
-   ```go
-   func init() {
-       runner.Register("<name>", runner.Factory{
-           UnmarshalConfig: unmarshalConfig, // strict-decode runner.config (empty is fine)
-           New: func(cfg any) (runner.Runner, error) { ... },
-       })
-   }
-   ```
-2. Implement the interface:
-   ```go
-   type Runner interface {
-       Spawn(t tasks.Ticket, node, agent, prompt string, env map[string]string) error
-       Find(t tasks.Ticket, node string) (runner.Session, bool, error)
-       Nudge(s runner.Session, prompt string) error
-       Close(t tasks.Ticket) error
-   }
-   ```
-   Contract highlights:
-   - **Titles are identity**: sessions must be findable later by
-     `<key>:<agent>:<node>` — bounce depends on it.
-   - **env must reach the agent process** — the report plugin keys off
-     `RELAY_FLOW_WORKFLOW/TICKET/NODE/AGENT`.
-   - **Find must distinguish "gone" from "error"** — a missing session is a
-     normal bounce case (respawn), not a failure.
-   - The runner must still launch **opencode** inside whatever session it
-     creates — the report plugin is opencode-specific. (tmux example:
-     `tmux new-session -s key-agent-node` + `send-keys "RELAY_FLOW_*=... opencode --agent ..." Enter`.)
-3. If your runner needs the repo binding, implement
-   `WithRepo(repoID, repoName string, dryRun bool)` — the server calls it via
-   interface assertion when present.
-4. Import for side effects in `internal/server/server.go`.
-5. Tests with a fake CLI seam (see `orca_test.go` / the `orcaCLI` interface).

package/internal/runner/runner_test.go

@@ -1,64 +0,0 @@
-package runner
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/rajpopat27/relay-flow/internal/tasks"
-)
-
-type fakeRunner struct {
-	spawned []string
-	nudged  []string
-	closed  []string
-	found   map[string]Session
-}
-
-func (f *fakeRunner) Spawn(t tasks.Ticket, node, agent, prompt string, env map[string]string) error {
-	f.spawned = append(f.spawned, t.Key+":"+node+":"+agent+":"+env["RELAY_WORKFLOW"])
-	return nil
-}
-func (f *fakeRunner) Find(t tasks.Ticket, node string) (Session, bool, error) {
-	s, ok := f.found[t.Key+":"+node]
-	return s, ok, nil
-}
-func (f *fakeRunner) Nudge(s Session, prompt string) error {
-	f.nudged = append(f.nudged, s.Title+":"+prompt)
-	return nil
-}
-func (f *fakeRunner) Close(t tasks.Ticket) error {
-	f.closed = append(f.closed, t.Key)
-	return nil
-}
-
-func TestRegistryNew(t *testing.T) {
-	fake := &fakeRunner{}
-	Register("fakerun", Factory{
-		UnmarshalConfig: func(m map[string]any) (any, error) { return m, nil },
-		New: func(cfg any) (Runner, error) { return fake, nil },
-	})
-
-	r, err := New("fakerun", nil)
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	tk := tasks.Ticket{Key: "XYZ-2"}
-	r.Spawn(tk, "coding", "build", "go", map[string]string{"RELAY_WORKFLOW": "w"})
-	if len(fake.spawned) != 1 || fake.spawned[0] != "XYZ-2:coding:build:w" {
-		t.Errorf("spawned = %v", fake.spawned)
-	}
-
-	if _, err := New("nope", nil); err == nil || !strings.Contains(err.Error(), "unknown runner type") {
-		t.Errorf("unknown runner error = %v", err)
-	}
-}
-
-func TestDuplicateRegisterPanics(t *testing.T) {
-	defer func() {
-		if recover() == nil {
-			t.Fatal("expected panic on duplicate registration")
-		}
-	}()
-	Register("duprun", Factory{})
-	Register("duprun", Factory{})
-}

package/internal/server/server_test.go

@@ -1,195 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"fmt"
-	"net"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/rajpopat27/relay-flow/internal/config"
-	"github.com/rajpopat27/relay-flow/internal/runner"
-	"github.com/rajpopat27/relay-flow/internal/tasks"
-)
-
-const goodYAML = `
-name: testFlow
-tasks:
-  type: faketasks
-  config: {}
-runner:
-  type: fakerunner
-closeOn: [done]
-nodes:
-  coding:
-    agent: build
-    when: "In Progress"
-    onSuccess: done
-    onFailure: coding
-  done:
-    when: "Done"
-`
-
-// registerFakes installs test adapters (unique names per process via init
-// in server package tests would collide across files — register once here).
-var fakesOnce = registerFakes()
-
-var (
-	lastFakeTasks  *fakeTasks
-	lastFakeRunner *fakeRunner
-)
-
-func registerFakes() bool {
-	tasks.Register("faketasks", tasks.Factory{
-		UnmarshalConfig: func(m map[string]any) (any, error) { return m, nil },
-		New: func(cfg any, wfName string, nodes map[string]config.Node, assignee, repoName string) (tasks.Tasks, error) {
-			lastFakeTasks = &fakeTasks{}
-			return lastFakeTasks, nil
-		},
-	})
-	runner.Register("fakerunner", runner.Factory{
-		UnmarshalConfig: func(m map[string]any) (any, error) { return m, nil },
-		New: func(cfg any) (runner.Runner, error) {
-			lastFakeRunner = &fakeRunner{}
-			return lastFakeRunner, nil
-		},
-	})
-	return true
-}
-
-type fakeTasks struct{ reports []string }
-
-func (f *fakeTasks) List() ([]tasks.Ticket, error) { return nil, nil }
-func (f *fakeTasks) Claim(t tasks.Ticket) error    { return nil }
-func (f *fakeTasks) Report(t tasks.Ticket, outcome, targetNode, summary string) error {
-	f.reports = append(f.reports, fmt.Sprintf("%s:%s:%s:%s", t.Key, outcome, targetNode, summary))
-	return nil
-}
-
-type fakeRunner struct{}
-
-func (f *fakeRunner) Spawn(t tasks.Ticket, node, agent, prompt string, env map[string]string) error {
-	return nil
-}
-func (f *fakeRunner) Find(t tasks.Ticket, node string) (runner.Session, bool, error) {
-	return runner.Session{}, false, nil
-}
-func (f *fakeRunner) Nudge(s runner.Session, prompt string) error { return nil }
-func (f *fakeRunner) Close(t tasks.Ticket) error                  { return nil }
-
-func testServer(t *testing.T) *Server {
-	t.Helper()
-	_ = fakesOnce
-	s := New(true, Deps{
-		ResolveRepo:    func(path string) (string, string, error) { return "repo-1", "repo:xyz", nil },
-		ValidateConfig: func(y []byte) ([]string, error) { return nil, nil },
-	})
-	return s
-}
-
-func post(t *testing.T, s *Server, path string, body string) (int, map[string]any) {
-	t.Helper()
-	req := httptest.NewRequest("POST", path, strings.NewReader(body))
-	rec := httptest.NewRecorder()
-	s.handler().ServeHTTP(rec, req)
-	var out map[string]any
-	json.NewDecoder(rec.Body).Decode(&out)
-	return rec.Code, out
-}
-
-func TestSubmitStartsWorkflow(t *testing.T) {
-	s := testServer(t)
-	code, out := post(t, s, "/submit", `{"repoPath":"/x","yaml":`+jsonStr(goodYAML)+`}`)
-	if code != 200 || out["ok"] != true {
-		t.Fatalf("code=%d out=%v", code, out)
-	}
-	if s.entries["testFlow"] == nil {
-		t.Fatal("entry not registered")
-	}
-	if lastFakeTasks == nil || lastFakeRunner == nil {
-		t.Fatal("adapters not constructed")
-	}
-	// Duplicate name → 409.
-	code, _ = post(t, s, "/submit", `{"repoPath":"/x","yaml":`+jsonStr(goodYAML)+`}`)
-	if code != 409 {
-		t.Errorf("dup submit code=%d, want 409", code)
-	}
-	s.Shutdown()
-}
-
-func TestSubmitRejectsBadYAML(t *testing.T) {
-	s := testServer(t)
-	defer s.Shutdown()
-	code, _ := post(t, s, "/submit", `{"repoPath":"/x","yaml":"name: \"\""}`)
-	if code != 400 {
-		t.Errorf("code=%d", code)
-	}
-}
-
-func TestSubmitRejectsInvalidStatuses(t *testing.T) {
-	s := New(true, Deps{
-		ResolveRepo:    func(path string) (string, string, error) { return "r", "n", nil },
-		ValidateConfig: func(y []byte) ([]string, error) { return []string{"DO Done"}, nil },
-	})
-	defer s.Shutdown()
-	code, out := post(t, s, "/submit", `{"repoPath":"/x","yaml":`+jsonStr(goodYAML)+`}`)
-	if code != 400 || !strings.Contains(fmt.Sprint(out["error"]), "DO Done") {
-		t.Errorf("code=%d out=%v", code, out)
-	}
-}
-
-func TestReportSuccessTransitions(t *testing.T) {
-	s := testServer(t)
-	post(t, s, "/submit", `{"repoPath":"/x","yaml":`+jsonStr(goodYAML)+`}`)
-	code, out := post(t, s, "/report",
-		`{"workflow":"testFlow","ticket":"XYZ-1","node":"coding","outcome":"success","summary":"did it"}`)
-	s.Shutdown()
-	if code != 200 || out["action"] != "transitioned" {
-		t.Fatalf("code=%d out=%v", code, out)
-	}
-	if len(lastFakeTasks.reports) != 1 || lastFakeTasks.reports[0] != "XYZ-1:success:done:did it" {
-		t.Errorf("reports = %v", lastFakeTasks.reports)
-	}
-}
-
-func TestReportSelfLoopActionCommented(t *testing.T) {
-	s := testServer(t)
-	post(t, s, "/submit", `{"repoPath":"/x","yaml":`+jsonStr(goodYAML)+`}`)
-	code, out := post(t, s, "/report",
-		`{"workflow":"testFlow","ticket":"XYZ-1","node":"coding","outcome":"failure","summary":"broke"}`)
-	s.Shutdown()
-	if code != 200 || out["action"] != "commented" {
-		t.Fatalf("self-loop must be commented: code=%d out=%v", code, out)
-	}
-	if lastFakeTasks.reports[0] != "XYZ-1:failure:coding:broke" {
-		t.Errorf("reports = %v", lastFakeTasks.reports)
-	}
-}
-
-func TestReportValidation(t *testing.T) {
-	s := testServer(t)
-	post(t, s, "/submit", `{"repoPath":"/x","yaml":`+jsonStr(goodYAML)+`}`)
-	defer s.Shutdown()
-	cases := []struct{ name, body string }{
-		{"bad outcome", `{"workflow":"testFlow","ticket":"XYZ-1","node":"coding","outcome":"done","summary":"x"}`},
-		{"unknown node", `{"workflow":"testFlow","ticket":"XYZ-1","node":"nope","outcome":"success","summary":"x"}`},
-		{"unknown workflow", `{"workflow":"nope","ticket":"XYZ-1","node":"coding","outcome":"success","summary":"x"}`},
-		{"missing fields", `{"workflow":"testFlow"}`},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			code, _ := post(t, s, "/report", tc.body)
-			if code != 400 && code != 404 {
-				t.Errorf("code=%d", code)
-			}
-		})
-	}
-}
-
-func jsonStr(s string) string {
-	b, _ := json.Marshal(s)
-	return string(b)
-}
-
-var _ = net.Dial // keep net import if unused later

package/internal/tasks/jira/README.md

@@ -1,69 +0,0 @@
-# tasks/jira — Jira adapter
-
-Implements `tasks.Tasks` over the [acli](https://github.com/acli) CLI. Jira
-statuses are node states (`when`); claim labels `wf:<workflow>` are Jira
-labels.
-
-## Config (tasks.config)
-
-| Field | Required | Meaning |
-|---|---|---|
-| `query` | yes | JQL fragment, e.g. `project = ABCD`. Must not contain `issuetype`, `assignee`, or `ORDER BY` — the adapter appends those. |
-| `issueTypes` | yes | Scalar or list, e.g. `[Task, Story]`. Rendered as `AND issuetype IN (...)`. |
-| `assigneeIsAgent` | no | Centralized mode: no assignee clause (org server owns the queue). Default false → `AND assignee = "<machine config>"` is appended. |
-
-Built JQL: `(query) AND issuetype IN (...) AND component = "<repo displayName>" [AND assignee = "..."] ORDER BY updated`.
-The repo displayName (resolved by the server from the submitter's cwd) scopes
-the poll to one repo's tickets.
-
-## Behavior
-
-- **List** — one search per poll; maps each ticket's status → node via `when`
-  (unmapped → `Node: ""`, daemon skips); first `wf:*` label → `ClaimedBy`.
-- **Claim** — adds `wf:<name>` label (labels are never removed; they're the
-  cross-restart mutex).
-- **Report** — transitions to the target node's `when` status + posts the
-  summary comment (`[wf] KEY (agent: x, node: y) reported outcome → target`).
-  Self-loop (target status == current) → comment only; acli FAILURE envelopes
-  (exit-0 failures) are detected and returned as errors.
-
-## Submit-time validation
-
-`ProjectKeyFromQuery` + `ValidateStates` probe every `when` status against the
-project — Jira's JQL parser rejects unknown statuses, so typos fail at submit
-instead of silently matching nothing.
-
-## Writing a new tasks adapter (beads, Linear, GitHub, ...)
-
-1. Create `internal/tasks/<name>/` with:
-   ```go
-   func init() {
-       tasks.Register("<name>", tasks.Factory{
-           UnmarshalConfig: unmarshalConfig, // strict-decode tasks.config into your struct
-           New: func(cfg any, wfName string, nodes map[string]config.Node, assignee, repoName string) (tasks.Tasks, error) {
-               // build your adapter; use nodes[..].When as the tracker-state map,
-               // wfName for claim labels, assignee/repoName if your tracker scopes by them
-           },
-       })
-   }
-   ```
-2. Implement the interface:
-   ```go
-   type Tasks interface {
-       List() ([]tasks.Ticket, error)                       // Node + ClaimedBy filled
-       Claim(t tasks.Ticket) error                          // attach wf:<name> marker
-       Report(t tasks.Ticket, outcome, targetNode, summary string) error
-   }
-   ```
-   `Ticket{Key, Summary, Node, ClaimedBy}` — you fill `Node` by reverse-mapping
-   the ticket's tracker state through `nodes[*].When`, and `ClaimedBy` from
-   your tracker's equivalent of claim markers (labels, assignments, ...).
-3. Strictly validate your `tasks.config` in `UnmarshalConfig` (unknown fields
-   must error — core can't see inside).
-4. Import your package for side effects (`_ "relay-flow/internal/tasks/<name>"`)
-   in `internal/server/server.go`, next to the jira import.
-5. Table-driven tests with a fake for your tracker's client seam (see
-   `jira_test.go` and the `aclier` interface for the pattern).
-
-External adapters (out of tree): fork the repo, add your package + import —
-the registry is deliberately in-process (no .so loading, YAGNI).

package/internal/tasks/jira/component_test.go

@@ -1,16 +0,0 @@
-package jira
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestJQLIncludesComponent(t *testing.T) {
-	j, err := newJira(JiraConfig{Query: "project = XYZ", IssueTypes: []string{"Task"}}, "wf", testNodes, "Jane Doe", "xyz-repo", nil)
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if !strings.Contains(j.jql, `component = "xyz-repo"`) {
-		t.Errorf("JQL missing component filter: %q", j.jql)
-	}
-}

package/internal/tasks/jira/decode.go

@@ -1,24 +0,0 @@
-package jira
-
-import (
-	"bytes"
-	"fmt"
-
-	"gopkg.in/yaml.v3"
-)
-
-// strictDecode re-marshals the opaque config map and decodes it into v
-// with KnownFields(true), so unknown YAML keys in tasks.config are
-// rejected just like top-level ones.
-func strictDecode(m map[string]any, v any) error {
-	if m == nil {
-		m = map[string]any{}
-	}
-	b, err := yaml.Marshal(m)
-	if err != nil {
-		return fmt.Errorf("re-marshal config: %w", err)
-	}
-	dec := yaml.NewDecoder(bytes.NewReader(b))
-	dec.KnownFields(true)
-	return dec.Decode(v)
-}

package/internal/tasks/jira/jira.go

@@ -1,231 +0,0 @@
-// Package jira is the built-in Tasks adapter for Jira. It talks to Jira
-// via the acli CLI and knows nothing about runners, terminals, or agents.
-// States are Jira status names; claims are Jira labels (wf:<workflow>).
-package jira
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-
-	"github.com/rajpopat27/relay-flow/internal/acli"
-	"github.com/rajpopat27/relay-flow/internal/config"
-	"github.com/rajpopat27/relay-flow/internal/tasks"
-)
-
-func init() {
-	tasks.Register("jira", tasks.Factory{
-		UnmarshalConfig: unmarshalConfig,
-		New: func(cfg any, wfName string, nodes map[string]config.Node, assignee, repoName string) (tasks.Tasks, error) {
-			c, ok := cfg.(JiraConfig)
-			if !ok {
-				return nil, fmt.Errorf("internal: jira factory received %T", cfg)
-			}
-			if repoName == "" {
-				return nil, fmt.Errorf("jira adapter requires a repo name (used as the JQL component filter)")
-			}
-			return newJira(c, wfName, nodes, assignee, repoName, nil)
-		},
-	})
-}
-
-// JiraConfig is the strictly-unmarshalled tasks.config for type jira.
-type JiraConfig struct {
-	// Query is a JQL fragment (no issuetype / assignee / ORDER BY — those
-	// are appended by the adapter or rejected).
-	Query string `yaml:"query"`
-	// IssueTypes restricts the workflow to these Jira issue types.
-	IssueTypes []string `yaml:"issueTypes"`
-	// AssigneeIsAgent marks centralized mode (org server owns the queue,
-	// tickets assigned upstream to bot accounts): no assignee clause.
-	AssigneeIsAgent bool `yaml:"assigneeIsAgent"`
-}
-
-var (
-	issueTypeRe = regexp.MustCompile(`(?i)\bissuetype\b`)
-	assigneeRe  = regexp.MustCompile(`(?i)\bassignee\b`)
-)
-
-func unmarshalConfig(m map[string]any) (any, error) {
-	var c JiraConfig
-	if err := strictDecode(m, &c); err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(c.Query) == "" {
-		return nil, fmt.Errorf("query must not be empty")
-	}
-	if strings.Contains(strings.ToUpper(c.Query), "ORDER BY") {
-		return nil, fmt.Errorf("query must not contain ORDER BY (always ordered by updated)")
-	}
-	if issueTypeRe.MatchString(c.Query) {
-		return nil, fmt.Errorf("query must not contain issuetype; use the issueTypes field")
-	}
-	if assigneeRe.MatchString(c.Query) {
-		return nil, fmt.Errorf("query must not contain assignee; identity comes from machine config or assigneeIsAgent")
-	}
-	if len(c.IssueTypes) == 0 {
-		return nil, fmt.Errorf("issueTypes must not be empty")
-	}
-	for _, it := range c.IssueTypes {
-		if strings.TrimSpace(it) == "" {
-			return nil, fmt.Errorf("issueTypes must not contain empty values")
-		}
-	}
-	return c, nil
-}
-
-// aclier is the seam to Jira. *acli.Client satisfies it; tests fake it.
-type aclier interface {
-	Search(jql string) ([]acli.Ticket, error)
-	View(key string) (acli.Ticket, error)
-	AddLabel(key string, existing []string, label string) error
-	Transition(key, status string) error
-	Comment(key, body string) error
-}
-
-type jiraTasks struct {
-	cfg        JiraConfig
-	wfName     string
-	nodes      map[string]config.Node
-	assignee   string
-	repoComponent string
-	jql        string
-	ac         aclier
-}
-
-// newJira builds the adapter. repoComponent is the Jira component name
-// (the Orca repo displayName); empty in unit tests → clause omitted.
-// ac nil → real acli client.
-func newJira(cfg JiraConfig, wfName string, nodes map[string]config.Node, assignee, repoComponent string, ac aclier) (*jiraTasks, error) {
-	if ac == nil {
-		ac = acli.New()
-	}
-	j := &jiraTasks{cfg: cfg, wfName: wfName, nodes: nodes, assignee: assignee, repoComponent: repoComponent, ac: ac}
-	j.jql = j.buildJQL()
-	return j, nil
-}
-
-func (j *jiraTasks) buildJQL() string {
-	quoted := make([]string, 0, len(j.cfg.IssueTypes))
-	for _, it := range j.cfg.IssueTypes {
-		quoted = append(quoted, fmt.Sprintf("%q", it))
-	}
-	q := fmt.Sprintf("(%s) AND issuetype IN (%s)", j.cfg.Query, strings.Join(quoted, ", "))
-	if j.repoComponent != "" {
-		q += fmt.Sprintf(" AND component = %q", j.repoComponent)
-	}
-	// Assignee comes from the machine config (per-person, uncommitted),
-	// never the shared workflow YAML. Centralized mode skips the clause.
-	if j.assignee != "" && !j.cfg.AssigneeIsAgent {
-		q += fmt.Sprintf(" AND assignee = %q", j.assignee)
-	}
-	return q + " ORDER BY updated"
-}
-
-func claimLabel(wfName string) string { return "wf:" + wfName }
-
-// List runs the workflow's one JQL query and maps each ticket's Jira
-// status back to a node via the `when` values ("" = unmapped). ClaimedBy
-// is read off the wf:* labels.
-func (j *jiraTasks) List() ([]tasks.Ticket, error) {
-	found, err := j.ac.Search(j.jql)
-	if err != nil {
-		return nil, err
-	}
-	out := make([]tasks.Ticket, 0, len(found))
-	for _, t := range found {
-		tk := tasks.Ticket{Key: t.Key, Summary: t.Summary}
-		for name, n := range j.nodes {
-			if strings.EqualFold(n.When, t.Status) {
-				tk.Node = name
-				break
-			}
-		}
-		for _, l := range t.Labels {
-			if strings.HasPrefix(l, "wf:") {
-				tk.ClaimedBy = strings.TrimPrefix(l, "wf:")
-				break
-			}
-		}
-		out = append(out, tk)
-	}
-	return out, nil
-}
-
-// Claim attaches this workflow's claim label. Labels are never removed:
-// they are the cross-restart mutex.
-func (j *jiraTasks) Claim(t tasks.Ticket) error {
-	cur, err := j.ac.View(t.Key)
-	if err != nil {
-		return fmt.Errorf("claim %s: view: %w", t.Key, err)
-	}
-	return j.ac.AddLabel(t.Key, cur.Labels, claimLabel(j.wfName))
-}
-
-// Report transitions the ticket to the target node's Jira status and
-// posts the summary as a comment. Self-loop (target status == current
-// status) → comment only (Jira has no self-transitions).
-func (j *jiraTasks) Report(t tasks.Ticket, outcome, targetNode, summary string) error {
-	target, ok := j.nodes[targetNode]
-	if !ok {
-		return fmt.Errorf("unknown node %q", targetNode)
-	}
-	cur, err := j.ac.View(t.Key)
-	if err != nil {
-		return fmt.Errorf("view %s: %w", t.Key, err)
-	}
-	agent := j.nodes[t.Node].Agent
-	body := fmt.Sprintf("[%s] %s (agent: %s, node: %s) reported %s → %s\n\n%s", j.wfName, t.Key, agent, t.Node, outcome, targetNode, summary)
-	if strings.EqualFold(cur.Status, target.When) {
-		return j.ac.Comment(t.Key, body)
-	}
-	if err := j.ac.Transition(t.Key, target.When); err != nil {
-		return fmt.Errorf("transition %s → %q: %w", t.Key, target.When, err)
-	}
-	return j.ac.Comment(t.Key, body)
-}
-
-// ProjectKeyFromQuery extracts the project key from a JQL fragment (used
-// by submit-time status validation).
-func ProjectKeyFromQuery(query string) (string, error) {
-	re := regexp.MustCompile(`(?i)\bproject\s*=\s*("?[A-Za-z][A-Za-z0-9]*"?)`)
-	m := re.FindStringSubmatch(query)
-	if m == nil {
-		return "", fmt.Errorf("could not find 'project = <KEY>' in query %q; it is required for status validation", query)
-	}
-	return strings.Trim(m[1], `"`), nil
-}
-
-// UnmarshalConfigForValidation exposes the strict config decode for
-// submit-time validation (server needs the query/assigneeIsAgent fields).
-func UnmarshalConfigForValidation(m map[string]any) (JiraConfig, error) {
-	c, err := unmarshalConfig(m)
-	if err != nil {
-		return JiraConfig{}, err
-	}
-	return c.(JiraConfig), nil
-}
-
-// StatusValidator is the seam ValidateStates uses. *acli.Client fits.
-type StatusValidator interface {
-	ValidateStatus(projectKey, status string) error
-}
-
-// ValidateStates probes every node's `when` status against the Jira
-// project; Jira's JQL parser rejects unknown statuses with a hard error,
-// so a typo fails at submit instead of silently matching zero tickets.
-func ValidateStates(v StatusValidator, nodes map[string]config.Node, projectKey string) ([]string, error) {
-	seen := map[string]bool{}
-	var bad []string
-	for _, n := range nodes {
-		key := strings.ToLower(strings.TrimSpace(n.When))
-		if key == "" || seen[key] {
-			continue
-		}
-		seen[key] = true
-		if err := v.ValidateStatus(projectKey, n.When); err != nil {
-			bad = append(bad, n.When)
-		}
-	}
-	return bad, nil
-}