Add wl reject command and restrict accept/reject to poster-only

Accept and reject now require the caller to be the original poster.
Accept retains the existing self-accept guard (completer != acceptor).
Reject reverts in_review → claimed by deleting the completion record,
allowing the worker to re-submit via wl done.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: julianknutsen

cmd/wl/cmd_accept.go

@@ -133,6 +133,10 @@ func acceptCompletion(store commons.WLCommonsStore, wantedID, rigHandle string,
 		return nil, fmt.Errorf("wanted item %s is not in_review (status: %s)", wantedID, item.Status)
 	}
 
+	if item.PostedBy != rigHandle {
+		return nil, fmt.Errorf("only the poster can accept (posted by %q)", item.PostedBy)
+	}
+
 	completion, err := store.QueryCompletion(wantedID)
 	if err != nil {
 		return nil, fmt.Errorf("querying completion: %w", err)

cmd/wl/cmd_accept_test.go

@@ -67,7 +67,7 @@ func TestValidateAcceptInputs(t *testing.T) {
 func TestAcceptCompletion_Success(t *testing.T) {
 	t.Parallel()
 	store := newFakeWLCommonsStore()
-	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug"})
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "reviewer-rig"})
 	_ = store.ClaimWanted("w-abc", "worker-rig")
 	_ = store.SubmitCompletion("c-test123", "w-abc", "worker-rig", "https://github.com/pr/1")
 
@@ -131,7 +131,7 @@ func TestAcceptCompletion_NotFound(t *testing.T) {
 func TestAcceptCompletion_SelfAccept(t *testing.T) {
 	t.Parallel()
 	store := newFakeWLCommonsStore()
-	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug"})
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "my-rig"})
 	_ = store.ClaimWanted("w-abc", "my-rig")
 	_ = store.SubmitCompletion("c-test123", "w-abc", "my-rig", "evidence")
 
@@ -144,10 +144,26 @@ func TestAcceptCompletion_SelfAccept(t *testing.T) {
 	}
 }
 
