Luma

A polished, context-aware Lovelace card suite for Home Assistant.

Explore every card in the interactive component catalogue — including responsive viewports, working actions, live-style mock data, and a production-scale home hero pattern.

Luma replaces deeply nested button-card and card-mod configurations with small, reusable web components. It shares one responsive visual language across heroes, room summaries, controls, live status, tabs, and Material-inspired bottom sheets while keeping actions and entity selection configurable at runtime.

Built-in interface copy follows Home Assistant's active language. English is the fallback locale and Hungarian is included; explicit labels supplied in a card configuration always take precedence over the built-in translation. The interactive catalogue has a locale switcher in its toolbar, so every component can be reviewed in either language without changing Home Assistant.

The EV Solar readiness card places the learned useful window on a full-day timeline with a live “now” marker, elapsed-window fill, start/end labels, remaining useful time, and estimated Solar energy. Set show_reason: false on a glanceable household-facing view to replace the backend's technical reason with a localized plain-language summary; the detailed backend reason remains the default.

Cards

Card	Purpose
custom:luma-home-hero-card	Weather-aware home hero, dynamic greeting, incidents, acknowledgements, alarm, waste and irrigation context
custom:luma-hero-card	General-purpose responsive hero with chips, badge and banners
custom:luma-heading-card	Compact section heading with optional navigation/action affordance
custom:luma-control-card	Entity action with mapped state and contextual styling
custom:luma-control-group-card	Dense, responsive row of controls
custom:luma-metric-card	Primary and secondary live metrics
custom:luma-storage-card	Disk/volume usage, capacity, temperature and SMART health in one card
custom:luma-room-card	Room summary with environment and quick actions
custom:luma-action-card	Compact scene, service, or navigation action
custom:luma-comfort-card	Indoor comfort and air-quality summary
custom:luma-climate-card	Compact climate controller
custom:luma-tab-card	Responsive tab container for any Lovelace cards
custom:luma-active-card	Runtime-filtered list of active entities
custom:luma-popup-card	Hash-driven, draggable Material-style bottom sheet
custom:luma-alarm-card	Alarm status with segmented, confirmed arming and disarming controls
custom:luma-sensor-grid-card	Responsive, grouped sensor values without entities or card-mod
custom:luma-remote-card	Android TV remote with a large D-pad, integrated playback rail and app shortcuts
custom:luma-gate-card	Gate and garage controls with inline confirmation or an anchored action popover
custom:luma-cover-card	Cover position, motion state, progress bar and open/stop/close controls
custom:luma-disclosure-card	Compact expandable container for related controls
custom:luma-temperature-card	Comfort-colored temperature hero and comparable room scale
custom:luma-energy-flow-card	Animated solar, optional measured home load, and configurable-sign grid power flow
custom:luma-energy-mix-card	Live or session energy-source split with a Luma rail, totals and percentages
custom:luma-history-card	Recorder-backed line or aggregated bar chart with optional daily/monthly range switching
custom:luma-session-browser-card	Swipeable completed-session browser combining Recorder events with a retained recent-session fallback
custom:luma-period-stats-card	Compact swipeable day/month/year energy and source-attribution summary
custom:luma-ev-mode-card	Persistent Off, Solar or Always charging strategy selector with confirmed changes
custom:luma-ev-control-card	Temporary Charge Now override with lifecycle-aware handoff to the persistent base mode
custom:luma-ev-solar-readiness-card	Canonical Solar recommendation, operational priority overrides and EVCC-style daily Solar-window timeline
custom:luma-navigation-card	Contextual navigation card with shared Luma styling
custom:luma-navbar-card	Configurable routes with an artwork-aware, switchable active-media dock
custom:luma-homelab-hero-card	Dynamic Kuma, Komodo and infrastructure health summary
custom:luma-rack-cooling-card	Rack thermal delta, fan speed and PWM visualization
custom:luma-irrigation-hero-card	Context-aware irrigation status with ad-hoc/program progress and next scheduled run
custom:luma-irrigation-schedule-card	Explicit weekday/every-N-days mode selector, persistent boolean mode, automation health and next-run preview
custom:luma-irrigation-zone-card	Adjustable timed zone start/stop with confirmation and live progress
custom:luma-irrigation-program-card	Confirmed program launch with live progress
custom:luma-logbook-card	Recorder-backed event history grouped by day
custom:luma-update-card	Confirmed update installation with live progress
custom:luma-timeline-card	Responsive camera-event timeline with authenticated snapshots and video playback
custom:luma-camera-activity-card	Latest security event with playable authenticated thumbnail and on-demand live camera selector
custom:luma-waste-hero-card	Dynamic next-collection summary with urgency and acknowledgement state
custom:luma-waste-collection-card	Next collection date and countdown for a waste schedule sensor
custom:luma-waste-ack-card	Confirmed, state-aware bin placement acknowledgement
custom:luma-lawn-hero-card	Contextual robot mower status, battery and progress hero
custom:luma-lawn-control-card	Confirmed start, resume and stop controls with live task progress
custom:luma-battery-hero-card	Dynamic low-battery summary with critical and warning counts
custom:luma-battery-grid-card	Runtime-discovered, sorted battery devices without template-generated cards
custom:luma-discovery-card	Native runtime discovery for favorite lights, Homelab incidents, infrastructure updates, and Komodo deployments
custom:luma-layout-card	Child-card grid with independent desktop, tablet and mobile column counts
custom:luma-appliance-card	Appliance state, remaining time and cycle progress
custom:luma-entity-grid-card	Fast runtime-filtered responsive entity collection without auto-entities templates
custom:luma-service-grid-card	One card per application: availability, container counts, metrics and confirmed management in a detail sheet
custom:luma-weather-forecast-card	Responsive daily forecast with an hourly, data-rich per-day detail sheet
custom:luma-weather-hourly-card	Scrollable 24-hour temperature, precipitation and wind outlook
custom:luma-weather-details-card	Current atmospheric, recent rain, optional air-quality and sun details

