refactor(cli): flatten grouped categories to []T in json/jsonl/yaml

Some `toolkit get -o json` outputs were returning objects
({"pool-a": [...], "pool-b": [...]}) and others arrays, mirroring
the Go shape of the underlying loader (map vs slice). Inconsistent
for consumers and an early leak that the upcoming MCP layer would
inherit.

Add output.FlattenWithKey[T](map[string][]T, groupField) which
round-trips each element through JSON and injects the map key into
each object under groupField (sorted-key iteration for determinism).

writeMap now flattens for json/jsonl/yaml; the table path keeps the
grouped input because the per-category renderer needs the group
column. Group field names per category:

  GpuNode/GpuNodeMap          -> "pool"
  DAC/DedicatedAIClusterMap   -> "tenant"
  ModelArtifact/.../Map       -> "model"
  TenancyOverride (3 kinds)   -> "tenant"

CLI consumers and the future MCP server now see a uniform Array<T>
for every category, with the group key carried in a named field.
The TUI is unaffected (it operates on the typed maps directly).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jingle2008

internal/cli/get.go

@@ -203,13 +203,13 @@ func emitCategory(
 		if err != nil {
 			return fmt.Errorf("load gpu nodes: %w", err)
 		}
-		return writeMap(w, filterMap(grouped, filter), opts, gpuNodeTable)
+		return writeMap(w, filterMap(grouped, filter), opts, gpuNodeTable, "pool")
 	case domain.DedicatedAICluster:
 		grouped, err := ld.LoadDedicatedAIClusters(ctx, cfg.KubeConfig, env)
 		if err != nil {
 			return fmt.Errorf("load dedicated AI clusters: %w", err)
 		}
-		return writeMap(w, filterMap(grouped, filter), opts, dacTable)
+		return writeMap(w, filterMap(grouped, filter), opts, dacTable, "tenant")
 	case domain.Tenant,
 		domain.LimitTenancyOverride,
 		domain.ConsolePropertyTenancyOverride,
@@ -273,19 +273,25 @@ func writeSlice[T any](
 	}
 }
 
+// writeMap renders a grouped slice. For json/jsonl/yaml the input is
+// flattened to []map[string]any with `groupField` carrying the original
+// map key, so consumers see a uniform array of objects (matches the
+// shape MCP tools return). The table path keeps the grouped input so
+// the per-category renderer can show a group column.
 func writeMap[T any](
 	w writer,
 	grouped map[string][]T,
 	opts output.Options,
 	toTable func(map[string][]T) (headers []string, rows [][]string),
+	groupField string,
 ) error {
 	switch opts.Format {
 	case output.FormatJSON:
-		return output.WriteJSON(w, grouped, opts)
+		return output.WriteJSON(w, output.FlattenWithKey(grouped, groupField), opts)
 	case output.FormatJSONL:
-		return output.WriteJSONL(w, grouped, opts)
+		return output.WriteJSONL(w, output.FlattenWithKey(grouped, groupField), opts)
 	case output.FormatYAML:
-		return output.WriteYAML(w, grouped, opts)
+		return output.WriteYAML(w, output.FlattenWithKey(grouped, groupField), opts)
 	case output.FormatTable:
 		headers, rows := toTable(grouped)
 		return output.WriteTable(w, headers, rows, opts)
@@ -313,13 +319,13 @@ func emitTenancyGroup(
 		return writeSlice(w, collections.FilterSlice(group.Tenants, nil, filter, nil), opts, tenantTable)
 	case domain.LimitTenancyOverride:
 		return writeMap(w, filterMap(group.LimitTenancyOverrideMap, filter), opts,
-			tenancyOverrideTable[models.LimitTenancyOverride])
+			tenancyOverrideTable[models.LimitTenancyOverride], "tenant")
 	case domain.ConsolePropertyTenancyOverride:
 		return writeMap(w, filterMap(group.ConsolePropertyTenancyOverrideMap, filter), opts,
-			tenancyOverrideTable[models.ConsolePropertyTenancyOverride])
+			tenancyOverrideTable[models.ConsolePropertyTenancyOverride], "tenant")
 	case domain.PropertyTenancyOverride:
 		return writeMap(w, filterMap(group.PropertyTenancyOverrideMap, filter), opts,
-			tenancyOverrideTable[models.PropertyTenancyOverride])
+			tenancyOverrideTable[models.PropertyTenancyOverride], "tenant")
 	default:
 		return fmt.Errorf("category %s not in tenancy group", cat)
 	}
@@ -354,7 +360,7 @@ func emitFromDataset(
 			collections.FilterSlice(dataset.ServiceTenancies, nil, filter, nil),
 			opts, serviceTenancyTable)
 	case domain.ModelArtifact:
-		return writeMap(w, filterMap(dataset.ModelArtifactMap, filter), opts, modelArtifactTable)
+		return writeMap(w, filterMap(dataset.ModelArtifactMap, filter), opts, modelArtifactTable, "model")
 	case domain.Alias:
 		return writeAliases(w, filter, opts)
 	default:

internal/cli/output/output.go

@@ -12,6 +12,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"sort"
 	"strings"
 	"text/tabwriter"
 
@@ -135,6 +136,39 @@ func WriteYAML(w io.Writer, items any, opts Options) error {
 	return enc.Encode(items)
 }
 
+// FlattenWithKey turns a map[string][]T into []map[string]any, injecting
+// the map key into each element under groupField. Used to expose grouped
+// loader data (e.g. GpuNodeMap, DedicatedAIClusterMap) as a uniform
+// array of objects without leaking the underlying map shape to MCP /
+// JSON consumers.
+//
+// The output is stable: map keys are sorted before iteration. The
+// implementation round-trips through JSON so the caller's struct tags
+// (omitempty, custom names, etc.) are honored.
+func FlattenWithKey[T any](grouped map[string][]T, groupField string) []map[string]any {
+	keys := make([]string, 0, len(grouped))
+	for k := range grouped {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	var out []map[string]any
+	for _, k := range keys {
+		for _, v := range grouped[k] {
+			raw, err := json.Marshal(v)
+			if err != nil {
+				continue
+			}
+			var m map[string]any
+			if err := json.Unmarshal(raw, &m); err != nil {
+				continue
+			}
+			m[groupField] = k
+			out = append(out, m)
+		}
+	}
+	return out
+}
+
 // WriteTable emits a tab-aligned table. opts.NoHeaders suppresses the
 // header row even when headers is non-empty.
 func WriteTable(w io.Writer, headers []string, rows [][]string, opts Options) error {