+func TestAcceptCompletion_NotPoster(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "poster-rig"})
+	_ = store.ClaimWanted("w-abc", "worker-rig")
+	_ = store.SubmitCompletion("c-test123", "w-abc", "worker-rig", "evidence")
+
+	_, err := acceptCompletion(store, "w-abc", "other-rig", 4, 3, "leaf", nil, "")
+	if err == nil {
+		t.Fatal("acceptCompletion() expected error for non-poster")
+	}
+	if !strings.Contains(err.Error(), "only the poster can accept") {
+		t.Errorf("error = %q, want to contain 'only the poster can accept'", err.Error())
+	}
+}
+
 func TestAcceptCompletion_QueryCompletionError(t *testing.T) {
 	t.Parallel()
 	store := newFakeWLCommonsStore()
-	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", Status: "in_review"})
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", Status: "in_review", PostedBy: "reviewer-rig"})
 	store.QueryCompletionErr = fmt.Errorf("completion query error")
 
 	_, err := acceptCompletion(store, "w-abc", "reviewer-rig", 4, 3, "leaf", nil, "")
@@ -162,7 +178,7 @@ func TestAcceptCompletion_QueryCompletionError(t *testing.T) {
 func TestAcceptCompletion_AcceptCompletionError(t *testing.T) {
 	t.Parallel()
 	store := newFakeWLCommonsStore()
-	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug"})
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "reviewer-rig"})
 	_ = store.ClaimWanted("w-abc", "worker-rig")
 	_ = store.SubmitCompletion("c-test123", "w-abc", "worker-rig", "evidence")
 	store.AcceptCompletionErr = fmt.Errorf("accept store error")

cmd/wl/cmd_fake_test.go

@@ -23,6 +23,7 @@ type fakeWLCommonsStore struct {
 	QueryCompletionErr   error
 	QueryStampErr        error
 	AcceptCompletionErr  error
+	RejectCompletionErr  error
 	UpdateWantedErr      error
 	DeleteWantedErr      error
 }
@@ -192,6 +193,26 @@ func (f *fakeWLCommonsStore) AcceptCompletion(wantedID, _, rigHandle string, sta
 	return nil
 }
 
+func (f *fakeWLCommonsStore) RejectCompletion(wantedID, _, _ string) error {
+	if f.RejectCompletionErr != nil {
+		return f.RejectCompletionErr
+	}
+
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	item, ok := f.items[wantedID]
+	if !ok {
+		return fmt.Errorf("wanted item %q not found", wantedID)
+	}
+	if item.Status != "in_review" {
+		return fmt.Errorf("wanted item %q is not in_review (status: %s)", wantedID, item.Status)
+	}
+	item.Status = "claimed"
+	delete(f.completions, wantedID)
+	return nil
+}
+
 func (f *fakeWLCommonsStore) UpdateWanted(wantedID string, fields *commons.WantedUpdate) error {
 	if f.UpdateWantedErr != nil {
 		return f.UpdateWantedErr

cmd/wl/cmd_reject.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+	"github.com/steveyegge/wasteland/internal/commons"
+	"github.com/steveyegge/wasteland/internal/style"
+)
+
+func newRejectCmd(stdout, stderr io.Writer) *cobra.Command {
+	var (
+		reason string
+		noPush bool
+	)
+
+	cmd := &cobra.Command{
+		Use:   "reject <wanted-id>",
+		Short: "Reject a completed wanted item back to claimed",
+		Long: `Reject a completed wanted item, reverting it from 'in_review' to 'claimed'.
+
+The item must be in 'in_review' status. Only the poster can reject.
+The completion record is deleted so the claimer can re-submit.
+
+In wild-west mode the commit is auto-pushed to upstream and origin.
+Use --no-push to skip pushing (offline work).
+
+Examples:
+  wl reject w-abc123
+  wl reject w-abc123 --reason "tests failing"`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runReject(cmd, stdout, stderr, args[0], reason, noPush)
+		},
+	}
+
+	cmd.Flags().StringVar(&reason, "reason", "", "Reason for rejection (included in commit message)")
+	cmd.Flags().BoolVar(&noPush, "no-push", false, "Skip pushing to remotes (offline work)")
+
+	return cmd
+}
+
+func runReject(cmd *cobra.Command, stdout, _ io.Writer, wantedID, reason string, noPush bool) error {
+	wlCfg, err := resolveWasteland(cmd)
+	if err != nil {
+		return fmt.Errorf("loading wasteland config: %w", err)
+	}
+	rigHandle := wlCfg.RigHandle
+
+	store := commons.NewWLCommons(wlCfg.LocalDir)
+
+	if err := rejectCompletion(store, wantedID, rigHandle, reason); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(stdout, "%s Rejected %s\n", style.Bold.Render("✓"), wantedID)
+	if reason != "" {
+		fmt.Fprintf(stdout, "  Reason: %s\n", reason)
+	}
+	fmt.Fprintf(stdout, "  Status: claimed\n")
+
+	if !noPush {
+		_ = commons.PushWithSync(wlCfg.LocalDir, stdout)
+	}
+
+	return nil
+}
+
+// rejectCompletion contains the testable business logic for rejecting a completion.
+func rejectCompletion(store commons.WLCommonsStore, wantedID, rigHandle, reason string) error {
+	item, err := store.QueryWanted(wantedID)
+	if err != nil {
+		return fmt.Errorf("querying wanted item: %w", err)
+	}
+
+	if item.Status != "in_review" {
+		return fmt.Errorf("wanted item %s is not in_review (status: %s)", wantedID, item.Status)
+	}
+
+	if item.PostedBy != rigHandle {
+		return fmt.Errorf("only the poster can reject (posted by %q)", item.PostedBy)
+	}
+
+	if err := store.RejectCompletion(wantedID, rigHandle, reason); err != nil {
+		return fmt.Errorf("rejecting completion: %w", err)
+	}
+
+	return nil
+}

cmd/wl/cmd_reject_test.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/steveyegge/wasteland/internal/commons"
+)
+
+func TestRejectCompletion_Success(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "poster-rig"})
+	_ = store.ClaimWanted("w-abc", "worker-rig")
+	_ = store.SubmitCompletion("c-test123", "w-abc", "worker-rig", "https://github.com/pr/1")
+
+	err := rejectCompletion(store, "w-abc", "poster-rig", "tests failing")
+	if err != nil {
+		t.Fatalf("rejectCompletion() error: %v", err)
+	}
+
+	item, _ := store.QueryWanted("w-abc")
+	if item.Status != "claimed" {
+		t.Errorf("Status = %q, want %q", item.Status, "claimed")
+	}
+
+	// Completion should be deleted.
+	_, err = store.QueryCompletion("w-abc")
+	if err == nil {
+		t.Error("expected completion to be deleted after reject")
+	}
+}
+
+func TestRejectCompletion_NotInReview(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "poster-rig"})
+
+	err := rejectCompletion(store, "w-abc", "poster-rig", "")
+	if err == nil {
+		t.Fatal("rejectCompletion() expected error for non-in_review item")
+	}
+	if !strings.Contains(err.Error(), "not in_review") {
+		t.Errorf("error = %q, want to contain 'not in_review'", err.Error())
+	}
+}
+
+func TestRejectCompletion_NotFound(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+
+	err := rejectCompletion(store, "w-nonexistent", "poster-rig", "")
+	if err == nil {
+		t.Fatal("rejectCompletion() expected error for missing item")
+	}
+}
+
+func TestRejectCompletion_NotPoster(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "poster-rig"})
+	_ = store.ClaimWanted("w-abc", "worker-rig")
+	_ = store.SubmitCompletion("c-test123", "w-abc", "worker-rig", "evidence")
+
+	err := rejectCompletion(store, "w-abc", "other-rig", "bad work")
+	if err == nil {
+		t.Fatal("rejectCompletion() expected error for non-poster")
+	}
+	if !strings.Contains(err.Error(), "only the poster can reject") {
+		t.Errorf("error = %q, want to contain 'only the poster can reject'", err.Error())
+	}
+}
+
+func TestRejectCompletion_RejectError(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "poster-rig"})
+	_ = store.ClaimWanted("w-abc", "worker-rig")
+	_ = store.SubmitCompletion("c-test123", "w-abc", "worker-rig", "evidence")
+	store.RejectCompletionErr = fmt.Errorf("reject store error")
+
+	err := rejectCompletion(store, "w-abc", "poster-rig", "reason")
+	if err == nil {
+		t.Fatal("rejectCompletion() expected error when RejectCompletion fails")
+	}
+	if !strings.Contains(err.Error(), "reject store error") {
+		t.Errorf("error = %q, want to contain 'reject store error'", err.Error())
+	}
+}

