Olares Dashboard (olares-cli dashboard)

dashboard (overview + applications, AI-agent first)

CRITICAL — before doing ANYTHING in this subtree, MUST Read ../olares-shared/SKILL.md for profile selection, login, factory-injected *http.Client, and HTTP 401/403 recovery rules. Every dashboard verb depends on that foundation.

This file is the source of truth for the dashboard subtree. Any code generation, refactor or fix touching cli/cmd/ctl/dashboard/, cli/pkg/dashboard/, cli/pkg/dashboard/format/, cli/pkg/olares/id.go::DashboardURL, or cli/pkg/credential/{types,default_provider}.go::DashboardURL MUST first Read this file end-to-end and respect the Iteration red-lines** section. Do not "modernize", "simplify" or "consolidate" anything listed under Frozen modules without an explicit user-approved plan that supersedes this skill.

Scope (frozen)

The dashboard CLI mirrors only the SPA routes that are still wired in packages/app/src/apps/dashboard/router/routes.ts:

Everything else in the SPA (legacy Overview/, audit, settings, …) is out of scope. Do not add commands for deprecated routes; reject any request that asks for them with a pointer to the route file.

Architecture

The dashboard CLI is a **two-layer split with mirrored subpackage trees on BOTH sides**:

Every fetch / merge / aggregate / format call goes through pkg — either the root infra or, for envelope assembly, the matching pkg subpackage. The cmd shell never touches HTTP, never builds an envelope, never writes a table, never runs Runner directly.

flowchart LR
    User[olares-cli dashboard ] --> Factory[cmdutil.Factory
refreshingTransport]
    Factory --> CmdShell["cli/cmd/ctl/dashboard/<area>/<leaf>.go
(thin cobra shell:
validate → prepareClient →
pkg<area>.RunXxx)"]
    CmdShell --> PkgArea["cli/pkg/dashboard/<area>/<leaf>.go
(RunXxx + BuildXxxEnvelope +
WriteXxxTable + watch loop)"]
    PkgArea --> PkgRoot["cli/pkg/dashboard/
(infra: Envelope, Client, Runner,
fetchers, aggregators, gates, schema)"]
    PkgRoot -->|/capi/* + /kapis/* + /hami/*| BFF["dashboard.<terminus>
(ks-apiserver-proxy)"]
    BFF -->|wildcard proxy| KsAPI[ks-apiserver]
    PkgRoot --> Format["cli/pkg/dashboard/format
(1:1 JS port)"]
    PkgArea --> Output["WriteJSON / WriteTable
(pkgdashboard.*)"]
    Output --> User

cmd area ↔ pkg subpackage mapping — every cmd leaf is a thin prepareClient + pkg.RunXxx(...) shell. The heavy logic (envelope builders, table writers, fan-out, watch loops) lives in a mirror subpackage under cli/pkg/dashboard//. The pkg root (cli/pkg/dashboard/) only owns infrastructure and shared fetchers.

| cmd area | pkg subpackage entry points (Run*) | shared infra it pulls from cli/pkg/dashboard/ | |---|---|---| | cmd/ctl/dashboard/root.go + options.go | n/a — pure cobra wiring + bindPersistentFlags | flags.go (CommonFlags), runner.go, emit.go, output.go | | cmd/ctl/dashboard/applications/root.go | pkg/dashboard/applications/list.go → RunList | ranking.go, workloads.go, apps.go, format/... | | cmd/ctl/dashboard/overview/{physical,user,ranking,root}.go | pkg/dashboard/overview/{physical,user,ranking,default}.go → RunPhysical/RunUser/RunRanking/RunDefault | monitoring.go, workloads.go, ranking.go, users.go, numbers.go | | cmd/ctl/dashboard/overview/{cpu,memory,pods,network}.go | pkg/dashboard/overview/{cpu,memory,pods,network}.go → RunCPU/RunMemory/RunPods/RunNetwork (built on nodes.go's RunPerNodeMetric scaffold) | monitoring.go, system.go (network → capi /system/ifs), numbers.go | | cmd/ctl/dashboard/overview/disk/{root,main,partitions}.go | pkg/dashboard/overview/disk/{default,main,partitions}.go → RunDefault/RunMain/RunPartitions | monitoring.go (node\_disk\_*), lsblk.go, numbers.go, format/... | | cmd/ctl/dashboard/overview/fan/{root,live,curve}.go | pkg/dashboard/overview/fan/{default,live,curve}.go → RunDefault/RunLive/RunCurve | system.go (FetchSystemFan), gates.go (GateOlaresOne), gpu.go (graphics list co-render), fan_curve.go | | cmd/ctl/dashboard/overview/gpu/{root,list,tasks,get,task,detail,task_detail}.go | pkg/dashboard/overview/gpu/{list,tasks,get,task,detail,task_detail}.go → RunList/RunTasks/RunGet/RunTask/RunDetail/RunTaskDetail (+ specs.go for the gauge/trend catalogue and concurrent fan-out) | gpu.go, gpu_format.go, gpu_query.go, gates.go, client.go | | cmd/ctl/dashboard/schema/root.go | n/a — schema loader stays in pkg root | schema.go (loader + go:embed bundle) |

JSON envelope (frozen shapes)

Every dashboard command emits exactly one of two shapes; the choice is fixed per command and MUST NOT be changed.

Shape A — leaf

Used by every command except parent commands with a sections envelope (see Shape B).

{
  "kind":  "dashboard..",
  "meta":  { "fetched_at": "...", "iteration": 0, "recommended_poll_seconds": 60, "empty": false, "empty_reason": "", "error": "", "http_status": 200 },
  "items": [ { "raw": { /* upstream-shape, units in source unit */ }, "display": { /* table-friendly strings */ } } ]
}