luma-remote-card automatically adds a restrained now-playing artwork strip when the media player exposes entity_picture_local or entity_picture. It falls back to the compact text header without reserving empty space. Set artwork: false to disable it for a specific remote. Set artwork_entity to another media-player entity to use its entity_picture as a fallback when the primary entity has no artwork. This is useful with an Android Debug Bridge entity that exposes a periodic TV screenshot. Application shortcuts are supplied by the dashboard through apps; Luma does not include a vendor-specific default list. Each item can use an Android TV activity, or a standard Luma tap_action for scripts and arbitrary Home Assistant actions. The pressed shortcut shows loading and success/error feedback.

type: custom:luma-remote-card
remote_entity: remote.living_room_tv
media_entity: media_player.living_room_tv
apps:
  - name: YouTube
    icon: mdi:youtube
    activity: https://www.youtube.com
  - name: Wholphin
    icon: mdi:jellyfish
    tap_action:
      action: perform-action
      perform_action: script.turn_on
      target:
        entity_id: script.launch_wholphin

luma-control-card automatically recognizes active lights and media players, and actions with confirmation use an inline second-tap confirmation state. Lights receive a warm accent and brightness subtitle; media players receive a distinct media accent and show the current title or application when available. Active media-player controls also use their artwork as a subtle backdrop and thumbnail when available; set artwork: false to keep the icon-only variant. For a relay whose Home Assistant domain does not describe its physical use, set display_as: light. This changes only presentation and active-state styling; actions still target the entity's real domain. Light controls open Home Assistant's More Info dialog on long press by default, giving direct access to brightness, color temperature, and color controls when the entity supports them. An explicit hold_action overrides this behavior. The active-entity list renders the same luma-control-card surface for each result, so active controls keep identical visuals, tap behavior, and long-press More Info access.

luma-metric-card is the single compact read-only status primitive. It supports numeric formatting, secondary entities, mapped states, and direct attribute display through attribute. The former luma-status-card was removed in 0.54; replace its type with custom:luma-metric-card without changing the remaining configuration.

The home hero's alarm chip opens an anchored alarm control by default. Its alarm_modes remain runtime-configurable, each state change requires an explicit second confirmation tap, and alarm_action continues to open the full detailed alarm sheet. Set alarm_popover: false to keep the direct action.

The home hero has no installation-specific incident preset. Pass every warning rule through incidents; entity IDs, thresholds, labels, messages, and navigation paths therefore stay in the dashboard that owns them. Rules support explicit entities, glob patterns, entity-registry platform/label filters, device classes, numeric thresholds, duration, aggregation, and acknowledgement scope.

The same boundary applies to specialized cards: luma-homelab-hero-card receives status_rules, luma-discovery-card in homelab-incidents mode receives incident_rules, and luma-rack-cooling-card receives all sensor entity IDs explicitly. Luma provides rendering and rule evaluation, while the runtime dashboard owns the installation topology.

