open-cli-collective
diff --git a/‎CLAUDE.md‎
Lines changed: 1 addition & 1 deletion b/‎CLAUDE.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎README.md‎
Lines changed: 11 additions & 0 deletions b/‎README.md‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎integration-tests.md‎
Lines changed: 28 additions & 0 deletions b/‎integration-tests.md‎
Lines changed: 28 additions & 0 deletions
diff --git a/‎internal/cmd/mail/draft.go‎
Lines changed: 212 additions & 11 deletions b/‎internal/cmd/mail/draft.go‎
Lines changed: 212 additions & 11 deletions
@@ -10,7 +10,7 @@ gro is a **non-destructive** command-line interface for Google services written
 **Module:** `github.com/open-cli-collective/google-readonly`
 
 ### Features
-- Gmail: Search, read, thread viewing, labels, attachments, archive, star, mark read/unread, label, categorize, draft (compose-only, never sent)
+- Gmail: Search, read, thread viewing, labels, attachments, archive, star, mark read/unread, label, categorize, draft (compose-only, never sent — supports reply-to-thread)
 - Google Calendar: List calendars, view events, today/week shortcuts
 - Google Contacts: List contacts, search, view details, list groups
 - Google Drive: List files, search, get details, download, tree view, shared drives
 
@@ -288,10 +288,17 @@ gro mail draft --to a@x.com --subject "See attached" --body "..." --attach repor
 
 # From a send-as alias
 gro mail draft --from work@me.com --to a@x.com --subject "Hi" --body "..."
+
+# Reply to an existing message (preserves thread, adds In-Reply-To / References)
+gro mail draft --reply-to <message-id> --body "thanks, will review"
+gro mail draft --reply-to <message-id> --reply-all --body "looping everyone in"
+gro mail draft --reply-to <message-id> --subject "Re: customised" --body "..."
 ```
 
 Drafts always land in your Gmail Drafts folder for human review. The CLI never calls `drafts.send` — sending requires explicit action in Gmail.
 
+With `--reply-to`, `--to` and `--subject` are derived from the source message (To = original From; Subject = `Re: <original>`, no double prefix). Explicit `--to` / `--cc` / `--subject` flags override the derived values. `--reply-all` adds the original To and Cc as Cc on the reply, filtered to remove your own address (and any `--from` alias).
+
 ### Calendar Commands
 
 All Calendar commands are under `gro calendar` (or `gro cal`):
@@ -733,12 +740,16 @@ Flags:
       --html              Send body as raw HTML (no markdown rendering)
   -a, --attach strings    File path to attach (repeat for multiple)
   -j, --json              Output result as JSON
+      --reply-to string   Source Gmail message ID to reply to (derives To/Subject/threading)
+      --reply-all         Include the source To/Cc as Cc on the reply (requires --reply-to)
 ```
 
 `--body`, `--stdin`, and `--file` are mutually exclusive (exactly one required). `--plain` and `--html` are mutually exclusive.
 
 Display names in `--to`/`--cc`/`--bcc` (e.g., `Alice <alice@example.com>`) are stripped; only the email address is sent. Edit the draft in Gmail to set display names.
 
+With `--reply-to`, the draft is threaded onto the source conversation (`In-Reply-To` and `References` headers are set; `Draft.Message.ThreadId` is set to the source thread). `--to` and `--subject` are derived from the source (To = original From; Subject = `Re: <original>` with no double prefix). Explicit `--to`/`--cc`/`--subject` flags override the derived values. `--reply-all` populates Cc with the source To+Cc minus your authenticated account and any `--from` alias.
+
 ### gro calendar list
 
 List all calendars the user has access to.
 
@@ -565,6 +565,34 @@ Skip if no Gmail send-as alias is configured for the test user.
 | T19 | Valid alias | `./bin/gro mail draft --from <configured-alias> --to "$ME" --subject "T19 alias" --body "x" --plain` | Exit 0. Gmail Drafts shows the alias in From line. |
 | T20 | Unconfigured alias | `./bin/gro mail draft --from "not-my-alias@example.com" --to "$ME" --subject "T20 bad alias" --body "x" --plain; echo "exit=$?"` | Non-zero exit. API error surfaced verbatim from `creating draft: ...`. |
 