Shape B — sections envelope

Used by parent commands that aggregate multiple sub-views:

| Parent command | Sections | Section kinds | |---|---|---| | dashboard overview | physical / user / ranking | dashboard.overview.physical / .user / .ranking | | dashboard overview disk| main / partitions | dashboard.overview.disk.main / .partitions (the latter is itself a sections envelope, keyed by device) | | dashboard overview fan | live / curve | dashboard.overview.fan.live / .curve | | dashboard schema | n/a — emits Shape A index | dashboard.schema.index |

{
  "kind": "dashboard.overview",
  "meta": { ... },
  "sections": {
    "physical": { "kind": "dashboard.overview.physical", "meta": {...}, "items": [...] },
    "user":     { "kind": "dashboard.overview.user",     "meta": {...}, "items": [...] },
    "ranking":  { "kind": "dashboard.overview.ranking",  "meta": {...}, "items": [...] }
  }
}

Kind constants

Declared in cli/pkg/dashboard/schema.go. AllKinds() MUST stay 1:1 with the actual command surface. Adding a command means:

1. Add a KindXxx constant in pkg/dashboard/schema.go. 2. Append it to AllKinds() (same file). 3. Add cli/pkg/dashboard/schemas/.json. 4. Register in LoadSchemaIndex() (same file). 5. Bump golden tests if the new shape appears in fixtures. 6. Add a leaf file in the matching cmd/ctl/dashboard// subdirectory and AddCommand it from the area's root.go.

Do NOT rename existing Kind values — agents rely on string equality.

The authoritative listing of every command, its envelope shape, and its default-action semantics is the cmd/pkg directory tree itself (see File layout) and olares-cli dashboard --help. Run olares-cli dashboard schema -o json for the live dashboard.. Kind index.

Frozen modules

The following are load-bearing. Touching them requires a separate user-confirmed plan; otherwise reject the request with this list.