luma-navbar-card keeps installation-specific paths and entities outside the package. Pass Navbar Card-compatible routes explicitly, plus an optional media_players list. When multiple configured players are active, swipe the dock horizontally or tap its subtle page indicator to switch players; tapping the dock opens the selected player's configured popup. app_names can map integration-specific package IDs to friendly labels.

type: custom:luma-navbar-card
routes:
  - url: /lovelace/home
    label: Home
    icon: mdi:home
  - url: /config?disable_km
    label: Settings
    icon: mdi:cog-outline
media_players:
  - entity: media_player.living_room
    name: Living room
    popup: "#living-room-remote"

luma-cover-card supports master, group, and compact variants, allowing the same behavior and visual language to cover whole-house, room, and individual shutter controls. Destructive group actions can use inline second-tap confirmation.

luma-gate-card defaults to permanently visible controls with second-tap confirmation. Set display: popover for compact overview cards: the first tap opens a control surface anchored to that card, and the labelled confirmation action performs the state-aware open or close command. Moving covers offer stop instead, and an optional pedestrian button can share the same surface.

type: custom:luma-gate-card
entity: cover.driveway_gate
name: Driveway
kind: cover
display: popover
pedestrian_entity: button.driveway_pedestrian_open

Security-oriented layouts can use compact_mobile: true on luma-alarm-card, surface: true on luma-sensor-grid-card, and a numeric top_spacing on luma-hero-card. These options keep kiosk headers clear of the viewport edge and make dense alarm and zone controls more comfortable on small screens without changing their desktop behavior.

luma-irrigation-zone-card can use a shared firmware duration number and dedicated start/stop button entities while remaining compatible with direct switch toggle configurations. Each card keeps its own ad-hoc duration in browser storage. Its compact minus/plus controls change only that local value; after the second confirmation tap, the card writes the value to the shared number and then presses the zone start button sequentially. Minimum, maximum, and step values still come from the number entity.

type: custom:luma-irrigation-zone-card
entity: switch.garden_zone
name: Garden
duration_entity: number.custom_zone_duration
default_duration: 10
start_entity: button.start_garden_custom_duration
stop_entity: button.stop_irrigation
progress_entity: sensor.active_zone_progress
remaining_entity: sensor.active_zone_remaining

The home hero accepts irrigation_zone_entities in addition to irrigation_entity, so manually or ad-hoc started zones also produce the irrigation banner. Entries may be entity IDs or objects with a shorter display name.

irrigation_entity: sensor.active_irrigation_program
irrigation_zone_entities:
  - entity: switch.garden_zone
    name: Garden
  - switch.drip_zone

Active appliances can use the same contextual banner area. Timestamp-based completion sensors and duration sensors with s, min, or h units are interpreted automatically.

appliances:
  - entity: sensor.washer_state
    name: Washer
    active_entity: input_boolean.washer_cycle_active
    remaining_entity: sensor.washer_completion_time
    path: /dashboard-rooms/laundry
    state_map:
      washing: Washing
      rinsing: Rinsing
      spinning: Spinning

luma-timeline-card is intentionally data-source agnostic. It reads an events attribute from a sensor and expects each item to provide timestamp, type, snapshot, and url; this keeps integrations responsible for fetching events while Luma owns presentation. The attribute name, visible item count, column count, and excluded event types remain configurable at runtime. Snapshot tiles show a tone-aware shimmer while authenticated images load and a clear fallback when an image is missing or unavailable. Set initial_items to keep long timelines compact behind an explicit expand/collapse control.

Event video uses Home Assistant's chunked UniFi Protect proxy directly. The player requests data eagerly, starts as soon as the first playable MP4 data is available, and uses muted inline autoplay for mobile-browser compatibility; sound can be enabled from the native controls.

type: custom:luma-timeline-card
entity: sensor.front_door_timeline
title: Front door events
max_items: 24
columns: 2
exclude_types:
  - lowMemory

Installation

Add this repository to HACS as a custom Dashboard repository and install Luma. HACS registers /hacsfiles/lovelace-luma/lovelace-luma.js as a module; refresh the browser after an update.

For local development:

npm install
npm run check
npm run build

The HACS-compatible bundle is written to dist/lovelace-luma.js.

Interactive documentation

