Add wl unclaim command to release claimed items back to open

Allows claimer or poster to revert claimed → open, clearing claimed_by.
Includes store layer, unit tests, testscript error cases, and integration tests.

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

Author: julianknutsen

cmd/wl/cmd_fake_test.go

@@ -17,6 +17,7 @@ type fakeWLCommonsStore struct {
 	// Error injection fields
 	InsertWantedErr      error
 	ClaimWantedErr       error
+	UnclaimWantedErr     error
 	SubmitCompletionErr  error
 	QueryWantedErr       error
 	QueryWantedDetailErr error
@@ -82,6 +83,26 @@ func (f *fakeWLCommonsStore) ClaimWanted(wantedID, rigHandle string) error {
 	return nil
 }
 
+func (f *fakeWLCommonsStore) UnclaimWanted(wantedID string) error {
+	if f.UnclaimWantedErr != nil {
+		return f.UnclaimWantedErr
+	}
+
+	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 != "claimed" {
+		return fmt.Errorf("wanted item %q is not claimed (status: %s)", wantedID, item.Status)
+	}
+	item.Status = "open"
+	item.ClaimedBy = ""
+	return nil
+}
+
 func (f *fakeWLCommonsStore) SubmitCompletion(completionID, wantedID, rigHandle, evidence string) error {
 	if f.SubmitCompletionErr != nil {
 		return f.SubmitCompletionErr

cmd/wl/cmd_unclaim.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+	"github.com/steveyegge/wasteland/internal/commons"
+	"github.com/steveyegge/wasteland/internal/style"
+)
+
+func newUnclaimCmd(stdout, stderr io.Writer) *cobra.Command {
+	var noPush bool
+
+	cmd := &cobra.Command{
+		Use:   "unclaim <wanted-id>",
+		Short: "Release a claimed wanted item back to open",
+		Long: `Release a claimed wanted item, reverting it from 'claimed' to 'open'.
+
+The item must be in 'claimed' status. Only the claimer or the poster can unclaim.
+
+In wild-west mode the commit is auto-pushed to upstream and origin.
+Use --no-push to skip pushing (offline work).
+
+Examples:
+  wl unclaim w-abc123
+  wl unclaim w-abc123 --no-push`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runUnclaim(cmd, stdout, stderr, args[0], noPush)
+		},
+	}
+
+	cmd.Flags().BoolVar(&noPush, "no-push", false, "Skip pushing to remotes (offline work)")
+
+	return cmd
+}
+
+func runUnclaim(cmd *cobra.Command, stdout, _ io.Writer, wantedID 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)
+	item, err := unclaimWanted(store, wantedID, rigHandle)
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintf(stdout, "%s Unclaimed %s\n", style.Bold.Render("✓"), wantedID)
+	fmt.Fprintf(stdout, "  Title: %s\n", item.Title)
+	fmt.Fprintf(stdout, "  Status: open\n")
+
+	if !noPush {
+		_ = commons.PushWithSync(wlCfg.LocalDir, stdout)
+	}
+
+	return nil
+}
+
+// unclaimWanted contains the testable business logic for unclaiming a wanted item.
+func unclaimWanted(store commons.WLCommonsStore, wantedID, rigHandle string) (*commons.WantedItem, error) {
+	item, err := store.QueryWanted(wantedID)
+	if err != nil {
+		return nil, fmt.Errorf("querying wanted item: %w", err)
+	}
+
+	if item.Status != "claimed" {
+		return nil, fmt.Errorf("wanted item %s is not claimed (status: %s)", wantedID, item.Status)
+	}
+
+	if item.ClaimedBy != rigHandle && item.PostedBy != rigHandle {
+		return nil, fmt.Errorf("only the claimer or poster can unclaim (claimed by %q, posted by %q)", item.ClaimedBy, item.PostedBy)
+	}
+
+	if err := store.UnclaimWanted(wantedID); err != nil {
+		return nil, fmt.Errorf("unclaiming wanted item: %w", err)
+	}
+
+	return item, nil
+}