| Frozen module | Why it's frozen | Where | |---|---|---| | Two-layer split with mirrored cmd/ ↔ pkg/dashboard/ subpackages: cmd is a thin cobra shell that calls pkg.RunXxx(...); pkg owns every envelope builder, table writer, watch loop and fan-out. The pkg root holds only infrastructure + shared fetchers. | Architectural decision (P1–P7); each leaf's heavy logic is testable directly via RunXxx without dragging cobra in, and cmd-side line budgets stay flat as the surface grows | cli/cmd/ctl/dashboard/ + cli/pkg/dashboard/ | | Directory tree mirrors command tree on BOTH sides | One file per leaf in cmd (.go) AND in the matching pkg subpackage (.go exposing one RunXxx entry); root.go+common.go per cmd parent, default.go per pkg parent — prevents drift between dashboard --help, the cmd ls, and the pkg ls | every cmd subdirectory under cli/cmd/ctl/dashboard/ and every pkg subpackage under cli/pkg/dashboard// | | Kind constants + AllKinds() | Public agent contract | pkg/dashboard/schema.go | | Envelope shapes A / B | Public agent contract | pkg/dashboard/output.go | | format pkg signatures + JS-parity behaviour | Backed by golden.json oracle; even rounding quirks are intentional | pkg/dashboard/format/format.go | | FetchClusterMetrics / FetchNodeMetrics / FetchUserMetric shared fetchers | Single upstream call powers multiple commands; must not fork | pkg/dashboard/monitoring.go | | FetchWorkloadsMetrics dual-fetch + merge + BuildRankingEnvelope | Single pkg function powers overview ranking + applications first-row parity; keep the dual-fetch shape | pkg/dashboard/workloads.go, pkg/dashboard/ranking.go | | FetchSystemIFS / FetchSystemFan / graphics+task helpers | Wire shape pinned in tests; capi vs hami URL prefixes are part of the contract | pkg/dashboard/system.go, pkg/dashboard/gpu.go | | FanCurveTable + FanSpeedMaxCPU + FanSpeedMaxGPU constants | 1:1 with SPA Fan/config.ts.tableData; CLI ships them as Go constants because the SPA does too | pkg/dashboard/fan_curve.go | | Parent-command default = sections envelope (overview, overview disk, overview fan) | Plan decision; consumers branch on kind == "dashboard.overview.*" to know whether to expect sections or items | overview/root.go, overview/disk/root.go, overview/fan/root.go | | Runner + --watch semantics (interval / iterations / timeout / 3-consecutive-failure exit / NDJSON per-iteration / SIGINT graceful / ErrTokenInvalidated short-circuit) | Plan decision; agents script around it | pkg/dashboard/runner.go | | --since vs --start --end mutual-exclusion + sliding-window rules | Plan decision (since_slides_abs_repeats) | pkg/dashboard/flags.go Validate / ResolveWindow | | Three-state empty-data semantics | Distinguishes "feature not installed" from "no hardware" without throwing | overview gpu {list,tasks} / overview fan live (cmd) ↔ pkg/dashboard/gates.go | | Client.EnsureUser sync.Once cache + RequireAdmin / ResolveTargetUser guards | Auth correctness for --user / overview user | pkg/dashboard/client.go | | ResolvedProfile.DashboardURL derivation chain | URL is derived, not configured | cli/pkg/olares/id.go, cli/pkg/credential/types.go, cli/pkg/credential/default_provider.go | | Cobra SilenceUsage = true + SilenceErrors = true on every dashboard cmd | Clean machine-readable error text; pinned by TestAllLeafCommandsSilenced in cmd-root | every cobra.Command literal under cmd/ctl/dashboard/ | | Default output = table | Plan decision (table_default) | pkg/dashboard/output.go ParseOutputFormat | | Dependency direction (cmd side) — cli/cmd/ctl/dashboard/ may import cli/pkg/dashboard, cli/pkg/dashboard//..., and its own cobra children only; horizontal cmd↔cmd imports are FORBIDDEN. The cmd shell is forbidden from owning envelope shapes / table writers / fan-out — those belong in the matching pkg/dashboard/ subpackage. | Architectural integrity; prevents the circular-import class of bugs that killed the 1.x layout, and keeps the cmd surface trivially line-budgeted | every import block under cli/cmd/ctl/dashboard/ | | Dependency direction (pkg side) — cli/pkg/dashboard//... may import cli/pkg/dashboard (the root infra: Client, Runner, fetchers, format, numbers, gpu_format, gpu_query, gates, schema, output, emit, lsblk, fan_curve); the pkg root MUST NOT import any subpackage (no upward import). Sibling subpackages (e.g. overview/disk ↔ overview/fan) MUST NOT import each other — if two areas need the same heavy helper, hoist it to cli/pkg/dashboard/ (the BuildRankingEnvelope precedent). | Keeps the pkg root independently testable + reusable, and keeps each subpackage a self-contained mirror of its cmd sibling | every import block under cli/pkg/dashboard/ |

Three-state empty data

Optional hardware (GPU / fan) and optional integrations have three legitimate "empty" states; the CLI distinguishes them in meta.empty_reason so agents can branch without parsing prose.

| Upstream response | meta.empty | meta.empty_reason | Example | |---|---|---|---| | HTTP 404 | true | no__integration | HAMI vGPU not installed → dashboard overview gpu list | | HTTP 200, empty body / empty metric | true | no__detected | Server has no fans → dashboard overview fan live | | HTTP 200, non-empty | false | "" | Normal case | | Any other 4xx/5xx | n/a (envelope meta.error) | n/a | Real failure → propagate via watch error path |

