feat(status): add deferred status for icebox issues (bd-4jr)

Add 'deferred' as a valid issue status for issues that are deliberately
put on ice - not blocked by dependencies, just postponed for later.

Changes:
- Add StatusDeferred constant and update IsValid() validation
- Add DeferredIssues to Statistics struct with counting in both SQLite
  and memory storage
- Add 'bd defer' command to set status to deferred
- Add 'bd undefer' command to restore status to open
- Update help text across list, search, count, dep, stale, and config
- Update MCP server models and tools to accept deferred status
- Add deferred to blocker status checks (schema, cache, ready, compact)
- Add StatusDeferred to public API exports (beads.go, internal/beads)
- Add snowflake styling for deferred in dep tree and graph views

Semantics:
- deferred vs blocked: deferred is a choice, blocked is forced
- deferred vs closed: deferred will be revisited, closed is done
- Deferred issues excluded from 'bd ready' (already works since
  default filter only includes open/in_progress)
- Deferred issues still block dependents (they are not done!)
- Deferred issues visible in 'bd list' and 'bd stale'

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

cmd/bd/undefer.go

@@ -0,0 +1,138 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+	"github.com/steveyegge/beads/internal/rpc"
+	"github.com/steveyegge/beads/internal/types"
+	"github.com/steveyegge/beads/internal/utils"
+)
+
+var undeferCmd = &cobra.Command{
+	Use:   "undefer [id...]",
+	Short: "Undefer one or more issues (restore to open)",
+	Long: `Undefer issues to restore them to open status.
+
+This brings issues back from the icebox so they can be worked on again.
+Issues will appear in 'bd ready' if they have no blockers.
+
+Examples:
+  bd undefer bd-abc        # Undefer a single issue
+  bd undefer bd-abc bd-def # Undefer multiple issues`,
+	Args: cobra.MinimumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		CheckReadonly("undefer")
+
+		ctx := rootCtx
+
+		// Resolve partial IDs first
+		var resolvedIDs []string
+		if daemonClient != nil {
+			for _, id := range args {
+				resolveArgs := &rpc.ResolveIDArgs{ID: id}
+				resp, err := daemonClient.ResolveID(resolveArgs)
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "Error resolving ID %s: %v\n", id, err)
+					os.Exit(1)
+				}
+				var resolvedID string
+				if err := json.Unmarshal(resp.Data, &resolvedID); err != nil {
+					fmt.Fprintf(os.Stderr, "Error unmarshaling resolved ID: %v\n", err)
+					os.Exit(1)
+				}
+				resolvedIDs = append(resolvedIDs, resolvedID)
+			}
+		} else {
+			var err error
+			resolvedIDs, err = utils.ResolvePartialIDs(ctx, store, args)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+				os.Exit(1)
+			}
+		}
+
+		undeferredIssues := []*types.Issue{}
+
+		// If daemon is running, use RPC
+		if daemonClient != nil {
+			for _, id := range resolvedIDs {
+				status := string(types.StatusOpen)
+				updateArgs := &rpc.UpdateArgs{
+					ID:     id,
+					Status: &status,
+				}
+
+				resp, err := daemonClient.Update(updateArgs)
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "Error undeferring %s: %v\n", id, err)
+					continue
+				}
+
+				if jsonOutput {
+					var issue types.Issue
+					if err := json.Unmarshal(resp.Data, &issue); err == nil {
+						undeferredIssues = append(undeferredIssues, &issue)
+					}
+				} else {
+					green := color.New(color.FgGreen).SprintFunc()
+					fmt.Printf("%s Undeferred %s (now open)\n", green("*"), id)
+				}
+			}
+
+			if jsonOutput && len(undeferredIssues) > 0 {
+				outputJSON(undeferredIssues)
+			}
+			return
+		}
+
+		// Fall back to direct storage access
+		if store == nil {
+			fmt.Fprintln(os.Stderr, "Error: database not initialized")
+			os.Exit(1)
+		}
+
+		for _, id := range args {
+			fullID, err := utils.ResolvePartialID(ctx, store, id)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error resolving %s: %v\n", id, err)
+				continue
+			}
+
+			updates := map[string]interface{}{
+				"status": string(types.StatusOpen),
+			}
+
+			if err := store.UpdateIssue(ctx, fullID, updates, actor); err != nil {
+				fmt.Fprintf(os.Stderr, "Error undeferring %s: %v\n", fullID, err)
+				continue
+			}
+
+			if jsonOutput {
+				issue, _ := store.GetIssue(ctx, fullID)
+				if issue != nil {
+					undeferredIssues = append(undeferredIssues, issue)
+				}
+			} else {
+				green := color.New(color.FgGreen).SprintFunc()
+				fmt.Printf("%s Undeferred %s (now open)\n", green("*"), fullID)
+			}
+		}
+
+		// Schedule auto-flush if any issues were undeferred
+		if len(args) > 0 {
+			markDirtyAndScheduleFlush()
+		}
+
+		if jsonOutput && len(undeferredIssues) > 0 {
+			outputJSON(undeferredIssues)
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(undeferCmd)
+}