Luma includes a Storybook catalogue that renders the real Lit card components against a safe, simulated Home Assistant runtime. Entity states and card options can be changed from Storybook controls; service calls are captured in an action log and never reach a Home Assistant instance.

npm run docs
npm run build:docs

The static catalogue is built into storybook-static. The included GitHub Pages workflow validates the TypeScript project, builds the catalogue, and publishes it after every push to main.

Metric and control cards placed directly inside luma-layout-card stretch to their row height. Content remains vertically centered without a subtitle; no placeholder or fixed height is required. Other layout children retain their top alignment. See the Metric / Equal Height Row story for a responsive example.

Compute and operations layouts

Interactive examples demonstrate full-width VM and update grids and combined compute metrics.

• Entity grids accept extra_cards: [...] to append explicitly configured cards to the same responsive grid as discovered entities. This can place a manually controlled workstation beside dynamically discovered VMs, without a second grid. Extras render even if discovery is empty; empty_card is used only when both collections are empty. Actions and confirmation remain child-card configuration.
• Metric cards accept secondary_tap_action, e.g. { action: more-info, entity: sensor.cpu_temperature }. Secondary clicks do not trigger the main card action. Without this option, existing secondary text remains non-interactive.
• Discovery mode infrastructure-updates uses the shared luma-update-card and accepts columns, tablet_columns, mobile_columns (all default to 1). Installing items remain visible, including numeric in_progress: 0.
• Rack cooling uses a horizontal summary/metrics layout when its available width is at least 620px, and keeps the compact vertical layout below that width.

Storage cards

Try disk, logical-volume, parity, warning and unavailable examples.

custom:luma-storage-card combines a percentage usage entity with optional capacity, temperature and SMART health. Every source and threshold is runtime configuration: there are no built-in Unraid/Proxmox entity names or attribute mappings.

Set compact: true for slightly tighter padding and card height without shrinking the text. An optional operation displays a read-only task state and progress on the disk itself, for example a parity check:

type: custom:luma-storage-card
name: Parity disk
compact: true
health_entity: binary_sensor.parity_disk_problem
operation:
  label: Parity check
  state: { entity: binary_sensor.parity_check_running, attribute: status }
  state_map:
    running: Running
    paused: Paused
    completed: Completed
    idle: Idle
  progress: { entity: sensor.parity_check_progress }
  progress_states: [running, paused]

progress_states matches raw states, before state_map. Completed/idle tasks therefore do not show a misleading 0% bar when the source resets after completion. Missing or invalid progress is hidden. Both values open their source's more-info.

type: custom:luma-storage-card
entity: sensor.data_disk_usage
name: Data disk
subtitle: Array · XFS
health_entity: binary_sensor.data_disk_problem
healthy_states: ["off"]
problem_states: ["on"]
used: { attribute: used }
free: { attribute: free }
total: { attribute: total }
temperature: { attribute: temperature_celsius, unit: "°C" }
health_detail: { entity: binary_sensor.data_disk_problem, attribute: reason }
warning_above: 85
critical_above: 95

A source accepts entity, attribute, and unit. Without entity it reads the main usage entity (or health_entity on a health-only card). Without attribute it reads that entity's state. Numeric values are rounded to one decimal using the active HA locale; preformatted capacity strings such as 2.9 TB are preserved. For separate Proxmox sensors, use e.g. used: { entity: sensor.volume_used }. Capacity values are displayed as reported, not recomputed: filesystem free space may account for reserved blocks differently from total minus used.

Omit health_entity for logical volumes without SMART; omit entity for a health-only/parity disk; usage_note overrides its explanatory text. Missing, unavailable and restored data is never shown as zero usage or healthy. Health and capacity warnings remain independent. Usage, capacity, SMART and temperature buttons open the corresponding HA more-info dialog; the card cannot start a disk operation or change power state. An attribute's button opens its parent entity (HA does not create a separate history for attributes).

For full-width stacked sections, put each heading and one luma-layout-card in a separate HA section with column_span equal to the view's max_columns. Set the layout to columns: 3, tablet_columns: 2, mobile_columns: 1 and grid_options: { columns: full, rows: auto }. Do not nest the three sections in side-by-side stacks: different row heights recreate the empty-space problem.

Runtime entity filtering

Unified services