Forbidden: turning a 404 into an error, or merging the two reasons into a single "empty=true" — agents currently key on the reason.

Capability gates (overview fan / overview gpu)

The fan / gpu subtrees mirror the SPA's gates — but with **two different strengths** because the SPA itself treats them differently:

| Subtree | Gate strength | Source check | |---|---|---| | overview fan * (default / live / curve) | Hard — empty envelope before any fetch | Fan.ts:67 (isOlaresOneDevice); fan data is meaningless on non-Olares One hardware | | overview gpu * (list / tasks / get / task) | Soft — advisory meta.note + stderr hint, then proceed with the HAMI fetch | ClusterResource.vue:232+278 hides the sidebar entry for non-admins / no-CUDA clusters; the GPU detail pages themselves do not hard-block |

Hard gate (fan) — empty envelope shape

{
  "kind": "dashboard.overview.fan.live",
  "meta": {
    "empty": true,
    "empty_reason": "not_olares_one",
    "note": "Fan / cooling integration is only available on Olares One devices",
    "device_name": "DIY-PC",
    "fetched_at": "..."
  },
  "items": []
}

Soft gate (gpu) — advisory, not a block

The CLI ALWAYS calls HAMI for GPU verbs. The SPA-equivalent "would-have-been-hidden" reason is recorded as meta.note and (in table mode) as a one-liner on stderr. The actual meta.empty / empty_reason are determined by HAMI's response:

// non-admin caller, HAMI returned an empty list:
{
  "kind": "dashboard.overview.gpu.list",
  "meta": {
    "empty": true,
    "empty_reason": "no_gpu_detected",
    "note": "GPU sidebar entry is hidden for non-admin profiles in the SPA; HAMI was queried directly",
    ...
  },
  "items": []
}
// any caller, HAMI returned 5xx:
{
  "kind": "dashboard.overview.gpu.list",
  "meta": {
    "empty": true,
    "empty_reason": "vgpu_unavailable",
    "http_status": 500,
    "error": "unknown request error",
    "note": "HAMI vGPU controller responded with Internal Server Error; the integration is installed but unhealthy",
    ...
  },
  "items": []
}

empty_reason taxonomy:

| Reason | Where | Meaning | |---|---|---| | not_olares_one | fan default / live / curve (hard gate) | Active device's device_name is not Olares One | | no_fan_integration | fan live (HTTP 404 fallback) | /user-service/api/mdns/olares-one/cpu-gpu returned 404 | | no_vgpu_integration | gpu list / tasks / get / task (HTTP 404) | HAMI vGPU controller absent | | vgpu_unavailable | gpu list / tasks / get / task (HTTP 5xx) | HAMI installed but unhealthy. meta.error carries the upstream message; meta.http_status carries the original status | | no_gpu_detected | gpu list / tasks / get / task (HTTP 200, empty body) | HAMI healthy but device list / detail is empty |

Soft-gate advisories never appear as empty_reason; they live in meta.note:

| Note | When | |---|---| | GPU sidebar entry is hidden for non-admin profiles in the SPA; HAMI was queried directly | meta.user.globalrole != platform-admin (and not admin) | | no node carries gpu.bytetrade.io/cuda-supported=true; SPA hides the GPU card. HAMI was queried directly | Admin caller, but the cluster's node list has no CUDA-supported label |

When BOTH a HAMI failure AND a soft advisory apply, meta.note is the concatenation " | ".

HAMI wire-shape contract (paid in blood)

HAMI's WebUI returns the payload at the top level for every endpoint we call — there is no data envelope around it. Adding one in the decoder yields a silent "0 GPUs" / "0 tasks" failure even on machines where the SPA shows devices.

| Endpoint | Real wire shape | Decoder target | |---|---|---| | POST /hami/api/vgpu/v1/gpus | {"list":[ {graphics...} ]} | struct{ List []map[string]any }, return raw.List | | POST /hami/api/vgpu/v1/containers | {"items":[ {task...} ]} | struct{ Items []map[string]any }, return raw.Items | | GET /hami/api/vgpu/v1/gpu?uuid=… | { ...graphics fields... } | map[string]any, return verbatim | | GET /hami/api/vgpu/v1/container?name=…&podUid=… | { ...task fields... } | map[string]any, return verbatim |

The fetchers in pkg/dashboard/gpu.go are pinned to this shape; TestFetchGraphicsList_ParsesTopLevelList / TestFetchTaskList_ParsesTopLevelItems / TestFetchGraphicsDetail_ReturnsBodyAsIs / TestFetchTaskDetail_ReturnsBodyAsIs enforce the contract (in cli/pkg/dashboard/dashboard_test.go).

