Add wl close command for solo maintainer housekeeping

Lets the poster mark an in_review item as completed without issuing a
reputation stamp. Solves the solo maintainer problem where accept requires
a different rig to have completed the work.

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

Author: julianknutsen

README.md

@@ -72,15 +72,32 @@ Maintainers with push access to upstream can skip forking:
 wl join --direct [--signed]          # clone upstream directly, no fork
 ```
 
+### Solo maintainer workflow
+
+If you're bootstrapping a wasteland, you can work your own wanted board:
+
+```bash
+wl post --title "Set up CI" --type feature
+wl claim w-abc123
+wl done w-abc123 --evidence "https://github.com/org/repo/pull/1"
+wl close w-abc123
+```
+
+The item moves through `open → claimed → in_review → completed`.
+Since `accept` requires a different rig to have completed the work
+(you can't stamp your own completion), use `wl close` to mark your
+own items as completed without issuing a reputation stamp. This is
+housekeeping, not reputation — stamps must come from someone else.
+
 ## Workflow
 
 A wanted item moves through this lifecycle:
 
 ```
 open ──→ claimed ──→ in_review ──→ completed
   │         │                         ↑
-  │         ↓                         │
-  │      (unclaim → open)         (accept + stamp)
+  │         ↓                         ├── accept (+ stamp)
+  │      (unclaim → open)             └── close  (no stamp)
   │
   ↓
 withdrawn
@@ -290,6 +307,7 @@ Config and data follow XDG conventions:
 | `wl done <id>` | Submit completion evidence | `--evidence` (required), `--no-push` |
 | `wl accept <id>` | Accept and issue a stamp | `--quality` (required), `--reliability`, `--severity`, `--skills` |
 | `wl reject <id>` | Reject back to claimed | `--reason`, `--no-push` |
+| `wl close <id>` | Close in_review item (no stamp) | `--no-push` |
 | `wl status <id>` | Show full item details | |
 | `wl update <id>` | Update an open item | `--title`, `--priority`, `--effort`, `--type`, `--tags`, `--project` |
 | `wl unclaim <id>` | Release back to open | `--no-push` |

cmd/wl/cmd_close.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/julianknutsen/wasteland/internal/commons"
+	"github.com/julianknutsen/wasteland/internal/style"
+	"github.com/spf13/cobra"
+)
+
+func newCloseCmd(stdout, stderr io.Writer) *cobra.Command {
+	var noPush bool
+
+	cmd := &cobra.Command{
+		Use:   "close <wanted-id>",
+		Short: "Close an in_review item as completed (no stamp)",
+		Long: `Close an in_review wanted item by marking it as completed without issuing
+a reputation stamp. This is housekeeping for solo maintainers who posted,
+claimed, and completed their own work.
+
+The item must be in 'in_review' status and only the poster can close it.
+
+In wild-west mode the commit is auto-pushed to upstream and origin.
+Use --no-push to skip pushing (offline work).
+
+Examples:
+  wl close w-abc123`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runClose(cmd, stdout, stderr, args[0], noPush)
+		},
+	}
+
+	cmd.Flags().BoolVar(&noPush, "no-push", false, "Skip pushing to remotes (offline work)")
+
+	return cmd
+}
+
+func runClose(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
+
+	mc := newMutationContext(wlCfg, wantedID, noPush, stdout)
+	cleanup, err := mc.Setup()
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	store := openStore(wlCfg.LocalDir, wlCfg.Signing, wlCfg.HopURI)
+
+	if err := closeWanted(store, wantedID, rigHandle); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(stdout, "%s Closed %s\n", style.Bold.Render("✓"), wantedID)
+	fmt.Fprintf(stdout, "  Status: completed\n")
+	if mc.BranchName() != "" {
+		fmt.Fprintf(stdout, "  Branch: %s\n", mc.BranchName())
+	}
+
+	mc.Push()
+
+	return nil
+}
+
+// closeWanted contains the testable business logic for closing a wanted item.
+func closeWanted(store commons.WLCommonsStore, wantedID, rigHandle 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 close (posted by %q)", item.PostedBy)
+	}
+
+	if err := store.CloseWanted(wantedID); err != nil {
+		return fmt.Errorf("closing wanted item: %w", err)
+	}
+
+	return nil
+}