luma-service-grid-card combines stack state and availability monitors without adding a backend, polling another API, or guessing matches from application names. Stacks, containers, updates and operation targets are discovered from selectors and grouped by their existing Home Assistant device. Cross-integration monitor bindings, names, URLs, selectors and operation definitions live in the dashboard. New stacks and enabled container entities appear automatically; link a new monitor by adding a binding. No Luma rebuild is needed for that change.

Set compact: true to reduce service tile padding and minimum height. Service details, weather forecast day details and configured luma-popup-card popups all use the same bottom-sheet shell: opaque themed surface, shared header and motion, scrollable content, Escape/backdrop/close-button dismissal and drag-down handle. On mobile the sheet meets the bottom edge; on desktop it floats above it. Reduced motion preferences are respected. No existing popup configuration needs changing.

type: custom:luma-service-grid-card
columns: 3
tablet_columns: 2
mobile_columns: 1
stacks:
  integration: komodo
  entity_pattern: sensor.*_stack_state
containers:
  integration: komodo
  domain: switch
  exclude: [switch.*_stack]
updates:
  integration: komodo
  domain: update
monitors:
  integration: uptime_kuma
  entity_pattern: sensor.*_status
metrics:
  latency: {from: _status, to: _response_time}
  uptime: {from: _status, to: _uptime_30_days}
  url: {from: _status, to: _monitored_url}
uptime_label: 30 days
bindings:
  - entity: sensor.photos_stack_state
    monitor: sensor.photos_status
    name: Photos
    icon: mdi:image-multiple-outline
monitor_groups:
  - name: Infrastructure
    entity_pattern: sensor.host_*
  - name: Backups
    entity_pattern: sensor.backup_*
operations:
  - name: Redeploy stack
    icon: mdi:rocket-launch-outline
    selector: {domain: button, entity_pattern: button.*_deploy_*}
    service: button.press
    confirm: Redeploy this entire stack? Service may be interrupted.
  - name: Stop stack
    icon: mdi:stop-circle-outline
    selector: {domain: switch, entity_pattern: switch.*_stack}
    state: ["on"]
    service: switch.turn_off
    confirm: Stop all containers in this stack?

Entity suffixes depend on your HA language and entity naming: use the actual entities from your installation. metrics suffix mappings apply only to the linked monitor entity. Selectors support integration, domain, entity_pattern and exclude wildcard lists. A binding may also override url (HTTP(S) only).

• Availability and container state stay separate: 4/4 running does not mean the application is healthy. A down monitor is an error; partial container failure or a non-running stack is a warning even if the monitor is up.
• Missing monitor data is unknown, not healthy. Unlinked stacks say No monitor. Unknown latency/uptime values are omitted, not rendered as zero or unknown ms.
• Counts cover discovered, enabled, non-hidden container switches. Enable all constituent container entities to get a complete count. The whole-stack switch must be excluded from containers. Restored orphan entities are ignored; explicitly bound stacks remain visible during integration recovery.
• Clicking the main card only opens details. Container start/stop, stack actions and available updates require a second click within six seconds. Closing the sheet or a target state change cancels pending confirmation; request errors are shown. Read-only history links never toggle anything.
• Only configure operations actually exposed by your integration. In Komodo, deploying a stack is not a simple restart; a stack switch's ON action may redeploy it. No start/restart action is invented by this card.
• Monitor-only entities remain visible, optionally grouped with monitor_groups. Raw infrastructure update discovery can remain on an Operations view; the separate deployments list is no longer necessary.

See interactive service examples, including mobile, partial failure, missing data and detail-sheet scenarios.

Entity grid exclusions

luma-entity-grid-card supports an optional exclude list of entity IDs or * wildcard patterns. Exclusions take precedence over its inclusion filters. Discovery stays dynamic, including stopped or unavailable entities unless a state filter explicitly excludes them. For example, show individual Komodo services without also showing whole-stack controls:

type: custom:luma-entity-grid-card
integration: komodo
domain: switch
exclude:
  - switch.*_stack
columns: 2
mobile_columns: 1
tap_action:
  action: toggle
  confirmation:
    text: Change this service's state?

Active entity filter rules

The home hero and active card use the same runtime filter language. Rules are evaluated against the current Home Assistant state and entity registry, so no rebuild is needed when the dashboard configuration changes.