GPU/task field names that round-trip from HAMI (used in Raw envelopes — agents can pull anything not surfaced in the table):

| gpu list raw fields | gpu tasks raw fields | |---|---| | uuid, type, shareMode, nodeName, nodeUid, health (bool), coreUtilizedPercent (already a percent — NOT a 0..1 ratio), coreUsed, coreTotal, memoryUsed / memoryUtilized / memoryTotal (all MiB), memoryUtilizedPercent, vgpuUsed, vgpuTotal, power, powerLimit (W), temperature (°C), node, mode | name, status, podUid, nodeName, nodeUid, type, deviceShareModes[], devicesCoreUtilizedPercent[], devicesMemUtilized[], allocatedDevices, allocatedCores, allocatedMem, createTime, startTime, endTime, namespace, deviceIds[], resourcePool, flavor, priority, appName |

Common renames the SPA does NOT do (we don't either — earlier revisions guessed at e.g. modelName / hostname / usedMem / totalMem / coreUtilization / sharemode; none of those field names appear on the wire):

Monitor query endpoints (instant-vector / range-vector)

The wire-shape contract above ONLY covers the list/detail endpoints. The two monitor query endpoints behave the opposite way — they DO wrap the result in a single-level data envelope, matching the SPA's InstantVectorResponse / RangeVectorResponse types in packages/app/src/apps/dashboard/types/gpu.ts.

| Endpoint | Wire shape | Decoder | |---|---|---| | POST /hami/api/vgpu/v1/monitor/query/instant-vector | {"data":[ {metric, value, timestamp} ]} | struct{ Data []instantVectorSample }, return raw.Data | | POST /hami/api/vgpu/v1/monitor/query/range-vector | {"data":[ {metric, values:[{value, timestamp}]} ]} | struct{ Data []rangeVectorSeries }, return raw.Data |

Both fetchers (fetchInstantVector / fetchRangeVector) are pinned by TestFetchInstantVector_ParsesDataEnvelope / TestFetchRangeVector_ParsesDataEnvelope. Do NOT "harmonise" with the list endpoints — different microservices behind HAMI, different wire shapes, period.

Range body shape: {"query":"","range":{"start":"YYYY-MM-DD HH:mm:ss","end":"…","step":"30m"}}. start/end are SPA's timeParse(date) (local clock, no offset suffix); the step is computed by gpuTrendStep(start, end) — a 1:1 port of timeRangeFormate(diff_s, 16) which preserves the SPA's preset table (10m→1m, 60m→10m, 480m→30m, 1440m→60m, etc.) and falls back to floor(minutes/16)m capped at [1m..60m].

dashboard overview gpu detail / task-detail — full detail pages

Two new commands mirror the SPA's Overview2/GPU/GPUsDetails.vue and Overview2/GPU/TasksDetails.vue pages: basic info (HAMI /v1/gpu or /v1/container) + top gauges (instant-vector) + trend charts (range-vector), all assembled into a single sections envelope.

| Command | Kind | Default window | Sections | PromQL count | |---|---|---|---|---| | overview gpu detail | dashboard.overview.gpu.detail.full | 8h | detail / gauges / trends | 4 instant + 6 range | | overview gpu task-detail [--sharemode] | dashboard.overview.gpu.task.detail.full | 1h | detail / gauges / trends | 2 instant + 2 range |

Section item ordering is fixed and stable across releases — agents can index by position OR by raw.key:

GPU detail.full gauges keys (in order): alloc_core / alloc_mem / util_core / util_mem / power / temperature. GPU detail.full trends keys (in order): alloc_trend (lines: core+memory) / usage_trend (core+memory) / power_trend / temp_trend.

Task task-detail.full gauges keys (in order): compute_usage / vram_usage. Task task-detail.full trends keys (in order): compute_trend / vram_trend (each one line, label usage).

Time window flags reuse the existing --since / --start / --end. With neither set the SPA defaults apply (8h for GPU detail, 1h for task detail). meta.window carries {since, start, end, step} so an agent can replay the exact same query without recomputing.

--sharemode on task-detail mirrors the SPA's displayAllocation toggle: when set to "2" (Time slicing) the CLI skips the allocation gauges, matching the SPA's hidden-rows behaviour. Other values ("0", "1") keep the full gauge set. Pinned by TestBuildGPUTaskDetailFullEnvelope_TimeSlicingSkipsAllocation.

Soft-failure semantics — a single instant/range query failing does NOT abort the envelope:

Hard-failure semantics still apply on the detail fetch itself: HAMI 404 → empty_reason=no_vgpu_integration, 5xx → vgpu_unavailable (meta.error + meta.http_status), 200 with empty body → no_gpu_detected. Watch mode polls every 30s by default (Recommended = 30 * time.Second — the monitor endpoints are slower than plain Prom queries).

device_no / driver_version are surfaced on the detail item — the CLI mirrors the SPA's trick of harvesting them from the power_trend range query's metric labels (HAMI doesn't ship them on /v1/gpu).

Behavior contract:

inspect meta.empty + meta.empty_reason + meta.note  →
  not_olares_one        → skip the fan subtree on this device
  no_*_integration      → upstream component absent (HAMI / capi system fan)
  vgpu_unavailable      → transient: retry; check meta.http_status / meta.error
  no_*_detected         → integration up but hardware empty
  (none) + meta.note    → data is present but the SPA would have hidden the entry; surface the note to the user
  (none) + (no note)    → items[] populated, proceed normally

flowchart TD
    A[invoke leaf cmd] --> B{--watch set?}
    B -- no --> C[RunOnce → emit one envelope → exit 0/1]
    B -- yes --> D[Runner.Run]
    D --> E[RunOnce iteration N]
    E --> F{success?}
    F -- yes --> G[emit envelope NDJSON line
meta.iteration=N]
    F -- transient err --> H[emit envelope NDJSON
meta.error set, items:[]]
    F -- ErrTokenInvalidated / ErrNotLoggedIn --> X[exit non-zero immediately]
    G --> I{--watch-iterations cap reached?}
    H --> J{N consecutive errors >= 3?}
    J -- yes --> X
    I -- yes --> Y[exit 0]
    J -- no --> K[wait --watch-interval]
    I -- no --> K
    K --> L{SIGINT?}
    L -- yes --> Y
    L -- no --> E

// Package  hosts the cobra wiring for olares-cli dashboard ;
// business logic lives in cli/pkg/dashboard//.
package 
import (
    "context"
    "fmt"
    "strings"
    "github.com/spf13/cobra"
    "github.com/beclab/Olares/cli/pkg/cmdutil"
    pkgdashboard "github.com/beclab/Olares/cli/pkg/dashboard"
)
// common is wired by NewXxxCommand; cobra's persistent-flag inheritance
// mutates the pointed-at struct before any leaf RunE fires.
var common *pkgdashboard.CommonFlags
// prepareClient is the area-private *pkgdashboard.Client factory.
func prepareClient(ctx context.Context, f *cmdutil.Factory) (*pkgdashboard.Client, error) { /* ResolveProfile + HTTPClient + NewClient */ }
// unknownSubcommandRunE prints a typed typo hint + returns ErrAlreadyReported.
func unknownSubcommandRunE(c *cobra.Command, args []string) error { /* SuggestionsFor + ErrAlreadyReported */ }

olares-cli dashboard overview -o json | jq '.sections.user.items[0].raw.utilisation'

olares-cli dashboard overview cpu --watch --watch-iterations 2 -o json

olares-cli dashboard overview cpu --watch --since 5m --watch-interval 10s -o json

olares-cli dashboard overview cpu --start 2026-04-28T08:00:00Z --end 2026-04-28T08:30:00Z -o json

olares-cli dashboard overview disk -o json | jq '.sections.partitions.sections | keys'
olares-cli dashboard overview disk partitions sda -o json

olares-cli dashboard overview fan -o json | jq '.sections.curve.items | length'   # → 10
olares-cli dashboard overview fan live --watch --watch-iterations 5 -o json

olares-cli dashboard overview gpu list -o json
olares-cli dashboard overview gpu tasks -o json
olares-cli dashboard overview gpu get GPU-0123abcd -o json
olares-cli dashboard overview gpu task my-task abcdef-0123-...

olares-cli dashboard overview user bob -o json

olares-cli profile use olares-id
olares-cli dashboard schema -o json | jq -e '.kind == "dashboard.schema.index"'
olares-cli dashboard overview -o json | jq -e '.sections.physical.kind == "dashboard.overview.physical"'
olares-cli dashboard overview gpu list -o json | jq -e '.kind == "dashboard.overview.gpu.list"'