The dashboard and chat both let an operator approve or refuse work, and they had drifted. Declining from the dashboard left the task closed_wont_do; cancelling the same task from chat left it rejected. Two operators looking at one queue saw different states for the same decision, and "rejected" -- which reconcilePRs also uses for a pull request closed without merging -- stopped meaning one thing. internal/gateway deliberately does not import internal/store, so it kept a hand-synced copy of the status strings with a comment asking future editors to keep them aligned. That is the same defect one level down, and it is how the drift happened. internal/taskstate is a leaf package with no dependencies holding the lifecycle vocabulary and the rules for operator actions. gateway, store and the dashboard all import it, so gateway stays decoupled from store without a copy, and CheckApprove/CheckRetry/CheckDecline have one implementation. Declined is named for what it is -- a human said no -- and stays distinct from Rejected, which is something archie observed. Chat cancel now records Declined. That is the behaviour change: same decision, same state, whichever surface the operator used. Rules were preserved rather than tidied while unifying. A parked task still cannot be declined, which both surfaces already refused, even though "not terminal" would have allowed it -- widening a rule under cover of a refactor is how you ship a change nobody reviewed. The comment says where to change it if that is ever wanted. TestDashboardAndChatAgreeOnTerminalStates drives both real surfaces against one store, so this cannot drift apart again without a red test. Also removes a second rule for the dash-top-standalone class: renderSetup already reconciles it from the data at the top of every call, and a later branch cleared it again. Harmless, but it reads as two sources of truth for one bit of layout state.
95 lines
3.6 KiB
Go
95 lines
3.6 KiB
Go
// Package taskstate owns the task lifecycle vocabulary and the rules for
|
|
// operator-initiated actions on a task.
|
|
//
|
|
// It exists because those rules had two implementations. The dashboard and
|
|
// chat both offer approve and reject, and they had drifted: rejecting from
|
|
// the dashboard left a task ClosedWontDo, cancelling the same task from chat
|
|
// left it Rejected. Two operators looking at the same queue saw different
|
|
// states for the same decision, and Rejected -- which the PR reconciler uses
|
|
// for "the pull request was closed without merging" -- no longer meant one
|
|
// thing.
|
|
//
|
|
// internal/gateway deliberately does not import internal/store, so it kept a
|
|
// hand-synced copy of the status strings with a comment asking future editors
|
|
// to keep them aligned. That is the same defect one level down. This package
|
|
// has no dependencies, so both can import it and the copy can go.
|
|
package taskstate
|
|
|
|
import "fmt"
|
|
|
|
// Task lifecycle statuses. The store persists these strings, so they are
|
|
// part of the on-disk format: renaming one is a migration, not a rename.
|
|
const (
|
|
Queued = "queued"
|
|
Running = "running"
|
|
WaitingHuman = "waiting_human"
|
|
PROpen = "pr_open"
|
|
Merged = "merged"
|
|
Parked = "parked"
|
|
Dead = "dead"
|
|
|
|
// Rejected means the forge closed the pull request without merging it.
|
|
// It is an outcome archie observed, not a decision an operator made --
|
|
// use Declined for that.
|
|
Rejected = "rejected"
|
|
|
|
// Declined means an operator refused the work. Whether they said so from
|
|
// the dashboard or from chat, the task lands here.
|
|
Declined = "closed_wont_do"
|
|
)
|
|
|
|
// Terminal reports whether a status is an end state, from which no further
|
|
// work happens without an operator asking for it.
|
|
func Terminal(status string) bool {
|
|
switch status {
|
|
case Merged, Rejected, Dead, Declined:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// CheckApprove reports whether a task in this status can be approved.
|
|
//
|
|
// Approval releases work that is waiting on a human decision, so it is only
|
|
// meaningful from WaitingHuman. Approving anything else would either restart
|
|
// finished work or race a task that is already running.
|
|
func CheckApprove(status string) error {
|
|
if status != WaitingHuman {
|
|
return fmt.Errorf("task is %s, not awaiting approval", status)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CheckRetry reports whether a task in this status can be retried.
|
|
//
|
|
// Only a parked task can be retried: parking is how archie says "this failed
|
|
// in a way a human might fix". A dead task has spent its retries and needs
|
|
// the cap raised or the work re-filed, not another attempt.
|
|
func CheckRetry(status string) error {
|
|
if status != Parked {
|
|
return fmt.Errorf("task is %s, not parked", status)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CheckDecline reports whether a task in this status can be declined.
|
|
//
|
|
// Work that is still progressing can be declined -- including a running task,
|
|
// which is the case most worth being able to stop. Callers that can interrupt
|
|
// running work should do so before recording the state, or the task may write
|
|
// its own outcome afterwards and win.
|
|
//
|
|
// Parked is refused along with the terminal states. A parked task is not
|
|
// progressing, so there is nothing to stop; it is retried, or left. Both the
|
|
// dashboard and chat already behaved this way and this package preserves it
|
|
// rather than widening the rule while unifying it. If declining a parked task
|
|
// is ever wanted, change it here and both paths get it at once -- which is
|
|
// the point.
|
|
func CheckDecline(status string) error {
|
|
if Terminal(status) || status == Parked {
|
|
return fmt.Errorf("task is already %s", status)
|
|
}
|
|
return nil
|
|
}
|