Merge feat/ai-sre into main — unify the two lineages

internal/cli/alert.go

@@ -120,7 +120,7 @@ func newAlertListCmd() *cobra.Command {
 	cmd.Flags().BoolVar(&muted, "muted", false, "Show ever-muted only")
 	cmd.Flags().StringVar(&since, "since", "24h", "Start time")
 	cmd.Flags().StringVar(&until, "until", "now", "End time")
-	cmd.Flags().IntVar(&limit, "limit", 20, "Max results")
+	cmd.Flags().IntVar(&limit, "limit", 20, "Max results (max 100)")
 	cmd.Flags().IntVar(&page, "page", 1, "Page number")
 	cmd.Flags().StringVar(&fields, "fields", "", "Comma-separated fields to project in json/toon output (e.g. alert_id,title,alert_severity,created_at); ignored in table mode. Use to avoid dumping the full nested record.")
 

internal/cli/alert_event.go

@@ -90,6 +90,8 @@ func newAlertEventListCmd() *cobra.Command {
 					fieldNames := []string{"event_id", "alert_id", "event_severity", "event_status", "event_time", "title"}
 					if fields != "" {
 						fieldNames = parseStringSlice(fields)
+					} else {
+						noteDefaultProjection(cmd.ErrOrStderr(), fieldNames)
 					}
 					proj, err := projectFields(result.Items, fieldNames)
 					if err != nil {
@@ -113,7 +115,7 @@ func newAlertEventListCmd() *cobra.Command {
 	cmd.Flags().StringVar(&integrationType, "integration-type", "", "Comma-separated integration types (plugin keys, e.g. AliCloud,Prometheus) — not integration IDs; use --integration for that")
 	cmd.Flags().StringVar(&since, "since", "1h", "Start time")
 	cmd.Flags().StringVar(&until, "until", "now", "End time")
-	cmd.Flags().IntVar(&limit, "limit", 20, "Max results")
+	cmd.Flags().IntVar(&limit, "limit", 20, "Max results (max 100)")
 	cmd.Flags().IntVar(&page, "page", 1, "Page number")
 	cmd.Flags().StringVar(&fields, "fields", "", "Comma-separated fields to project in json/toon output (e.g. event_id,alert_id,event_severity,event_status,event_time,title); ignored in table mode. Defaults to these compact event fields. Long strings are truncated as needed to keep structured output below 16 KiB.")
 

internal/cli/command_test.go

@@ -87,6 +87,28 @@ func execCommand(args ...string) (string, error) {
 	return buf.String(), err
 }
 
+// execCommandSplit is execCommand with stdout and stderr captured separately,
+// for tests that assert machine-readable stdout stays pure while advisory
+// notices (e.g. the default-projection note) land on stderr.
+func execCommandSplit(args ...string) (stdout, stderr string, err error) {
+	resetCommandFlags(rootCmd)
+
+	outBuf := new(bytes.Buffer)
+	errBuf := new(bytes.Buffer)
+	rootCmd.SetOut(outBuf)
+	rootCmd.SetErr(errBuf)
+	rootCmd.SetArgs(args)
+
+	err = rootCmd.Execute()
+
+	rootCmd.SetArgs(nil)
+	rootCmd.SetOut(nil)
+	rootCmd.SetErr(nil)
+	resetCommandFlags(rootCmd)
+
+	return outBuf.String(), errBuf.String(), err
+}
+
 func resetCommandFlags(cmd *cobra.Command) {
 	if cmd == nil {
 		return

internal/cli/fieldproject.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"fmt"
+	"io"
 	"reflect"
 	"sort"
 	"strings"
@@ -69,6 +70,16 @@ func projectFields(items any, fields []string) ([]map[string]any, error) {
 	return out, nil
 }
 
+// noteDefaultProjection announces on stderr that structured rows were reduced
+// to the command's compact default projection. Without it, a reader piping
+// stdout to jq sees an unselected key (labels, description, …) as null on
+// every row and can conclude the server never returns it, when it is one
+// --fields away. stderr keeps stdout byte-identical for jq/toon pipelines.
+func noteDefaultProjection(w io.Writer, fields []string) {
+	_, _ = fmt.Fprintf(w, "note: rows projected to default compact fields (%s); other response fields are available via --fields\n",
+		strings.Join(fields, ","))
+}
+
 // boundProjectedOutput keeps the new agent-oriented projections below their
 // command budget without changing the selected keys. List rows (many small
 // records) are shortened fairly when they overflow the budget, with

internal/cli/fieldproject_test.go

@@ -213,29 +213,37 @@ func TestIncidentListStructuredDefaultUsesCompactProjection(t *testing.T) {
 		stub := newGFStub(t)
 		stub.data = map[string]any{"items": []any{incidentRow()}, "total": 1}
 
-		out, err := execCommand("incident", "list", "--output-format", "json")
+		out, stderrText, err := execCommandSplit("incident", "list", "--output-format", "json")
 		if err != nil {
-			t.Fatalf("execCommand: %v", err)
+			t.Fatalf("execCommandSplit: %v", err)
 		}
 
 		assertProjectedJSONFields(t, out, []string{"incident_id", "title", "incident_severity", "progress", "start_time", "channel_id"})
+		if !strings.Contains(stderrText, "note: rows projected to default compact fields") {
+			t.Errorf("default projection should announce itself on stderr, got:\n%s", stderrText)
+		}
 	})
 
 	t.Run("toon default", func(t *testing.T) {
 		saveAndResetGlobals(t)
 		stub := newGFStub(t)
 		stub.data = map[string]any{"items": []any{incidentRow()}, "total": 1}
 
-		out, err := execCommand("incident", "list", "--output-format", "toon")
+		out, stderrText, err := execCommandSplit("incident", "list", "--output-format", "toon")
 		if err != nil {
-			t.Fatalf("execCommand: %v", err)
+			t.Fatalf("execCommandSplit: %v", err)
 		}
 
+		// Positive keys must come from stdout alone: the stderr note embeds the
+		// same field names, so a merged capture would satisfy this vacuously.
 		for _, key := range []string{"incident_id", "title", "incident_severity", "progress", "start_time", "channel_id"} {
 			if !strings.Contains(out, key) {
 				t.Errorf("default toon output missing compact key %q, got:\n%s", key, out)
 			}
 		}
+		if !strings.Contains(stderrText, "note: rows projected to default compact fields") {
+			t.Errorf("default projection should announce itself on stderr, got:\n%s", stderrText)
+		}
 		for _, key := range []string{"responders", "labels", "description"} {
 			if strings.Contains(out, key) {
 				t.Errorf("default toon output should not contain full-record key %q, got:\n%s", key, out)
@@ -489,13 +497,16 @@ func TestIncidentSimilarStructuredProjection(t *testing.T) {
 	}
 	stub.data = map[string]any{"items": items, "total": len(items)}
 
-	out, err := execCommand("incident", "similar", "inc-1", "--limit", "20", "--output-format", "json")
+	out, stderrText, err := execCommandSplit("incident", "similar", "inc-1", "--limit", "20", "--output-format", "json")
 	if err != nil {
-		t.Fatalf("execCommand: %v", err)
+		t.Fatalf("execCommandSplit: %v", err)
 	}
 	if len(out) >= 16*1024 {
 		t.Fatalf("compact similar output is %d bytes, want <16 KiB", len(out))
 	}
+	if !strings.Contains(stderrText, "note: rows projected to default compact fields") {
+		t.Errorf("default projection should announce itself on stderr, got:\n%s", stderrText)
+	}
 
 	var rows []map[string]json.RawMessage
 	if err := json.Unmarshal([]byte(strings.TrimSpace(out)), &rows); err != nil {
@@ -614,13 +625,16 @@ func TestAlertEventListStructuredProjection(t *testing.T) {
 	}
 	stub.data = map[string]any{"items": items, "total": len(items)}
 
-	out, err := execCommand("alert-event", "list", "--limit", "30", "--output-format", "json")
+	out, stderrText, err := execCommandSplit("alert-event", "list", "--limit", "30", "--output-format", "json")
 	if err != nil {
-		t.Fatalf("execCommand: %v", err)
+		t.Fatalf("execCommandSplit: %v", err)
 	}
 	if len(out) >= 16*1024 {
 		t.Fatalf("compact alert-event output is %d bytes, want <16 KiB", len(out))
 	}
+	if !strings.Contains(stderrText, "note: rows projected to default compact fields") {
+		t.Errorf("default projection should announce itself on stderr, got:\n%s", stderrText)
+	}
 	var rows []map[string]json.RawMessage
 	if err := json.Unmarshal([]byte(strings.TrimSpace(out)), &rows); err != nil {
 		t.Fatalf("parse compact alert-event json: %v\n%s", err, out)

internal/cli/incident.go

@@ -120,6 +120,8 @@ func newIncidentListCmd() *cobra.Command {
 						if len(selectedFields) == 0 {
 							return fmt.Errorf("--fields must name at least one field")
 						}
+					} else {
+						noteDefaultProjection(cmd.ErrOrStderr(), selectedFields)
 					}
 					proj, err := projectFields(result.Items, selectedFields)
 					if err != nil {
@@ -605,6 +607,8 @@ func newIncidentSimilarCmd() *cobra.Command {
 					fieldNames := []string{"incident_id", "title", "incident_severity", "progress", "start_time", "close_time", "ack_time", "alert_cnt", "root_cause", "score"}
 					if fields != "" {
 						fieldNames = parseStringSlice(fields)
+					} else {
+						noteDefaultProjection(cmd.ErrOrStderr(), fieldNames)
 					}
 					proj, err := projectFields(result.Items, fieldNames)
 					if err != nil {

internal/cli/insight.go

@@ -138,7 +138,7 @@ func newInsightIncidentsCmd() *cobra.Command {
 
 	cmd.Flags().StringVar(&since, "since", "7d", "Start time")
 	cmd.Flags().StringVar(&until, "until", "now", "End time")
-	cmd.Flags().IntVar(&limit, "limit", 20, "Max results")
+	cmd.Flags().IntVar(&limit, "limit", 20, "Max results (max 100)")
 	cmd.Flags().IntVar(&page, "page", 1, "Page number")
 
 	return cmd