cmd/wl/cmd_close_test.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/julianknutsen/wasteland/internal/commons"
+)
+
+func TestCloseWanted_Success(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = 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", "https://github.com/pr/1")
+
+	err := closeWanted(store, "w-abc", "my-rig")
+	if err != nil {
+		t.Fatalf("closeWanted() error: %v", err)
+	}
+
+	item, _ := store.QueryWanted("w-abc")
+	if item.Status != "completed" {
+		t.Errorf("Status = %q, want %q", item.Status, "completed")
+	}
+}
+
+func TestCloseWanted_NotInReview(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name   string
+		status string
+	}{
+		{"open item", ""},
+		{"claimed item", "claimed"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			store := newFakeWLCommonsStore()
+			item := &commons.WantedItem{ID: "w-abc", Title: "Fix bug", PostedBy: "my-rig"}
+			if tt.status != "" {
+				item.Status = tt.status
+			}
+			_ = store.InsertWanted(item)
+			if tt.status == "claimed" {
+				_ = store.ClaimWanted("w-abc", "my-rig")
+			}
+
+			err := closeWanted(store, "w-abc", "my-rig")
+			if err == nil {
+				t.Fatal("closeWanted() 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 TestCloseWanted_WrongPoster(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 := closeWanted(store, "w-abc", "other-rig")
+	if err == nil {
+		t.Fatal("closeWanted() expected error for non-poster")
+	}
+	if !strings.Contains(err.Error(), "only the poster can close") {
+		t.Errorf("error = %q, want to contain 'only the poster can close'", err.Error())
+	}
+}
+
+func TestCloseWanted_NotFound(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+
+	err := closeWanted(store, "w-nonexistent", "my-rig")
+	if err == nil {
+		t.Fatal("closeWanted() expected error for missing item")
+	}
+}
+
+func TestCloseWanted_StoreError(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", Status: "in_review", PostedBy: "my-rig"})
+	store.CloseWantedErr = fmt.Errorf("close store error")
+
+	err := closeWanted(store, "w-abc", "my-rig")
+	if err == nil {
+		t.Fatal("closeWanted() expected error when CloseWanted fails")
+	}
+	if !strings.Contains(err.Error(), "close store error") {
+		t.Errorf("error = %q, want to contain 'close store error'", err.Error())
+	}
+}

cmd/wl/cmd_fake_test.go

@@ -25,6 +25,7 @@ type fakeWLCommonsStore struct {
 	QueryStampErr        error
 	AcceptCompletionErr  error
 	RejectCompletionErr  error
+	CloseWantedErr       error
 	UpdateWantedErr      error
 	DeleteWantedErr      error
 }
@@ -234,6 +235,25 @@ func (f *fakeWLCommonsStore) RejectCompletion(wantedID, _, _ string) error {
 	return nil
 }
 
+func (f *fakeWLCommonsStore) CloseWanted(wantedID string) error {
+	if f.CloseWantedErr != nil {
+		return f.CloseWantedErr
+	}
+
+	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 = "completed"
+	return nil
+}
+
 func (f *fakeWLCommonsStore) UpdateWanted(wantedID string, fields *commons.WantedUpdate) error {
 	if f.UpdateWantedErr != nil {
 		return f.UpdateWantedErr

cmd/wl/main.go

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

internal/commons/commons.go

@@ -27,6 +27,7 @@ type WLCommonsStore interface {
 	QueryStamp(stampID string) (*Stamp, error)
 	AcceptCompletion(wantedID, completionID, rigHandle string, stamp *Stamp) error
 	RejectCompletion(wantedID, rigHandle, reason string) error
+	CloseWanted(wantedID string) error
 	UpdateWanted(wantedID string, fields *WantedUpdate) error
 	DeleteWanted(wantedID string) error
 }
@@ -103,6 +104,11 @@ func (w *WLCommons) RejectCompletion(wantedID, rigHandle, reason string) error {
 	return RejectCompletion(w.dbDir, wantedID, rigHandle, reason, w.signed)
 }
 
+// CloseWanted marks an in_review item as completed without a stamp.
+func (w *WLCommons) CloseWanted(wantedID string) error {
+	return CloseWanted(w.dbDir, wantedID, w.signed)
+}
+
 // DeleteWanted soft-deletes a wanted item by setting status=withdrawn.
 func (w *WLCommons) DeleteWanted(wantedID string) error {
 	return DeleteWanted(w.dbDir, wantedID, w.signed)
@@ -606,6 +612,24 @@ func UpdateWanted(dbDir, wantedID string, fields *WantedUpdate, signed bool) err
 	return fmt.Errorf("update failed: %w", err)
 }
 
+// CloseWanted marks an in_review wanted item as completed without issuing a
+// stamp. This is housekeeping for solo maintainers who completed their own work.
+// dbDir is the actual database directory.
+func CloseWanted(dbDir, wantedID string, signed bool) error {
+	script := fmt.Sprintf("UPDATE wanted SET status='completed', updated_at=NOW() WHERE id='%s' AND status='in_review';\nCALL DOLT_ADD('-A');\n",
+		EscapeSQL(wantedID))
+	script += commitSQL("wl close: "+wantedID, signed)
+
+	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("close failed: %w", err)
+}
+
 // formatTagsJSON formats a string slice as a JSON array SQL literal.
 func formatTagsJSON(tags []string) string {
 	if len(tags) == 0 {

internal/commons/commons_fake_test.go

@@ -15,6 +15,7 @@ type fakeWLCommonsStore struct {
 	UnclaimWantedErr    error
 	SubmitCompletionErr error
 	QueryWantedErr      error
+	CloseWantedErr      error
 }
 
 func (f *fakeWLCommonsStore) InsertWanted(item *WantedItem) error {
@@ -133,6 +134,25 @@ func (f *fakeWLCommonsStore) QueryStamp(_ string) (*Stamp, error) {
 	return nil, fmt.Errorf("not implemented in commons fake")
 }
 
+func (f *fakeWLCommonsStore) CloseWanted(wantedID string) error {
+	if f.CloseWantedErr != nil {
+		return f.CloseWantedErr
+	}
+
+	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 = "completed"
+	return nil
+}
+
 func (f *fakeWLCommonsStore) AcceptCompletion(_, _, _ string, _ *Stamp) error {
 	return fmt.Errorf("not implemented in commons fake")
 }