feat(dates): add --due and --defer timestamp options with natural language parsing (#847)

* feat(dates): add due date schema and --due flag

- Add due_at and defer_until columns to issues table via migration 035
- Implement --due flag on create command with ISO date parsing
- Extend RPC protocol and daemon to pass DueAt from CLI to storage
- Display DueAt and DeferUntil in show command output
- Update Issue type with new date fields

Users can now set due dates when creating issues, enabling deadline-based
task management.

* feat(dates): add compact duration parser (+6h, +1d, +2w)

- Create internal/timeparsing package with layered parser architecture
- Implement parseCompactDuration with regex pattern [+-]?\d+[hdwmy]
- Add comprehensive test suite (22 cases) for duration parsing
- Integrate into create.go with fallback to ISO format

Supports hours (h), days (d), weeks (w), months (m), and years (y).
Negative values allowed for past dates.

* feat(dates): add NLP parsing for natural language dates

Integrate olebedev/when library for natural language time expressions.
The layered parser now handles: compact duration → absolute formats → NLP.

Changes:
- Add olebedev/when dependency for NLP parsing
- Implement ParseNaturalLanguage and ParseRelativeTime functions
- Reorder layers: absolute formats before NLP to avoid misinterpretation
- Simplify create.go to use unified ParseRelativeTime
- Add comprehensive NLP test coverage (22 test cases)

Supports: tomorrow, next monday, in 3 days, 3 days ago

* feat(dates): add --defer flag to create/update/defer commands

Add time-based deferral support alongside existing status-based defer.
Issues can now be hidden from bd ready until a specific time.

Changes:
- Add --defer flag to bd create (sets defer_until on creation)
- Add --due and --defer flags to bd update (modify existing issues)
- Add --until flag to bd defer (combines status=deferred with defer_until)
- Add DueAt/DeferUntil fields to UpdateArgs in protocol.go

Supports: +1h, tomorrow, next monday, 2025-01-15

* feat(dates): add defer_until filtering to ready command

Add time-based deferral support to bd ready:

- Add --include-deferred flag to show issues with future defer_until
- Filter out issues where defer_until > now by default
- Update undefer to clear defer_until alongside status change
- Add IncludeDeferred to WorkFilter and RPC ReadyArgs

Part of GH#820: Relative Date Parsing (Phase 5)

* feat(dates): add polish and tests for relative date parsing

Add user-facing warnings when defer date is in the past to help catch
common mistakes. Expand help text with format examples and document
the olebedev/when September parsing quirk.

Tests:
- TestCreateSuite/WithDueAt, WithDeferUntil, WithBothDueAndDefer
- TestReadyWorkDeferUntil (ExcludesFutureDeferredByDefault, IncludeDeferredShowsAll)

Docs:
- CLAUDE.md quick reference updated with new flags
- Help text examples for --due, --defer on create/update

Closes: Phase 6 of beads-820-relative-dates spec

* feat(list): add time-based query filters for defer/due dates

Add --deferred, --defer-before, --defer-after, --due-before, --due-after,
and --overdue flags to bd list command. All date filters now support
relative time expressions (+6h, tomorrow, next monday) via the
timeparsing package.

Filters:
- --deferred: issues with defer_until set
- --defer-before/after: filter by defer_until date range
- --due-before/after: filter by due_at date range
- --overdue: due_at in past AND status != closed

Existing date filters (--created-after, etc.) now also support relative
time expressions through updated parseTimeFlag().

* build(nix): update vendorHash for olebedev/when dependency

The olebedev/when library was added for natural language date parsing
(GH#820). This changes go.sum, requiring an updated vendorHash in the
Nix flake configuration.

cmd/bd/update.go

@@ -4,10 +4,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"time"
 
 	"github.com/spf13/cobra"
 	"github.com/steveyegge/beads/internal/hooks"
 	"github.com/steveyegge/beads/internal/rpc"
+	"github.com/steveyegge/beads/internal/timeparsing"
 	"github.com/steveyegge/beads/internal/types"
 	"github.com/steveyegge/beads/internal/ui"
 	"github.com/steveyegge/beads/internal/utils"
@@ -132,6 +134,39 @@ create, update, show, or close operation).`,
 			}
 			updates["issue_type"] = issueType
 		}
+		// Time-based scheduling flags (GH#820)
+		if cmd.Flags().Changed("due") {
+			dueStr, _ := cmd.Flags().GetString("due")
+			if dueStr == "" {
+				// Empty string clears the due date
+				updates["due_at"] = nil
+			} else {
+				t, err := timeparsing.ParseRelativeTime(dueStr, time.Now())
+				if err != nil {
+					FatalErrorRespectJSON("invalid --due format %q. Examples: +6h, tomorrow, next monday, 2025-01-15", dueStr)
+				}
+				updates["due_at"] = t
+			}
+		}
+		if cmd.Flags().Changed("defer") {
+			deferStr, _ := cmd.Flags().GetString("defer")
+			if deferStr == "" {
+				// Empty string clears the defer_until
+				updates["defer_until"] = nil
+			} else {
+				t, err := timeparsing.ParseRelativeTime(deferStr, time.Now())
+				if err != nil {
+					FatalErrorRespectJSON("invalid --defer format %q. Examples: +1h, tomorrow, next monday, 2025-01-15", deferStr)
+				}
+				// Warn if defer date is in the past (user probably meant future)
+				if t.Before(time.Now()) && !jsonOutput {
+					fmt.Fprintf(os.Stderr, "%s Defer date %q is in the past. Issue will appear in bd ready immediately.\n",
+						ui.RenderWarn("!"), t.Format("2006-01-02 15:04"))
+					fmt.Fprintf(os.Stderr, "  Did you mean a future date? Use --defer=+1h or --defer=tomorrow\n")
+				}
+				updates["defer_until"] = t
+			}
+		}
 
 		// Get claim flag
 		claimFlag, _ := cmd.Flags().GetBool("claim")
@@ -229,6 +264,23 @@ create, update, show, or close operation).`,
 				if parent, ok := updates["parent"].(string); ok {
 					updateArgs.Parent = &parent
 				}
+				// Time-based scheduling (GH#820)
+				if dueAt, ok := updates["due_at"].(time.Time); ok {
+					s := dueAt.Format(time.RFC3339)
+					updateArgs.DueAt = &s
+				} else if updates["due_at"] == nil && cmd.Flags().Changed("due") {
+					// Explicit clear
+					empty := ""
+					updateArgs.DueAt = &empty
+				}
+				if deferUntil, ok := updates["defer_until"].(time.Time); ok {
+					s := deferUntil.Format(time.RFC3339)
+					updateArgs.DeferUntil = &s
+				} else if updates["defer_until"] == nil && cmd.Flags().Changed("defer") {
+					// Explicit clear
+					empty := ""
+					updateArgs.DeferUntil = &empty
+				}
 
 				// Set claim flag for atomic claim operation
 				updateArgs.Claim = claimFlag
@@ -528,5 +580,16 @@ func init() {
 	updateCmd.Flags().String("parent", "", "New parent issue ID (reparents the issue, use empty string to remove parent)")
 	updateCmd.Flags().Bool("claim", false, "Atomically claim the issue (sets assignee to you, status to in_progress; fails if already claimed)")
 	updateCmd.Flags().String("session", "", "Claude Code session ID for status=closed (or set CLAUDE_SESSION_ID env var)")
+	// Time-based scheduling flags (GH#820)
+	// Examples:
+	//   --due=+6h           Due in 6 hours
+	//   --due=tomorrow      Due tomorrow
+	//   --due="next monday" Due next Monday
+	//   --due=2025-01-15    Due on specific date
+	//   --due=""            Clear due date
+	//   --defer=+1h         Hidden from bd ready for 1 hour
+	//   --defer=""          Clear defer (show in bd ready immediately)
+	updateCmd.Flags().String("due", "", "Due date/time (empty to clear). Formats: +6h, +1d, +2w, tomorrow, next monday, 2025-01-15")
+	updateCmd.Flags().String("defer", "", "Defer until date (empty to clear). Issue hidden from bd ready until then")
 	rootCmd.AddCommand(updateCmd)
 }