cmd/wl/main.go

@@ -68,6 +68,7 @@ func newRootCmd(stdout, stderr io.Writer) *cobra.Command {
 		newClaimCmd(stdout, stderr),
 		newDoneCmd(stdout, stderr),
 		newAcceptCmd(stdout, stderr),
+		newRejectCmd(stdout, stderr),
 		newUpdateCmd(stdout, stderr),
 		newDeleteCmd(stdout, stderr),
 		newBrowseCmd(stdout, stderr),

cmd/wl/main_test.go

@@ -28,7 +28,7 @@ func TestSubcommandRegistration(t *testing.T) {
 	var stdout, stderr bytes.Buffer
 	root := newRootCmd(&stdout, &stderr)
 
-	expected := []string{"join", "post", "claim", "done", "accept", "update", "delete", "browse", "status", "sync", "leave", "list", "version"}
+	expected := []string{"join", "post", "claim", "done", "accept", "reject", "update", "delete", "browse", "status", "sync", "leave", "list", "version"}
 	for _, name := range expected {
 		found := false
 		for _, c := range root.Commands() {

cmd/wl/testdata/errors.txtar

@@ -82,6 +82,14 @@ stderr 'invalid severity'
 ! exec wl accept w-abc --quality 3
 stderr 'not joined'
 
+# reject with no args.
+! exec wl reject
+stderr 'accepts 1 arg'
+
+# reject not joined.
+! exec wl reject w-abc
+stderr 'not joined'
+
 # update with no args.
 ! exec wl update
 stderr 'accepts 1 arg'

internal/commons/commons.go

@@ -25,6 +25,7 @@ type WLCommonsStore interface {
 	QueryCompletion(wantedID string) (*CompletionRecord, error)
 	QueryStamp(stampID string) (*Stamp, error)
 	AcceptCompletion(wantedID, completionID, rigHandle string, stamp *Stamp) error
+	RejectCompletion(wantedID, rigHandle, reason string) error
 	UpdateWanted(wantedID string, fields *WantedUpdate) error
 	DeleteWanted(wantedID string) error
 }
@@ -81,6 +82,11 @@ func (w *WLCommons) UpdateWanted(wantedID string, fields *WantedUpdate) error {
 	return UpdateWanted(w.dbDir, wantedID, fields)
 }
 
+// RejectCompletion reverts a wanted item from in_review to claimed.
+func (w *WLCommons) RejectCompletion(wantedID, rigHandle, reason string) error {
+	return RejectCompletion(w.dbDir, wantedID, rigHandle, reason)
+}
+
 // DeleteWanted soft-deletes a wanted item by setting status=withdrawn.
 func (w *WLCommons) DeleteWanted(wantedID string) error {
 	return DeleteWanted(w.dbDir, wantedID)
@@ -277,7 +283,7 @@ CALL DOLT_COMMIT('-m', 'wl done: %s');
 // QueryWanted fetches a wanted item by ID. Returns an error if not found.
 // dbDir is the actual database directory.
 func QueryWanted(dbDir, wantedID string) (*WantedItem, error) {
-	query := fmt.Sprintf(`SELECT id, title, status, COALESCE(claimed_by, '') as claimed_by FROM wanted WHERE id='%s';`,
+	query := fmt.Sprintf(`SELECT id, title, status, COALESCE(claimed_by, '') as claimed_by, COALESCE(posted_by, '') as posted_by FROM wanted WHERE id='%s';`,
 		EscapeSQL(wantedID))
 
 	output, err := doltSQLQuery(dbDir, query)
@@ -296,6 +302,7 @@ func QueryWanted(dbDir, wantedID string) (*WantedItem, error) {
 		Title:     row["title"],
 		Status:    row["status"],
 		ClaimedBy: row["claimed_by"],
+		PostedBy:  row["posted_by"],
 	}
 	return item, nil
 }
@@ -583,3 +590,28 @@ CALL DOLT_COMMIT('-m', 'wl delete: %s');
 	}
 	return fmt.Errorf("delete failed: %w", err)
 }
+
+// RejectCompletion reverts a wanted item from in_review to claimed and deletes
+// the completion record. The reason is embedded in the dolt commit message.
+// dbDir is the actual database directory.
+func RejectCompletion(dbDir, wantedID, _, reason string) error {
+	commitMsg := fmt.Sprintf("wl reject: %s", EscapeSQL(wantedID))
+	if reason != "" {
+		commitMsg += " — " + EscapeSQL(reason)
+	}
+
+	script := fmt.Sprintf(`DELETE FROM completions WHERE wanted_id='%s';
+UPDATE wanted SET status='claimed', updated_at=NOW() WHERE id='%s' AND status='in_review';
+CALL DOLT_ADD('-A');
+CALL DOLT_COMMIT('-m', '%s');
+`, EscapeSQL(wantedID), EscapeSQL(wantedID), commitMsg)
+
+	err := doltSQLScript(dbDir, script)
+	if err == nil {
+		return nil
+	}
+	if isNothingToCommit(err) {
+		return fmt.Errorf("wanted item %q is not in_review or does not exist", wantedID)
+	}
+	return fmt.Errorf("reject failed: %w", err)
+}

internal/commons/commons_fake_test.go

@@ -116,6 +116,10 @@ func (f *fakeWLCommonsStore) AcceptCompletion(_, _, _ string, _ *Stamp) error {
 	return fmt.Errorf("not implemented in commons fake")
 }
 
+func (f *fakeWLCommonsStore) RejectCompletion(_, _, _ string) error {
+	return fmt.Errorf("not implemented in commons fake")
+}
+
 func (f *fakeWLCommonsStore) UpdateWanted(_ string, _ *WantedUpdate) error {
 	return fmt.Errorf("not implemented in commons fake")
 }