fix(cli): anchor defaulted --since at --until; note --fields everywhere it does not apply

A defaulted lookback --since (24h, or 30d for open-only incident and
active alert lists) now spans back from the parsed --until instead of
from now. With --until +1d the 30d default used to produce a 31-day
window, which the list endpoints reject; a past --until with the 24h
default produced an inverted window. timeutil.Lookback recognizes the
past-relative duration form (and rejects "+" offsets, which the day
shorthand expansion would otherwise accept).

The "--fields does not apply" note moves to the root PersistentPostRun,
driven by whether a projection ran. Commands that print their own
output (version, config show) and table mode now get the note too,
instead of ignoring --fields silently.

Author: ysyneu

internal/cli/command.go

@@ -80,7 +80,6 @@ func (ctx *RunContext) PrintTotal(items any, cols []output.Column, total int) er
 
 // WriteResult prints a success message as plain text or JSON.
 func (ctx *RunContext) WriteResult(message string) {
-	noteFieldsNotApplied(ctx.Cmd)
 	writeResult(ctx.Writer, message)
 }
 
@@ -89,7 +88,6 @@ func (ctx *RunContext) WriteResult(message string) {
 // shell redirection (`> file.csv`) captures the bytes verbatim instead of the
 // canned "OK: POST ..." acknowledgment.
 func (ctx *RunContext) WriteRaw(body []byte) error {
-	noteFieldsNotApplied(ctx.Cmd)
 	_, err := ctx.Writer.Write(body)
 	return err
 }
@@ -102,7 +100,6 @@ func (ctx *RunContext) WriteResultJSON(data any, humanMessage string) error {
 		_, _ = fmt.Fprintln(ctx.Writer, humanMessage)
 		return nil
 	}
-	noteFieldsNotApplied(ctx.Cmd)
 	out, err := marshalStructured(data)
 	if err != nil {
 		return fmt.Errorf("failed to marshal output: %w", err)

internal/cli/gen_support.go

@@ -358,6 +358,7 @@ func printGenericResult(ctx *RunContext, data any) error {
 				return err
 			}
 			noteFieldsMissing(ctx.Cmd, proj)
+			fieldsApplied = true
 			data = proj.out
 			if pp, ok := ctx.Printer.(projectingPrinter); ok {
 				projected := *ctx

internal/cli/outputfields.go

@@ -116,10 +116,17 @@ func noteFieldsMissing(cmd *cobra.Command, p projection) {
 	}
 }
 
-// noteFieldsNotApplied says --fields left a command's structured output as it
-// was: an acknowledgement or a raw (file/CSV) body has no record to project.
+// fieldsApplied records that the global --fields projected something during
+// the current run; the root resets it before each command runs.
+var fieldsApplied bool
+
+// noteFieldsNotApplied runs after every command (root PersistentPostRun) and
+// says so when --fields was given but projected nothing: table output, an
+// acknowledgement, a raw (file/CSV) body, or a command that prints its own
+// text (version, config show). One hook covers every output path, so no
+// command can ignore the flag silently.
 func noteFieldsNotApplied(cmd *cobra.Command) {
-	if flagFields != "" && currentOutputFormat().Structured() {
+	if flagFields != "" && !fieldsApplied {
 		_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "note: --fields does not apply to the output of %q; printed unchanged\n", cmd.CommandPath())
 	}
 }
@@ -150,5 +157,6 @@ func (p projectingPrinter) Print(data any, columns []output.Column) error {
 		return err
 	}
 	noteFieldsMissing(p.cmd, proj)
+	fieldsApplied = true
 	return p.inner.Print(proj.out, nil)
 }

internal/cli/outputfields_test.go

@@ -127,11 +127,32 @@ func TestGlobalFieldsOnAcknowledgement(t *testing.T) {
 	if !strings.Contains(stdout, `"message"`) {
 		t.Errorf("acknowledgement should print unchanged, got %q", stdout)
 	}
-	if !strings.Contains(stderr, `note: --fields does not apply to the output of "flashduty channel disable"; printed unchanged`) {
+	if !strings.Contains(stderr, `note: --fields does not apply to the output of "flashduty channel disable"`) {
 		t.Errorf("want not-applied note, got %q", stderr)
 	}
 }
 
+// TestGlobalFieldsOnSelfPrintedOutput: commands that print their own output
+// (version, config show) and table mode say --fields did not apply instead of
+// ignoring it silently.
+func TestGlobalFieldsOnSelfPrintedOutput(t *testing.T) {
+	for _, args := range [][]string{
+		{"version", "--fields", "version", "--output-format", "json"},
+		{"config", "show", "--fields", "base_url"},
+		{"member", "list", "--fields", "member_id"},
+	} {
+		saveAndResetGlobals(t)
+		newGFStub(t)
+		_, stderr, err := execCommandSplit(args...)
+		if err != nil {
+			t.Fatalf("%v: %v", args, err)
+		}
+		if !strings.Contains(stderr, "note: --fields does not apply to the output of") {
+			t.Errorf("%v: want not-applied note, got %q", args, stderr)
+		}
+	}
+}
+
 // TestLocalFieldsFlagShadowsGlobal: a command whose own --fields is a request
 // field sends it and does not project its output.
 func TestLocalFieldsFlagShadowsGlobal(t *testing.T) {

internal/cli/root.go

@@ -61,6 +61,7 @@ var rootCmd = &cobra.Command{
 		}
 		updateNotice = nil
 		updateCheckWarning = ""
+		fieldsApplied = false
 		if cmd.CommandPath() == cmd.Root().Name()+" update" {
 			return nil
 		}
@@ -89,6 +90,7 @@ var rootCmd = &cobra.Command{
 		return nil
 	},
 	PersistentPostRun: func(cmd *cobra.Command, _ []string) {
+		noteFieldsNotApplied(cmd)
 		if updateCheckWarning != "" {
 			_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "\n%s\n", updateCheckWarning)
 		}

internal/cli/window.go

@@ -42,15 +42,21 @@ var nowFn = time.Now
 // parseWindow parses a curated verb's --since/--until pair into unix seconds
 // and announces the effective window on stderr (see noteWindow). why, when
 // non-empty, says which default produced the window.
+//
+// A defaulted lookback --since ("24h", "30d") spans back from --until, not
+// from now: with --until moved, a now-relative default would stretch the
+// window past the server's 31-day cap (future --until) or invert it (past
+// --until). With --until at its "now" default the two readings coincide.
 func parseWindow(cmd *cobra.Command, since, until, why string) (start, end int64, err error) {
-	start, err = timeutil.Parse(since)
-	if err != nil {
-		return 0, 0, fmt.Errorf("invalid --since: %w", err)
-	}
 	end, err = timeutil.Parse(until)
 	if err != nil {
 		return 0, 0, fmt.Errorf("invalid --until: %w", err)
 	}
+	if span, ok := timeutil.Lookback(since); ok && !cmd.Flags().Changed("since") {
+		start = end - int64(span/time.Second)
+	} else if start, err = timeutil.Parse(since); err != nil {
+		return 0, 0, fmt.Errorf("invalid --since: %w", err)
+	}
 	noteWindow(cmd.ErrOrStderr(), time.Unix(start, 0), time.Unix(end, 0), why)
 	return start, end, nil
 }

internal/cli/window_test.go

@@ -147,6 +147,12 @@ func TestOpenStateDefaultWindow(t *testing.T) {
 		{"alert active", []string{"alert", "list", "--active"}, 30 * day, true},
 		{"alert unfiltered", []string{"alert", "list"}, day, false},
 		{"alert active explicit since", []string{"alert", "list", "--active", "--since", "1h"}, 3600, false},
+		// A defaulted --since spans back from --until, so a moved --until
+		// neither stretches the window past 30d nor inverts it.
+		{"incident triggered future until", []string{"incident", "list", "--progress", "Triggered", "--until", "+1d"}, 30 * day, true},
+		{"alert active future until", []string{"alert", "list", "--active", "--until", "+1d"}, 30 * day, true},
+		{"incident past until", []string{"incident", "list", "--until", "2d"}, day, false},
+		{"incident explicit since and until", []string{"incident", "list", "--since", "3d", "--until", "1d"}, 2 * day, false},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {

internal/timeutil/parse.go

@@ -84,6 +84,21 @@ func Parse(s string) (int64, error) {
 	return 0, fmt.Errorf("unable to parse time %q: expected duration (24h), RFC3339 (2006-01-02T15:04:05Z07:00), date (2006-01-02), datetime (2006-01-02 15:04:05), or unix timestamp in seconds or milliseconds", s)
 }
 
+// Lookback reports the span of a past-relative duration ("24h", "30d") — the
+// form Parse reads as "now minus duration". ok is false for every other form
+// (absolute times, "now", "+" future offsets).
+func Lookback(s string) (d time.Duration, ok bool) {
+	s = strings.TrimSpace(s)
+	if strings.HasPrefix(s, "+") {
+		return 0, false
+	}
+	d, err := time.ParseDuration(expandDays(s))
+	if err != nil || d < 0 {
+		return 0, false
+	}
+	return d, true
+}
+
 // msThreshold is the magnitude cutoff separating a unix timestamp in seconds
 // from one in milliseconds: 100,000,000,000 as seconds is the year 5138, so
 // any input at or above it is treated as milliseconds instead.

internal/timeutil/parse_test.go

@@ -250,3 +250,28 @@ func TestParse(t *testing.T) {
 		})
 	}
 }
+
+// TestLookback: only past-relative durations are lookbacks; "+" future
+// offsets (which Atoi-based day expansion would otherwise accept), "now",
+// dates and unix timestamps are not.
+func TestLookback(t *testing.T) {
+	cases := map[string]struct {
+		want time.Duration
+		ok   bool
+	}{
+		"24h":        {24 * time.Hour, true},
+		"30d":        {30 * 24 * time.Hour, true},
+		" 90m ":      {90 * time.Minute, true},
+		"now":        {0, false},
+		"+1d":        {0, false},
+		"+24h":       {0, false},
+		"2026-04-01": {0, false},
+		"1712000000": {0, false},
+	}
+	for in, tc := range cases {
+		got, ok := Lookback(in)
+		if got != tc.want || ok != tc.ok {
+			t.Errorf("Lookback(%q) = %v, %v; want %v, %v", in, got, ok, tc.want, tc.ok)
+		}
+	}
+}