+### Reply-to-thread (`--reply-to` / `--reply-all`)
+
+**Setup additions:**
+```bash
+# Pick any existing message in your inbox as the source. The query can be
+# anything that resolves to a single recent message.
+SRC_ID=$(./bin/gro mail search "in:inbox" --json | jq -r '.[0].id')
+SRC_RFC=$(./bin/gro mail read "$SRC_ID" --json | jq -r '.rfcMessageId')
+SRC_THREAD=$(./bin/gro mail read "$SRC_ID" --json | jq -r '.threadId')
+echo "source: $SRC_ID / thread: $SRC_THREAD / rfc-id: $SRC_RFC"
+```
+
+For each happy-path scenario, capture the created draft's message ID and read it back to verify the wire-format headers:
+
+```bash
+DRAFT_MSG_ID=$(./bin/gro mail draft --reply-to "$SRC_ID" --body "T21 reply" --plain --json | jq -r '.messageId')
+./bin/gro mail read "$DRAFT_MSG_ID" --json | jq '{inReplyTo, references, threadId}'
+```
+
+| # | Test Case | Command | Expected Result |
+|---|-----------|---------|-----------------|
+| T21 | Simple reply | `./bin/gro mail draft --reply-to "$SRC_ID" --body "T21 reply" --plain --json` | Exit 0. Read-back JSON shows `threadId == $SRC_THREAD`, `inReplyTo == $SRC_RFC`, `references` ends with `$SRC_RFC`, subject prefixed `Re: `. Gmail UI shows the draft grouped under the original conversation. |
+| T22 | Reply-all | `./bin/gro mail draft --reply-to "$SRC_ID" --reply-all --body "T22 all" --plain --json` | Exit 0. Cc on the draft contains the source To+Cc minus `$ME`. Read-back JSON same threading checks as T21. |
+| T23 | Explicit subject override | `./bin/gro mail draft --reply-to "$SRC_ID" --subject "T23 custom" --body "x" --plain --json` | Exit 0. Draft subject is `T23 custom` (no `Re:` prefix). Threading headers still set. |
+| T24 | Explicit Cc override | `./bin/gro mail draft --reply-to "$SRC_ID" --cc "$ME" --body "T24 cc" --plain --json` | Exit 0. Draft Cc is exactly `$ME` (replaces, not merges with, derived Cc). |
+| T25 | No double Re: prefix | First find a source message whose subject already starts with `Re:`: `RE_SRC=$(./bin/gro mail search "subject:Re:" --json \| jq -r '.[0].id')`. Then: `./bin/gro mail draft --reply-to "$RE_SRC" --body "T25" --plain --json` | Exit 0. Read-back subject is unchanged (no `Re: Re: ` doubling). |
+| T26 | Reply-all without reply-to | `./bin/gro mail draft --to "$ME" --subject "x" --body "y" --reply-all; echo "exit=$?"` | Non-zero exit. Error mentions `--reply-all requires --reply-to`. |
+
 ### Cleanup
 
 ```bash
 
@@ -31,6 +31,8 @@ func newDraftCommand() *cobra.Command {
 		htmlMode bool
 		attach   []string
 		jsonOut  bool
+		replyTo  string
+		replyAll bool
 	)
 
 	cmd := &cobra.Command{
@@ -50,34 +52,48 @@ Examples:
   gro mail draft --to "a@x.com, b@x.com" --subject "Sync" --file notes.md
   echo "# Hello" | gro mail draft --to a@x.com --subject "Hi" --stdin
   gro mail draft --to a@x.com --subject "Plain" --body "no md" --plain
-  gro mail draft --to a@x.com --subject "Report" --body "see attached" --attach report.pdf`,
+  gro mail draft --to a@x.com --subject "Report" --body "see attached" --attach report.pdf
+  gro mail draft --reply-to <message-id> --body "thanks, will review"
+  gro mail draft --reply-to <message-id> --reply-all --body "..."`,
 		RunE: func(cmd *cobra.Command, _ []string) error {
-			// 1. Required-flag checks.
-			if !cmd.Flags().Changed("to") {
-				return fmt.Errorf("--to is required")
+			// --reply-to with an empty value is a user error (often a shell
+			// variable that didn't expand). Reject it explicitly so we don't
+			// silently produce an unthreaded draft.
+			if cmd.Flags().Changed("reply-to") && strings.TrimSpace(replyTo) == "" {
+				return fmt.Errorf("--reply-to requires a non-empty message ID")
 			}
-			if !cmd.Flags().Changed("subject") {
-				return fmt.Errorf("--subject is required (use --subject \"\" for empty subject)")
+			isReply := cmd.Flags().Changed("reply-to")
+
+			// 1. Required-flag checks. In reply mode, --to and --subject are
+			//    derived from the source message and only required if not derivable.
+			if replyAll && !isReply {
+				return fmt.Errorf("--reply-all requires --reply-to")
+			}
+			if !isReply {
+				if !cmd.Flags().Changed("to") {
+					return fmt.Errorf("--to is required")
+				}
+				if !cmd.Flags().Changed("subject") {
+					return fmt.Errorf("--subject is required (use --subject \"\" for empty subject)")
+				}
 			}
 
 			// 2. Header-injection guard on raw flag values.
 			for _, f := range []struct{ name, val string }{
 				{"--to", to}, {"--cc", cc}, {"--bcc", bcc},
 				{"--from", fromAddr}, {"--subject", subject},
+				{"--reply-to", replyTo},
 			} {
 				if strings.ContainsAny(f.val, "\r\n") {
 					return fmt.Errorf("%s contains illegal CR or LF", f.name)
 				}
 			}
 
-			// 3. Address parsing.
+			// 3. Address parsing on user-supplied flags.
 			toAddrs, err := parseAddressList("--to", to)
 			if err != nil {
 				return err
 			}
-			if len(toAddrs) == 0 {
-				return fmt.Errorf("--to must contain at least one address")
-			}
 			ccAddrs, err := parseAddressList("--cc", cc)
 			if err != nil {
 				return err
@@ -98,6 +114,17 @@ Examples:
 				fromAddr = parsed.Address
 			}
 
+			// 3b. Local recipient validation (no I/O yet).
+			//     - Non-reply mode: --to is required and must parse to ≥1 address.
+			//     - Reply mode: an explicit --to override must still parse to ≥1
+			//       address; otherwise we defer the check until after derivation.
+			if !isReply && len(toAddrs) == 0 {
+				return fmt.Errorf("--to must contain at least one address")
+			}
+			if isReply && cmd.Flags().Changed("to") && len(toAddrs) == 0 {
+				return fmt.Errorf("--to must contain at least one address")
+			}
+
 			// 4. Body source: exactly one of --body, --stdin, --file.
 			bodySources := 0
 			if cmd.Flags().Changed("body") {
@@ -169,11 +196,63 @@ Examples:
 				})
 			}
 
-			// 9. Call client.
+			// 9. Build client; in reply mode, fetch source + (optionally) profile and derive defaults.
 			client, err := newGmailClient(cmd.Context())
 			if err != nil {
 				return fmt.Errorf("creating Gmail client: %w", err)
 			}
+
+			var (
+				threadID   string
+				inReplyTo  string
+				references []string
+			)
+			if isReply {
+				src, err := client.GetMessage(cmd.Context(), replyTo, false)
+				if err != nil {
+					return fmt.Errorf("fetching reply source %s: %w", replyTo, err)
+				}
+				needs := replyNeeds{
+					To:      !cmd.Flags().Changed("to"),
+					Cc:      replyAll && !cmd.Flags().Changed("cc"),
+					Subject: !cmd.Flags().Changed("subject"),
+				}
+				selfSet := map[string]bool{}
+				if needs.Cc {
+					profile, err := client.GetProfile(cmd.Context())
+					if err != nil {
+						return fmt.Errorf("fetching profile for --reply-all: %w", err)
+					}
+					if profile != nil && profile.EmailAddress != "" {
+						selfSet[strings.ToLower(profile.EmailAddress)] = true
+					}
+					if fromAddr != "" {
+						selfSet[strings.ToLower(fromAddr)] = true
+					}
+				}
+				derived, err := deriveReplyDefaults(src, needs, selfSet)
+				if err != nil {
+					return err
+				}
+				threadID = derived.ThreadID
+				inReplyTo = derived.InReplyTo
+				references = derived.References
+				if needs.To {
+					toAddrs = derived.To
+				}
+				if needs.Cc {
+					ccAddrs = derived.Cc
+				}
+				if needs.Subject {
+					subject = derived.Subject
+				}
+			}
+
+			// 9b. Post-derivation resolved-recipient validation.
+			if len(toAddrs) == 0 {
+				return fmt.Errorf("--to must contain at least one address")
+			}
+
 			result, err := client.CreateDraft(cmd.Context(), gmailapi.DraftMessage{
 				From:        fromAddr,
 				To:          toAddrs,
@@ -183,6 +262,9 @@ Examples:
 				Body:        outBody,
 				BodyKind:    kind,
 				Attachments: attachments,
+				ThreadID:    threadID,
+				InReplyTo:   inReplyTo,
+				References:  references,
 			})
 			if err != nil {
 				return fmt.Errorf("creating draft: %w", err)
@@ -226,10 +308,129 @@ Examples:
 	cmd.Flags().BoolVar(&htmlMode, "html", false, "Treat body as raw HTML (no markdown rendering)")
 	cmd.Flags().StringArrayVarP(&attach, "attach", "a", nil, "File path to attach (repeat for multiple)")
 	cmd.Flags().BoolVarP(&jsonOut, "json", "j", false, "Output result as JSON")
+	cmd.Flags().StringVar(&replyTo, "reply-to", "", "Source Gmail message ID to reply to (derives To/Subject/threading)")
+	cmd.Flags().BoolVar(&replyAll, "reply-all", false, "Include the source To/Cc as Cc on the reply (requires --reply-to)")
 
 	return cmd
 }
 
+// replyDerivation is the result of analysing the source message for reply mode.
+type replyDerivation struct {
+	ThreadID   string
+	InReplyTo  string
+	References []string
+	To         []string
+	Cc         []string
+	Subject    string
+}
+
+// replyNeeds tells deriveReplyDefaults which slots the caller will actually
+// consume. Source headers are only parsed for needed slots, so an explicit
+// --to/--cc/--subject override is unaffected by a malformed/missing source
+// header for that slot.
+type replyNeeds struct {
+	To      bool
+	Cc      bool
+	Subject bool
+}
+
+func deriveReplyDefaults(src *gmailapi.Message, needs replyNeeds, selfSet map[string]bool) (replyDerivation, error) {
+	if src == nil {
+		return replyDerivation{}, fmt.Errorf("source message is nil")
+	}
+	// Message-Id is always required: it feeds In-Reply-To and References,
+	// which are emitted regardless of override flags.
+	if strings.TrimSpace(src.RFCMessageID) == "" {
+		return replyDerivation{}, fmt.Errorf("source message %s has no Message-Id header", src.ID)
+	}
+	out := replyDerivation{
+		ThreadID:   src.ThreadID,
+		InReplyTo:  src.RFCMessageID,
+		References: buildReferences(src.References, src.RFCMessageID),
+	}
+	if needs.To {
+		if strings.TrimSpace(src.From) == "" {
+			return replyDerivation{}, fmt.Errorf("source message %s has no From header", src.ID)
+		}
+		fromAddr, err := mail.ParseAddress(src.From)
+		if err != nil {
+			return replyDerivation{}, fmt.Errorf("parsing source From header %q: %w", src.From, err)
+		}
+		out.To = []string{fromAddr.Address}
+	}
+	if needs.Subject {
+		out.Subject = addRePrefix(src.Subject)
+	}
+	if needs.Cc {
+		ccAddrs, err := splitAddressHeaders(src.To, src.Cc)
+		if err != nil {
+			return replyDerivation{}, fmt.Errorf("parsing source To/Cc headers: %w", err)
+		}
+		out.Cc = filterSelf(ccAddrs, selfSet)
+	}
+	return out, nil
+}
+
+// buildReferences appends the source Message-Id to the existing References
+// chain, splitting the raw header on whitespace (RFC 5322 §3.6.4). If the
+// chain already ends with msgID, it is not duplicated.
+func buildReferences(rawRefs, msgID string) []string {
+	out := strings.Fields(rawRefs)
+	if len(out) > 0 && out[len(out)-1] == msgID {
+		return out
+	}
+	return append(out, msgID)
+}
+
+// splitAddressHeaders parses each non-empty raw header value via
+// mail.ParseAddressList and concatenates the bare addresses. Returns an
+// error on the first malformed header rather than silently dropping content.
+func splitAddressHeaders(values ...string) ([]string, error) {
+	var out []string
+	for _, v := range values {
+		if strings.TrimSpace(v) == "" {
+			continue
+		}
+		addrs, err := mail.ParseAddressList(v)
+		if err != nil {
+			return nil, fmt.Errorf("%q: %w", v, err)
+		}
+		for _, a := range addrs {
+			out = append(out, a.Address)
+		}
+	}
+	return out, nil
+}
+
+// filterSelf removes addresses present in selfSet (case-insensitive lookup)
+// and de-duplicates while preserving first-seen order.
+func filterSelf(addrs []string, selfSet map[string]bool) []string {
+	seen := map[string]bool{}
+	out := make([]string, 0, len(addrs))
+	for _, a := range addrs {
+		k := strings.ToLower(a)
+		if selfSet[k] || seen[k] {
+			continue
+		}
+		seen[k] = true
+		out = append(out, a)
+	}
+	return out
+}
+
+// addRePrefix prefixes "Re: " unless the subject already begins with a
+// case-insensitive "re:" (the colon is the delimiter; "re:foo" without a
+// trailing space still counts as already-prefixed). Locale variants
+// (Aw, Sv, etc.) are intentionally not recognised — Gmail itself
+// doesn't normalise them.
+func addRePrefix(subject string) string {
+	trimmed := strings.TrimLeft(subject, " \t")
+	if len(trimmed) >= 3 && strings.EqualFold(trimmed[:3], "re:") {
+		return subject
+	}
+	return "Re: " + subject
+}
+
 // parseAddressList parses a comma-separated address list. An empty input is OK
 // and returns nil — the caller decides whether emptiness is an error.
 func parseAddressList(flag, raw string) ([]string, error) {