cmd/wl/cmd_unclaim_test.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/steveyegge/wasteland/internal/commons"
+)
+
+func TestUnclaimWanted_Success(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{
+		ID:       "w-abc123",
+		Title:    "Fix auth bug",
+		PostedBy: "poster-rig",
+	})
+	_ = store.ClaimWanted("w-abc123", "my-rig")
+
+	item, err := unclaimWanted(store, "w-abc123", "my-rig")
+	if err != nil {
+		t.Fatalf("unclaimWanted() error: %v", err)
+	}
+	if item.Title != "Fix auth bug" {
+		t.Errorf("Title = %q, want %q", item.Title, "Fix auth bug")
+	}
+
+	// Verify status was reverted in store.
+	updated, _ := store.QueryWanted("w-abc123")
+	if updated.Status != "open" {
+		t.Errorf("Status = %q, want %q", updated.Status, "open")
+	}
+	if updated.ClaimedBy != "" {
+		t.Errorf("ClaimedBy = %q, want empty", updated.ClaimedBy)
+	}
+}
+
+func TestUnclaimWanted_ByPoster(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{
+		ID:       "w-abc123",
+		Title:    "Fix auth bug",
+		PostedBy: "poster-rig",
+	})
+	_ = store.ClaimWanted("w-abc123", "claimer-rig")
+
+	// Poster (not claimer) unclaims — should succeed.
+	item, err := unclaimWanted(store, "w-abc123", "poster-rig")
+	if err != nil {
+		t.Fatalf("unclaimWanted() error: %v", err)
+	}
+	if item.Title != "Fix auth bug" {
+		t.Errorf("Title = %q, want %q", item.Title, "Fix auth bug")
+	}
+
+	updated, _ := store.QueryWanted("w-abc123")
+	if updated.Status != "open" {
+		t.Errorf("Status = %q, want %q", updated.Status, "open")
+	}
+	if updated.ClaimedBy != "" {
+		t.Errorf("ClaimedBy = %q, want empty", updated.ClaimedBy)
+	}
+}
+
+func TestUnclaimWanted_NotClaimed(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{
+		ID:       "w-abc123",
+		Title:    "Fix auth bug",
+		PostedBy: "poster-rig",
+	})
+
+	_, err := unclaimWanted(store, "w-abc123", "my-rig")
+	if err == nil {
+		t.Fatal("unclaimWanted() expected error for non-claimed item")
+	}
+	if !strings.Contains(err.Error(), "not claimed") {
+		t.Errorf("error = %q, want to contain 'not claimed'", err.Error())
+	}
+}
+
+func TestUnclaimWanted_NotFound(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+
+	_, err := unclaimWanted(store, "w-nonexistent", "my-rig")
+	if err == nil {
+		t.Fatal("unclaimWanted() expected error for missing item")
+	}
+}
+
+func TestUnclaimWanted_NotAuthorized(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{
+		ID:       "w-abc123",
+		Title:    "Fix auth bug",
+		PostedBy: "poster-rig",
+	})
+	_ = store.ClaimWanted("w-abc123", "claimer-rig")
+
+	// Someone who is neither claimer nor poster tries to unclaim.
+	_, err := unclaimWanted(store, "w-abc123", "random-rig")
+	if err == nil {
+		t.Fatal("unclaimWanted() expected error for unauthorized rig")
+	}
+	if !strings.Contains(err.Error(), "only the claimer or poster") {
+		t.Errorf("error = %q, want to contain 'only the claimer or poster'", err.Error())
+	}
+}
+
+func TestUnclaimWanted_StoreError(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	store.UnclaimWantedErr = fmt.Errorf("unclaim store error")
+	_ = store.InsertWanted(&commons.WantedItem{
+		ID:       "w-abc123",
+		Title:    "Fix auth bug",
+		PostedBy: "poster-rig",
+	})
+	_ = store.ClaimWanted("w-abc123", "my-rig")
+
+	_, err := unclaimWanted(store, "w-abc123", "my-rig")
+	if err == nil {
+		t.Fatal("unclaimWanted() expected error when UnclaimWanted fails")
+	}
+	if !strings.Contains(err.Error(), "unclaim store error") {
+		t.Errorf("error = %q, want to contain 'unclaim store error'", err.Error())
+	}
+}

cmd/wl/main.go

