@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.1

package/pipeline/skills/shared/external/energykit/references/energykit-patterns.md

@@ -1,583 +1,287 @@
-# EnergyKit Extended Patterns
+# EnergyKit Patterns
 
-Overflow reference for the `energykit` skill. Contains advanced patterns
-that exceed the main skill file's scope.
+Larger building blocks for an EnergyKit app. Basics live in the
+[skill overview](../SKILL.md). The API is new in iOS 26; confirm names against
+current documentation. The code assumes a 26.1 deployment target, because venue
+lookup and some error cases are 26.1 APIs.
 
-## Contents
-
-- [Full App Architecture](#full-app-architecture)
-- [EV Charging Session Manager](#ev-charging-session-manager)
-- [HVAC Control Manager](#hvac-control-manager)
-- [SwiftUI Energy Dashboard](#swiftui-energy-dashboard)
-- [Insight Data Visualization](#insight-data-visualization)
-- [Error Handling Strategies](#error-handling-strategies)
-- [Venue Discovery Flow](#venue-discovery-flow)
-
-## Full App Architecture
-
-An `@Observable` manager that ties together guidance, venues, and load events.
+## Observable guidance manager
 
 ```swift
 import EnergyKit
-import SwiftUI
+import Observation
 
-@Observable
-@MainActor
-final class EnergyManager {
-    var venues: [EnergyVenue] = []
+@Observable @MainActor
+final class GridForecastModel {
+    private(set) var venues: [EnergyVenue] = []
     var selectedVenue: EnergyVenue?
-    var currentGuidance: ElectricityGuidance?
-    var guidanceValues: [ElectricityGuidance.Value] = []
-    var isLoading = false
-    var errorMessage: String?
+    private(set) var latest: ElectricityGuidance?
+    private(set) var slots: [ElectricityGuidance.Value] = []
+    private(set) var isLoading = false
+    private(set) var problem: String?
 
-    private var guidanceTask: Task<Void, Never>?
+    private var watcher: Task<Void, Never>?
 
     func loadVenues() async {
         isLoading = true
-        errorMessage = nil
-
+        defer { isLoading = false }
         do {
             venues = try await EnergyVenue.venues()
             selectedVenue = venues.first
-            if let venue = selectedVenue {
-                startObservingGuidance(for: venue.id)
-            }
-        } catch let error as EnergyKitError {
-            errorMessage = handleError(error)
+            if let first = venues.first { startWatching(first.id) }
         } catch {
-            errorMessage = error.localizedDescription
+            problem = explain(error)
         }
-
-        isLoading = false
     }
 
-    func startObservingGuidance(for venueID: UUID) {
-        guidanceTask?.cancel()
-        guidanceTask = Task { [weak self] in
-            let query = ElectricityGuidance.Query(suggestedAction: .shift)
-            let service = ElectricityGuidance.sharedService
-
+    func startWatching(_ venueID: UUID, action: ElectricityGuidance.SuggestedAction = .shift) {
+        watcher?.cancel()
+        watcher = Task { [weak self] in
+            let query = ElectricityGuidance.Query(suggestedAction: action)
             do {
-                for try await guidance in service.guidance(using: query, at: venueID) {
-                    self?.currentGuidance = guidance
-                    self?.guidanceValues = guidance.values
+                for try await forecast in ElectricityGuidance.sharedService.guidance(using: query, at: venueID) {
+                    guard let self else { return }
+                    self.latest = forecast
+                    self.slots = forecast.values
                 }
             } catch {
-                self?.errorMessage = error.localizedDescription
+                self?.problem = self?.explain(error)
             }
         }
     }
 
-    func stopObserving() {
-        guidanceTask?.cancel()
-        guidanceTask = nil
-    }
-
-    var bestWindow: ElectricityGuidance.Value? {
-        guidanceValues.min(by: { $0.rating < $1.rating })
-    }
-
-    var hasRatePlan: Bool {
-        currentGuidance?.options.contains(.locationHasRatePlan) ?? false
+    func stopWatching() {
+        watcher?.cancel()
+        watcher = nil
     }
 
-    var usesRatePlan: Bool {
-        currentGuidance?.options.contains(.guidanceIncorporatesRatePlan) ?? false
-    }
-
-    // EnergyKitError cases
-    private func handleError(_ error: EnergyKitError) -> String {
-        switch error {
-        case .unsupportedRegion:
-            return "Energy guidance is not available in your region."
-        case .guidanceUnavailable:
-            return "Grid guidance data is currently unavailable."
-        case .venueUnavailable:
-            return "No energy venue found. Set up your home in the Home app."
-        case .permissionDenied:
-            return "Permission to access energy data was denied."
-        case .serviceUnavailable:
-            return "The energy service is temporarily unavailable."
-        case .rateLimitExceeded:
-            return "Too many requests. Please try again later."
-        case .invalidLoadEvent:
-            return "The load event data was invalid."
-        case .inProgress:
-            return "A request is already in progress."
-        case .locationServicesDenied:
-            return "Location services are required for energy guidance."
-        @unknown default:
-            return "An unknown error occurred."
+    var cleanestSlot: ElectricityGuidance.Value? { slots.min { $0.rating < $1.rating } }
+    var hasRatePlan: Bool { latest?.options.contains(.locationHasRatePlan) ?? false }
+    var usesRatePlan: Bool { latest?.options.contains(.guidanceIncorporatesRatePlan) ?? false }
+
+    private func explain(_ error: Error) -> String {
+        guard let energy = error as? EnergyKitError else { return error.localizedDescription }
+        switch energy {
+        case .unsupportedRegion:      return "Forecasts are not offered in this region."
+        case .guidanceUnavailable:    return "No forecast is available right now."
+        case .venueUnavailable:       return "Add your home in the Home app to get forecasts."
+        case .permissionDenied:       return "The app is not allowed to use EnergyKit."
+        case .serviceUnavailable:     return "The service is down. Try again soon."
+        case .rateLimitExceeded:      return "Too many requests. Waiting before trying again."
+        case .invalidLoadEvent:       return "A load event was rejected."
+        case .inProgress:             return "A request is already running."
+        case .locationServicesDenied: return "Location access is needed for forecasts."
+        @unknown default:             return "Unexpected EnergyKit error."
         }
     }
 }
 ```
 
-## EV Charging Session Manager
+## EV charging sessions
 
-Manage the full lifecycle of an EV charging session with guidance tracking.
-Use only a `guidanceToken` returned by EnergyKit for the venue and device that
-requested guidance. Do not synthesize placeholder tokens.
+Only use a token EnergyKit returned for this venue and the device that asked
+for guidance. Never synthesize one.
 
 ```swift
-import EnergyKit
-
-@Observable
-@MainActor
-final class EVChargingManager {
-    var isCharging = false
-    var currentSessionID: UUID?
-    var stateOfCharge: Int = 0
-    var currentPower: Double = 0  // kW
-    var totalEnergy: Double = 0   // kWh
-
-    private let deviceID: String
-    private var venue: EnergyVenue?
-    private var guidanceToken: UUID?
-    private var pendingEvents: [ElectricVehicleLoadEvent] = []
-
-    init(deviceID: String) {
-        self.deviceID = deviceID
-    }
-
-    func setVenue(_ venue: EnergyVenue) {
+actor ChargeSessionRecorder {
+    private let chargerID: String
+    private let venue: EnergyVenue
+    private var token: UUID?
+    private var sessionID: UUID?
+    private var queued: [ElectricVehicleLoadEvent] = []
+
+    init(chargerID: String, venue: EnergyVenue) {
+        self.chargerID = chargerID
         self.venue = venue
     }
 
-    func setGuidanceToken(_ token: UUID) {
-        self.guidanceToken = token
-    }
+    func adopt(token: UUID) { self.token = token }   // from ElectricityGuidance.guidanceToken
 
-    func startCharging(stateOfCharge: Int) async throws {
-        guard let venue else { throw EVError.noVenue }
-
-        let sessionID = UUID()
-        currentSessionID = sessionID
-        self.stateOfCharge = stateOfCharge
-        isCharging = true
-
-        let event = try makeEvent(
-            sessionState: .begin,
-            stateOfCharge: stateOfCharge,
-            power: 0,
-            energy: 0
-        )
-        pendingEvents = [event]
+    func plugIn(percent: Int) async throws {
+        sessionID = UUID()
+        queued.append(try event(.begin, kilowatts: 0, kilowattHours: 0, percent: percent))
+        try await flush()
     }
 
-    func updateCharging(
-        stateOfCharge: Int,
-        power: Double,
-        energy: Double
-    ) async throws {
-        guard let venue, isCharging else { return }
-
-        self.stateOfCharge = stateOfCharge
-        self.currentPower = power
-        self.totalEnergy = energy
-
-        let event = try makeEvent(
-            sessionState: .active,
-            stateOfCharge: stateOfCharge,
-            power: power,
-            energy: energy
-        )
-        pendingEvents.append(event)
-
-        if pendingEvents.count >= 4 {
-            try await flushPendingEvents()
-        }
+    func sample(kilowatts: Double, kilowattHours: Double, percent: Int) async throws {
+        queued.append(try event(.active, kilowatts: kilowatts, kilowattHours: kilowattHours, percent: percent))
+        if queued.count >= 4 { try await flush() }
     }
 
-    func stopCharging() async throws {
-        guard let venue, isCharging else { return }
-
-        let event = try makeEvent(
-            sessionState: .end,
-            stateOfCharge: stateOfCharge,
-            power: 0,
-            energy: totalEnergy
-        )
-        pendingEvents.append(event)
-        try await flushPendingEvents()
-
-        isCharging = false
-        currentSessionID = nil
+    func unplug(kilowattHours: Double, percent: Int) async throws {
+        queued.append(try event(.end, kilowatts: 0, kilowattHours: kilowattHours, percent: percent))
+        try await flush()
+        sessionID = nil
     }
 
-    func flushPendingEvents() async throws {
-        guard let venue, !pendingEvents.isEmpty else { return }
-
-        let events = pendingEvents
-        pendingEvents.removeAll()
-        try await venue.submitEvents(events)
+    private func flush() async throws {
+        let outgoing = queued
+        queued.removeAll()
+        guard !outgoing.isEmpty else { return }
+        try await venue.submitEvents(outgoing)
     }
 
-    private func makeEvent(
-        sessionState: ElectricVehicleLoadEvent.Session.State,
-        stateOfCharge: Int,
-        power: Double,
-        energy: Double
-    ) throws -> ElectricVehicleLoadEvent {
-        guard let guidanceToken else { throw EVError.missingGuidanceToken }
-        guard let currentSessionID else { throw EVError.noActiveSession }
-
-        let guidanceState = ElectricVehicleLoadEvent.Session.GuidanceState(
-            wasFollowingGuidance: true,
-            guidanceToken: guidanceToken
-        )
-
-        let session = ElectricVehicleLoadEvent.Session(
-            id: currentSessionID,
-            state: sessionState,
-            guidanceState: guidanceState
-        )
-
-        let measurement = ElectricVehicleLoadEvent.ElectricalMeasurement(
-            stateOfCharge: stateOfCharge,
-            direction: .imported,
-            power: Measurement(value: power, unit: .kilowatts),
-            energy: Measurement(value: energy, unit: .kilowattHours)
-        )
-
+    private func event(_ state: ElectricVehicleLoadEvent.Session.State,
+                       kilowatts: Double, kilowattHours: Double, percent: Int) throws -> ElectricVehicleLoadEvent {
+        guard let token, let sessionID else { throw ChargeError.noGuidanceOrSession }
         return ElectricVehicleLoadEvent(
-            timestamp: Date(),
-            measurement: measurement,
-            session: session,
-            deviceID: deviceID
-        )
-    }
-
-    enum EVError: Error {
-        case noVenue
-        case missingGuidanceToken
-        case noActiveSession
+            timestamp: .now,
+            measurement: .init(stateOfCharge: percent, direction: .imported,
+                               power: Measurement(value: kilowatts, unit: .kilowatts),
+                               energy: Measurement(value: kilowattHours, unit: .kilowattHours)),
+            session: .init(id: sessionID, state: state,
+                           guidanceState: .init(wasFollowingGuidance: true, guidanceToken: token)),
+            deviceID: chargerID)
     }
 }
+
+enum ChargeError: Error { case noGuidanceOrSession }
 ```
 
-## HVAC Control Manager
+## HVAC stages
 
-Track HVAC load events with guidance compliance.
-Submit events when the heating or cooling stage changes, and use the real
-guidance token that was in effect for that venue.
-Treat heat stage 1 -> heat stage 2, heat -> cooling, cooling -> idle, and
-equipment stop as distinct load events instead of one summarized session row.
-For devices that emit frequent stage/runtime samples, buffer events and submit
-periodically or at the end of a session, while still recording significant state
-changes as they occur.
+Report each heating or cooling stage change with the real token in force for
+the venue. Stage 1 to stage 2 heat, heat to cooling, cooling to idle, and
+shutting down are four separate events, not one summary row. If the equipment
+reports very frequently, buffer and submit on a timer or at session end, but
+still capture every significant state change when it happens.
 
 ```swift
-import EnergyKit
-
-@Observable
-@MainActor
-final class HVACManager {
-    var isRunning = false
-    var currentStage: Int = 0
-    var sessionID: UUID?
-
-    private let deviceID: String
-    private var venue: EnergyVenue?
-    private var guidanceToken: UUID?
-
-    init(deviceID: String) {
-        self.deviceID = deviceID
-    }
-
-    func configure(venue: EnergyVenue, guidanceToken: UUID) {
+actor ClimateRecorder {
+    private let thermostatID: String
+    private let venue: EnergyVenue
+    private let token: UUID
+    private var runID = UUID()
+
+    init(thermostatID: String, venue: EnergyVenue, token: UUID) {
+        self.thermostatID = thermostatID
         self.venue = venue
-        self.guidanceToken = guidanceToken
+        self.token = token
     }
 
     func start(stage: Int) async throws {
-        guard let venue else { return }
-        sessionID = UUID()
-        currentStage = stage
-        isRunning = true
-
-        let event = try makeEvent(state: .begin, stage: stage)
-        try await venue.submitEvents([event])
+        runID = UUID()
+        try await send(.begin, stage: stage)
     }
 
-    func updateStage(_ stage: Int) async throws {
-        guard let venue, isRunning else { return }
-        currentStage = stage
+    func changeStage(to stage: Int) async throws { try await send(.active, stage: stage) }
 
-        let event = try makeEvent(state: .active, stage: stage)
-        try await venue.submitEvents([event])
-    }
+    func stop() async throws { try await send(.end, stage: 0) }
 
-    func stop() async throws {
-        guard let venue, isRunning else { return }
-
-        let event = try makeEvent(state: .end, stage: 0)
+    private func send(_ state: ElectricHVACLoadEvent.Session.State, stage: Int) async throws {
+        let event = ElectricHVACLoadEvent(
+            timestamp: .now,
+            measurement: .init(stage: stage),
+            session: .init(id: runID, state: state,
+                           guidanceState: .init(wasFollowingGuidance: true, guidanceToken: token)),
+            deviceID: thermostatID)
         try await venue.submitEvents([event])
-
-        isRunning = false
-        sessionID = nil
-    }
-
-    private func makeEvent(
-        state: ElectricHVACLoadEvent.Session.State,
-        stage: Int
-    ) throws -> ElectricHVACLoadEvent {
-        guard let guidanceToken else { throw HVACError.missingGuidanceToken }
-        guard let sessionID else { throw HVACError.noActiveSession }
-
-        let guidanceState = ElectricHVACLoadEvent.Session.GuidanceState(
-            wasFollowingGuidance: true,
-            guidanceToken: guidanceToken
-        )
-
-        let session = ElectricHVACLoadEvent.Session(
-            id: sessionID,
-            state: state,
-            guidanceState: guidanceState
-        )
-
-        let measurement = ElectricHVACLoadEvent.ElectricalMeasurement(stage: stage)
-
-        return ElectricHVACLoadEvent(
-            timestamp: Date(),
-            measurement: measurement,
-            session: session,
-            deviceID: deviceID
-        )
-    }
-
-    enum HVACError: Error {
-        case missingGuidanceToken
-        case noActiveSession
     }
 }
 ```
 
-## SwiftUI Energy Dashboard
-
-A complete dashboard view showing guidance and insights.
+## Dashboard view
 
 ```swift
 import SwiftUI
-import EnergyKit
 
-struct EnergyDashboardView: View {
-    @Environment(EnergyManager.self) private var energyManager
+struct GridDashboard: View {
+    @Environment(GridForecastModel.self) private var model
 
     var body: some View {
-        NavigationStack {
-            Group {
-                if energyManager.isLoading {
-                    ProgressView("Loading energy data...")
-                } else if let error = energyManager.errorMessage {
-                    ContentUnavailableView(
-                        "Energy Guidance Unavailable",
-                        systemImage: "bolt.slash",
-                        description: Text(error)
-                    )
-                } else {
-                    dashboardContent
-                }
-            }
-            .navigationTitle("Energy")
-            .task {
-                await energyManager.loadVenues()
-            }
-        }
-    }
-
-    private var dashboardContent: some View {
-        List {
-            if let venue = energyManager.selectedVenue {
-                Section("Venue") {
-                    LabeledContent("Name", value: venue.name)
-                }
-            }
-
-            if let best = energyManager.bestWindow {
-                Section("Best Time") {
-                    VStack(alignment: .leading) {
-                        Text("Optimal usage window")
-                            .font(.headline)
-                        Text(best.interval.start, style: .time)
-                        + Text(" - ")
-                        + Text(best.interval.end, style: .time)
-                        Text("Rating: \(best.rating, specifier: "%.2f")")
-                            .foregroundStyle(.secondary)
+        Group {
+            if model.isLoading {
+                ProgressView("Loading forecast")
+            } else if let problem = model.problem {
+                ContentUnavailableView("No Forecast", systemImage: "bolt.slash", description: Text(problem))
+            } else {
+                List {
+                    if let venue = model.selectedVenue {
+                        Section("Home") { Text(venue.name) }
                     }
-                }
-            }
-
-            if !energyManager.guidanceValues.isEmpty {
-                Section("Timeline") {
-                    ForEach(energyManager.guidanceValues, id: \.interval.start) { value in
-                        HStack {
-                            VStack(alignment: .leading) {
-                                Text(value.interval.start, style: .time)
-                                Text(value.interval.end, style: .time)
-                                    .font(.caption)
-                                    .foregroundStyle(.secondary)
-                            }
-                            Spacer()
-                            guidanceRatingView(value.rating)
+                    if let best = model.cleanestSlot {
+                        Section("Best time") {
+                            Text(best.interval.start, style: .time)
+                            Text("Rating \(best.rating, format: .number.precision(.fractionLength(2)))")
                         }
                     }
-                }
-            }
-
-            if energyManager.hasRatePlan {
-                Section("Rate Plan") {
-                    Label(
-                        energyManager.usesRatePlan
-                            ? "Guidance incorporates your rate plan"
-                            : "Rate plan available but not yet incorporated",
-                        systemImage: "dollarsign.circle"
-                    )
+                    Section("Timeline") { ForecastList(values: model.slots) }
+                    if model.usesRatePlan {
+                        Label("Includes your rate plan", systemImage: "dollarsign.circle")
+                    }
                 }
             }
         }
-    }
-
-    private func guidanceRatingView(_ rating: Double) -> some View {
-        let color: Color = rating <= 0.3 ? .green : rating <= 0.6 ? .yellow : .red
-        let label = rating <= 0.3 ? "Good" : rating <= 0.6 ? "Fair" : "Avoid"
-
-        return Text(label)
-            .font(.caption)
-            .fontWeight(.medium)
-            .padding(.horizontal)
-            .padding(.vertical)
-            .background(color.opacity(0.15))
-            .foregroundStyle(color)
-            .clipShape(Capsule())
+        .task { await model.loadVenues() }
     }
 }
 ```
 
-## Insight Data Visualization
+## Preparing insight charts
 
-Prepare insight records for chart display.
-`dataByGridCleanliness` is iOS/iPadOS 26.1+, so keep the chart model optional
-and guard access when supporting 26.0.
+`dataByGridCleanliness` needs 26.1. Keep the chart model's cleanliness fields
+optional and guard them when the app still supports 26.0.
 
 ```swift
-struct InsightDataPoint: Identifiable {
-    let id = UUID()
-    let date: Date
-    let energy: Double  // kWh
-    let cleanerEnergy: Double?
-    let lessCleanEnergy: Double?
+struct UsageBar: Identifiable {
+    let id: Date
+    let totalKWh: Double
+    let cleanerKWh: Double?
+    let lessCleanKWh: Double?
 }
 
-func processInsightRecords(
-    _ records: [ElectricityInsightRecord<Measurement<UnitEnergy>>]
-) -> [InsightDataPoint] {
-    records.compactMap { record in
-        guard let total = record.totalEnergy else { return nil }
-
-        let cleanliness: (cleaner: Double?, lessClean: Double?)
-        if #available(iOS 26.1, iPadOS 26.1, *) {
-            cleanliness = (
-                record.dataByGridCleanliness?.cleaner?
-                    .converted(to: .kilowattHours).value,
-                record.dataByGridCleanliness?.lessClean?
-                    .converted(to: .kilowattHours).value
-            )
-        } else {
-            cleanliness = (nil, nil)
-        }
-
-        return InsightDataPoint(
-            date: record.range.start,
-            energy: total.converted(to: .kilowattHours).value,
-            cleanerEnergy: cleanliness.cleaner,
-            lessCleanEnergy: cleanliness.lessClean
-        )
+func bar(from record: ElectricityInsightRecord<Measurement<UnitEnergy>>) -> UsageBar {
+    let total = record.totalEnergy?.converted(to: .kilowattHours).value ?? 0
+    var cleaner: Double?
+    var lessClean: Double?
+    if #available(iOS 26.1, *) {
+        cleaner = record.dataByGridCleanliness?.cleaner?.converted(to: .kilowattHours).value
+        lessClean = record.dataByGridCleanliness?.lessClean?.converted(to: .kilowattHours).value
     }
+    return UsageBar(id: record.range.start, totalKWh: total, cleanerKWh: cleaner, lessCleanKWh: lessClean)
 }
 ```
 
-## Error Handling Strategies
+## Retrying
 
-Comprehensive error handling with retry logic.
+Only transient errors deserve a retry: `.serviceUnavailable` and
+`.rateLimitExceeded`, up to three attempts with a `2^(attempt+1)` second pause.
+`.unsupportedRegion`, `.permissionDenied` and `.venueUnavailable` are permanent
+for this session; surface them instead.
 
 ```swift
-@Observable
-@MainActor
-final class ResilientEnergyService {
-    private let maxRetries = 3
-
-    func fetchGuidanceWithRetry(venueID: UUID) async throws -> ElectricityGuidance? {
-        let query = ElectricityGuidance.Query(suggestedAction: .shift)
-        let service = ElectricityGuidance.sharedService
-
-        for attempt in 0..<maxRetries {
-            do {
-                for try await guidance in service.guidance(using: query, at: venueID) {
-                    return guidance
-                }
-            } catch let error as EnergyKitError {
-                switch error {
-                case .serviceUnavailable, .rateLimitExceeded:
-                    if attempt < maxRetries - 1 {
-                        try await Task.sleep(for: .seconds(pow(2.0, Double(attempt + 1))))
-                    }
-                case .unsupportedRegion, .permissionDenied, .venueUnavailable:
-                    throw error  // Do not retry permanent failures
-                default:
-                    throw error
-                }
-            }
+func retryingEnergyCall<T>(_ work: () async throws -> T) async throws -> T {
+    var attempt = 0
+    while true {
+        do {
+            return try await work()
+        } catch let error as EnergyKitError where attempt < 2 &&
+                    (error == .serviceUnavailable || error == .rateLimitExceeded) {
+            attempt += 1
+            try await Task.sleep(for: .seconds(1 << attempt))
         }
-
-        return nil
     }
 }
 ```
 
-## Venue Discovery Flow
-
-Guide users through venue setup if none exist.
+## Venue picker
 
 ```swift
-import SwiftUI
-import EnergyKit
-
-struct VenueSetupView: View {
-    @State private var venues: [EnergyVenue] = []
-    @State private var isLoading = true
-    @State private var showSetupGuide = false
+struct HomePicker: View {
+    @State private var homes: [EnergyVenue] = []
 
     var body: some View {
         Group {
-            if isLoading {
-                ProgressView()
-            } else if venues.isEmpty {
-                ContentUnavailableView {
-                    Label("No Energy Venues", systemImage: "house")
-                } description: {
-                    Text("Set up your home in the Home app to use energy guidance.")
-                } actions: {
-                    Button("Learn More") { showSetupGuide = true }
-                        .buttonStyle(.borderedProminent)
-                }
+            if homes.isEmpty {
+                ContentUnavailableView("No Home Found", systemImage: "house",
+                                       description: Text("Create your home in the Home app, then come back."))
             } else {
-                List(venues, id: \.id) { venue in
-                    NavigationLink(value: venue.id) {
-                        Label(venue.name, systemImage: "house.fill")
-                    }
+                List(homes, id: \.id) { home in
+                    NavigationLink(home.name) { VenueDetail(venue: home) }
                 }
             }
         }
-        .task {
-            do {
-                venues = try await EnergyVenue.venues()
-            } catch {
-                venues = []
-            }
-            isLoading = false
-        }
+        .task { homes = (try? await EnergyVenue.venues()) ?? [] }
     }
 }
 ```