feat(tasks): allow rejecting a task from any non-terminal state

An operator could only reject work that was waiting on a human decision, so a
task sitting in review (PR open) or running had no way to be refused even
when it was clearly dangerous.

- expose reject in taskstate.Actions for every non-terminal state (queued,
  running, waiting_human, parked, pr_open) so both the dashboard and the chat
  tool surface it; terminal states still only expose archive
- make rejectTask transition from the task's actual status to closed_wont_do
  and interrupt running execution first, so nothing keeps working against a
  task being closed out
- keep the distinct stop (recoverable → parked) semantics; reject is the
  terminal escape hatch
- update the lifecycle contract tests to the new intent
This commit is contained in:
sam committed 2026-08-28 00:19:27 +00:00
1 parent 8ef6980fe6
commit 96c82cd4e0
6 files changed
+40 -25

No files matched your search

+2 -2
View File
@@ -121,8 +121,8 @@ func TestChatTaskActorAdapterRefusesDisallowedStateAction(t *testing.T) {
attemptAction: taskstate.ActionApprove,
},
{
name: "cannot reject queued task",
initialStatus: store.StatusQueued,
name: "cannot reject merged task",
initialStatus: store.StatusMerged,
attemptAction: taskstate.ActionReject,
},
}
+3 -1
View File
@@ -361,9 +361,11 @@ func TestStoreTaskControllerStopRunningWithoutRuntime(t *testing.T) {
}
}
// PROpen is deliberately absent: it is not a terminal state, and reject is
// now available there so an operator can refuse work still sitting in review.
// The genuine terminal states must keep refusing cancel.
func TestStoreTaskControllerCancelRejectsTerminalStates(t *testing.T) {
for _, status := range []string{
taskstate.PROpen,
taskstate.Merged,
taskstate.Rejected,
taskstate.Dead,
+12 -7
View File
@@ -72,19 +72,24 @@ func Terminal(status string) bool {
// Actions returns the ordered controls valid for status. Callers receive a
// fresh slice so presentation code cannot mutate the lifecycle table.
//
// Reject is deliberately present in every non-terminal state: an operator can
// refuse work no matter where it currently sits, and the refusal always lands
// in the terminal Declined state. Terminal states are already resolved, so
// they only expose archive.
func Actions(status string) []Action {
var actions []Action
switch status {
case Queued:
actions = []Action{ActionCancel}
actions = []Action{ActionCancel, ActionReject}
case Running:
actions = []Action{ActionStop}
actions = []Action{ActionStop, ActionReject}
case WaitingHuman:
actions = []Action{ActionApprove, ActionReject}
case Parked:
actions = []Action{ActionRetry, ActionAbandon}
actions = []Action{ActionRetry, ActionAbandon, ActionReject}
case PROpen:
actions = []Action{ActionOpenPR, ActionOpenIssue}
actions = []Action{ActionOpenPR, ActionOpenIssue, ActionReject}
case Merged, Rejected, Dead, Declined:
actions = []Action{ActionArchive}
}
@@ -126,9 +131,9 @@ func CheckRetry(status string) error {
// CheckDecline reports whether a task in this status can be declined.
//
// The legacy chat command expresses cancel, stop, reject and abandon as one
// operation. It remains available only where the canonical action table
// exposes one of those controls; unknown, PR-open and terminal states fail
// closed instead of permitting an arbitrary transition.
// operation. Because Reject is now offered in every non-terminal state, that
// command is available everywhere a task is still live; unknown and terminal
// states fail closed instead of permitting an arbitrary transition.
func CheckDecline(status string) error {
for _, action := range Actions(status) {
switch action {
+4 -4
View File
@@ -15,11 +15,11 @@ func TestActionRules(t *testing.T) {
terminal bool
actions []Action
}{
{status: Queued, decline: true, actions: []Action{ActionCancel}},
{status: Running, decline: true, actions: []Action{ActionStop}},
{status: Queued, decline: true, actions: []Action{ActionCancel, ActionReject}},
{status: Running, decline: true, actions: []Action{ActionStop, ActionReject}},
{status: WaitingHuman, approve: true, decline: true, actions: []Action{ActionApprove, ActionReject}},
{status: PROpen, actions: []Action{ActionOpenPR, ActionOpenIssue}},
{status: Parked, retry: true, decline: true, actions: []Action{ActionRetry, ActionAbandon}},
{status: PROpen, decline: true, actions: []Action{ActionOpenPR, ActionOpenIssue, ActionReject}},
{status: Parked, retry: true, decline: true, actions: []Action{ActionRetry, ActionAbandon, ActionReject}},
{status: Merged, terminal: true, actions: []Action{ActionArchive}},
{status: Rejected, terminal: true, actions: []Action{ActionArchive}},
{status: Dead, terminal: true, actions: []Action{ActionArchive}},
+7 -6
View File
@@ -458,13 +458,14 @@ func (s *Server) retireTask(ctx context.Context, task *store.Task, reason string
}
func (s *Server) rejectTask(ctx context.Context, w http.ResponseWriter, task *store.Task) *actionOutcome {
// The dashboard only offers Reject on a waiting_human task, but the rule
// is the shared one so the two surfaces cannot drift apart again.
if err := taskstate.CheckApprove(task.Status); err != nil {
http.Error(w, err.Error(), http.StatusConflict)
return nil
// Reject is available from any non-terminal lifecycle state: work the
// operator refuses belongs in the terminal Declined state regardless of
// where it currently sits. Running work is interrupted first so nothing
// keeps executing against a task that is being closed out.
if task.Status == store.StatusRunning && s.TaskStopper != nil {
s.TaskStopper.CancelTask(task.ID)
}
err := s.Store.Transition(ctx, task.ID, store.StatusWaitingHuman, store.StatusClosedWontDo, "declined from the dashboard")
err := s.Store.Transition(ctx, task.ID, task.Status, store.StatusClosedWontDo, "declined from the dashboard")
if s.storeFailed(w, err) {
return nil
}
+12 -5
View File
@@ -397,11 +397,11 @@ func TestTaskListExposesLifecycleActions(t *testing.T) {
srv := newTestServer(t)
ctx := t.Context()
want := map[string][]string{
store.StatusQueued: {"cancel"},
store.StatusRunning: {"stop"},
store.StatusQueued: {"cancel", "reject"},
store.StatusRunning: {"stop", "reject"},
store.StatusWaitingHuman: {"approve", "reject"},
store.StatusParked: {"retry", "abandon"},
store.StatusPROpen: {"open_pr", "open_issue"},
store.StatusParked: {"retry", "abandon", "reject"},
store.StatusPROpen: {"open_pr", "open_issue", "reject"},
store.StatusMerged: {"archive"},
store.StatusRejected: {"archive"},
store.StatusDead: {"archive"},
@@ -455,6 +455,13 @@ func TestLifecycleSpecificTaskActions(t *testing.T) {
{name: "stop running", from: store.StatusRunning, action: "stop", want: store.StatusParked, stopperResult: true},
{name: "park stale running row", from: store.StatusRunning, action: "stop", want: store.StatusParked},
{name: "abandon parked", from: store.StatusParked, action: "abandon", want: store.StatusClosedWontDo, closesIssue: true},
// Reject is available from every non-terminal state and always lands in
// the terminal Declined state, closing the forge issue.
{name: "reject queued", from: store.StatusQueued, action: "reject", want: store.StatusClosedWontDo, closesIssue: true},
{name: "reject running stops execution", from: store.StatusRunning, action: "reject", want: store.StatusClosedWontDo, closesIssue: true, stopperResult: true},
{name: "reject waiting_human", from: store.StatusWaitingHuman, action: "reject", want: store.StatusClosedWontDo, closesIssue: true},
{name: "reject parked", from: store.StatusParked, action: "reject", want: store.StatusClosedWontDo, closesIssue: true},
{name: "reject pr_open", from: store.StatusPROpen, action: "reject", want: store.StatusClosedWontDo, closesIssue: true},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
@@ -478,7 +485,7 @@ func TestLifecycleSpecificTaskActions(t *testing.T) {
t.Cleanup(bus.Close)
srv.Events = bus
sub := bus.Subscribe(1)
if tc.action == "stop" {
if tc.action == "stop" || (tc.action == "reject" && tc.from == store.StatusRunning) {
setTaskStopper(t, srv, &recordingTaskStopper{result: tc.stopperResult})
}
if w := postAction(t, srv, task.ID, tc.action); w.Code != http.StatusOK {