@@ -66,6 +66,7 @@ func newRootCmd(stdout, stderr io.Writer) *cobra.Command {
 		newJoinCmd(stdout, stderr),
 		newPostCmd(stdout, stderr),
 		newClaimCmd(stdout, stderr),
+		newUnclaimCmd(stdout, stderr),
 		newDoneCmd(stdout, stderr),
 		newAcceptCmd(stdout, stderr),
 		newRejectCmd(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", "reject", "update", "delete", "browse", "status", "sync", "leave", "list", "version"}
+	expected := []string{"join", "post", "claim", "unclaim", "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

@@ -46,6 +46,14 @@ stderr 'accepts 1 arg'
 ! exec wl claim w-abc
 stderr 'not joined'
 
+# unclaim with no args.
+! exec wl unclaim
+stderr 'accepts 1 arg'
+
+# unclaim not joined.
+! exec wl unclaim w-abc
+stderr 'not joined'
+
 # done with no args.
 ! exec wl done
 stderr 'accepts 1 arg'

internal/commons/commons.go

@@ -19,6 +19,7 @@ import (
 type WLCommonsStore interface {
 	InsertWanted(item *WantedItem) error
 	ClaimWanted(wantedID, rigHandle string) error
+	UnclaimWanted(wantedID string) error
 	SubmitCompletion(completionID, wantedID, rigHandle, evidence string) error
 	QueryWanted(wantedID string) (*WantedItem, error)
 	QueryWantedDetail(wantedID string) (*WantedItem, error)
@@ -47,6 +48,11 @@ func (w *WLCommons) ClaimWanted(wantedID, rigHandle string) error {
 	return ClaimWanted(w.dbDir, wantedID, rigHandle)
 }
 
+// UnclaimWanted reverts a claimed wanted item to open.
+func (w *WLCommons) UnclaimWanted(wantedID string) error {
+	return UnclaimWanted(w.dbDir, wantedID)
+}
+
 // SubmitCompletion records completion evidence for a claimed wanted item.
 func (w *WLCommons) SubmitCompletion(completionID, wantedID, rigHandle, evidence string) error {
 	return SubmitCompletion(w.dbDir, completionID, wantedID, rigHandle, evidence)
@@ -253,6 +259,25 @@ CALL DOLT_COMMIT('-m', 'wl claim: %s');
 	return fmt.Errorf("claim failed: %w", err)
 }
 
+// UnclaimWanted reverts a claimed wanted item to open, clearing claimed_by.
+// dbDir is the actual database directory.
+func UnclaimWanted(dbDir, wantedID string) error {
+	script := fmt.Sprintf(`UPDATE wanted SET claimed_by=NULL, status='open', updated_at=NOW()
+  WHERE id='%s' AND status='claimed';
+CALL DOLT_ADD('-A');
+CALL DOLT_COMMIT('-m', 'wl unclaim: %s');
+`, EscapeSQL(wantedID), EscapeSQL(wantedID))
+
+	err := doltSQLScript(dbDir, script)
+	if err == nil {
+		return nil
+	}
+	if isNothingToCommit(err) {
+		return fmt.Errorf("wanted item %q is not claimed or does not exist", wantedID)
+	}
+	return fmt.Errorf("unclaim failed: %w", err)
+}
+
 // SubmitCompletion inserts a completion record and updates the wanted status.
 // dbDir is the actual database directory.
 func SubmitCompletion(dbDir, completionID, wantedID, rigHandle, evidence string) error {

internal/commons/commons_fake_test.go

@@ -12,6 +12,7 @@ type fakeWLCommonsStore struct {
 
 	InsertWantedErr     error
 	ClaimWantedErr      error
+	UnclaimWantedErr    error
 	SubmitCompletionErr error
 	QueryWantedErr      error
 }
@@ -62,6 +63,26 @@ func (f *fakeWLCommonsStore) ClaimWanted(wantedID, rigHandle string) error {
 	return nil
 }
 
+func (f *fakeWLCommonsStore) UnclaimWanted(wantedID string) error {
+	if f.UnclaimWantedErr != nil {
+		return f.UnclaimWantedErr
+	}
+
+	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 != "claimed" {
+		return fmt.Errorf("wanted item %q is not claimed (status: %s)", wantedID, item.Status)
+	}
+	item.Status = "open"
+	item.ClaimedBy = ""
+	return nil
+}
+
 func (f *fakeWLCommonsStore) SubmitCompletion(_, wantedID, rigHandle, _ string) error {
 	if f.SubmitCompletionErr != nil {
 		return f.SubmitCompletionErr