active:
  # Both default to true. Hidden or disabled registry entries are ignored.
  exclude_hidden: true
  exclude_disabled: true
  include:
    # Keep useful light groups as one item.
    - entity: light.sofa_lights
      state: "on"
      tap_action:
        action: toggle

    # Then add individual lights, without duplicating groups.
    - domain: light
      state: "on"
      exclude_groups: true

    - domain: media_player
      state_not: ["off", "idle", "standby", "unknown", "unavailable"]

    - domain: climate
      attribute: hvac_action
      state: ["heating", "cooling", "drying", "fan"]

    - entity_pattern: sensor.*_power
      above: 10
  exclude:
    - light.all_lights
    - light.*_bulb_*

  # Integrations such as Zigbee may expose overlapping groups without a
  # member list. Keep one semantic representation when several are active.
  collapse:
    - entities:
        - light.terrace_lights
        - light.outdoor_wall_lights
        - light.terrace_relay
      prefer: light.terrace_lights

An include rule accepts entity, entity_pattern, or domain, plus state, state_not, above, below, attribute, exclude_groups, and an optional tap_action. Use display_as: light for a relay that should use light styling and behavior, and area_name to provide the secondary location label when an integration entity or group has no area in Home Assistant's registry. exclude accepts entity-id globs. Earlier matching rules win the display order and duplicate entity IDs are collapsed. Each collapse entry also accepts entity-id globs; if multiple listed entities are active, prefer is retained (or the first displayed match when the preferred entity is absent). This is useful for integration-level groups that do not expose attributes.entity_id, where automatic member-based deduplication is not possible in the browser.

Use the same block under custom:luma-active-card:

type: custom:luma-active-card
name: Active now
active:
  exclude_hidden: true
  # Broad domain rules ignore switch-as-light wrappers by default. Override
  # this list, or include a specific entity explicitly, when one is intentional.
  exclude_platforms:
    - switch_as_x
  include:
    - domain: light
      state: "on"
      exclude_groups: true

When at least one displayed light is active, the card header also shows a compact Lights off action. It turns off only entries presented as lights; media players and climate devices are left untouched.

Popup example

Room example

type: custom:luma-room-card
name: Living room
icon: mdi:sofa-outline
path: /dashboard-rooms/living-area
temperature_entity: sensor.living_room_temperature
humidity_entity: sensor.living_room_humidity
items:
  - entity: light.living_room
    name: Light
    icon: mdi:lightbulb-outline
    tap_action:
      action: toggle
  - entity: media_player.living_room
    name: TV
    icon: mdi:television
    tap_action:
      action: more-info
  - entity: cover.living_room
    name: Shade
    icon: mdi:window-shutter
    tap_action:
      action: more-info

The environment entities and quick items are optional. Items use the shared Luma condition, state mapping, color, and action fields, so the card also fits utility rooms, outdoor areas, and media-focused spaces.

Popup example

type: custom:luma-popup-card
hash: "#active"
title: Active devices
icon: mdi:lightning-bolt-outline
max_width: 720
cards:
  - type: custom:luma-active-card

The popup has a scrim, a draggable dismiss handle, and an edit-mode preview so it remains selectable in the Lovelace editor.

Home hero example

type: custom:luma-home-hero-card
weather_entity: weather.home
alarm_entity: alarm_control_panel.home
tap_action:
  action: navigate
  navigation_path: /lovelace/weather
active_action:
  action: navigate
  navigation_path: "#active"
alarm_action:
  action: navigate
  navigation_path: "#alarm"
waste_items:
  - entity: sensor.general_waste
    name: General
  - entity: sensor.plastic_waste
    name: Plastic
incidents:
  - entity_pattern: sensor.*_monitored_url
    state_not: Up
    message: "{count} monitored services unavailable"
    tone: error
    aggregate: true
    navigation_path: /dashboard-homelab/overview

Incident rules accept an exact entity, one entity_pattern glob, multiple entity_patterns, or device_classes, together with state, state_not, above, below, and for_minutes. {name} expands per entity and {count} works with aggregate: true. A non-aggregated incident without a navigation_path opens the matching entity's More Info dialog. Configuring an input-text acknowledgement entity enables per-incident 7- or 30-day dismissal; error incidents remain visible.

Incident rules can use label to limit wildcard matches to entities carrying a specific Home Assistant label. Set ack_scope: matches when an aggregate warning should reappear as soon as the matched entity set or an entity's latest_version changes, while keeping a single combined acknowledgement action.

Actions

Cards support none, navigate, more-info, toggle, perform-action, and the legacy call-service action spelling.

License

MIT