@elizaos/app-core 2.0.0-beta.3 → 2.0.11-beta.6

package/platforms/ios/App/App/DeviceActivityReportExtension/DeviceActivityReportExtension.swift

@@ -0,0 +1,53 @@
+import DeviceActivity
+import SwiftUI
+
+@main
+@available(iOS 16.0, *)
+struct ElizaDeviceActivityReportExtension: DeviceActivityReportExtension {
+    var body: some DeviceActivityReportScene {
+        ElizaDeviceActivityReportScene { configuration in
+            ElizaDeviceActivityReportView(configuration: configuration)
+        }
+    }
+}
+
+private struct ElizaDeviceActivityReportConfiguration {
+    let title: String
+    let message: String
+}
+
+@available(iOS 16.0, *)
+private struct ElizaDeviceActivityReportScene: DeviceActivityReportScene {
+    let context: DeviceActivityReport.Context = .elizaScreenTimeSummary
+    let content: (ElizaDeviceActivityReportConfiguration) -> ElizaDeviceActivityReportView
+
+    func makeConfiguration(
+        representing data: DeviceActivityResults<DeviceActivityData>
+    ) async -> ElizaDeviceActivityReportConfiguration {
+        _ = data
+        return ElizaDeviceActivityReportConfiguration(
+            title: "Screen Time",
+            message: "Screen Time activity is available for this report."
+        )
+    }
+}
+
+private struct ElizaDeviceActivityReportView: View {
+    let configuration: ElizaDeviceActivityReportConfiguration
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text(configuration.title)
+                .font(.headline)
+            Text(configuration.message)
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+        }
+        .padding()
+    }
+}
+
+@available(iOS 16.0, *)
+private extension DeviceActivityReport.Context {
+    static let elizaScreenTimeSummary = Self("eliza.screen-time.summary")
+}

package/platforms/ios/App/App/DeviceActivityReportExtension/Info.plist

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleDisplayName</key>
+	<string>Device Activity Report</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>XPC!</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSExtension</key>
+	<dict>
+		<key>NSExtensionPointIdentifier</key>
+		<string>com.apple.deviceactivityui.report-extension</string>
+	</dict>
+</dict>
+</plist>

package/platforms/ios/App/App/ElizaAppIntents.swift

@@ -0,0 +1,183 @@
+import AppIntents
+import Foundation
+import UIKit
+
+@available(iOS 16.0, *)
+private enum ElizaAppIntentRouter {
+    private static let scheme = "elizaos"
+    private static let source = "ios-app-intents"
+
+    @MainActor
+    static func open(path: String, action: String? = nil, text: String? = nil, extraItems: [URLQueryItem] = []) {
+        guard let url = makeURL(path: path, action: action, text: text, extraItems: extraItems) else {
+            return
+        }
+        UIApplication.shared.open(url, options: [:], completionHandler: nil)
+    }
+
+    private static func makeURL(path: String, action: String?, text: String?, extraItems: [URLQueryItem]) -> URL? {
+        var components = URLComponents()
+        components.scheme = scheme
+
+        let parts = path.split(separator: "/", maxSplits: 1, omittingEmptySubsequences: true)
+        guard let host = parts.first else {
+            return nil
+        }
+        components.host = String(host)
+        if parts.count > 1 {
+            components.path = "/" + parts[1]
+        }
+
+        var items = [URLQueryItem(name: "source", value: source)]
+        if let action = normalized(action) {
+            items.append(URLQueryItem(name: "action", value: action))
+        }
+        if let text = normalized(text) {
+            items.append(URLQueryItem(name: "text", value: text))
+        }
+        items.append(contentsOf: extraItems.filter { normalized($0.value) != nil })
+        components.queryItems = items
+        return components.url
+    }
+
+    private static func normalized(_ value: String?) -> String? {
+        let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        return trimmed.isEmpty ? nil : trimmed
+    }
+}
+
+@available(iOS 16.0, *)
+struct AskElizaIntent: AppIntent {
+    static var title: LocalizedStringResource = "Ask Eliza"
+    static var description = IntentDescription("Ask Eliza a question or hand off a request to chat.")
+    static var openAppWhenRun = true
+
+    @Parameter(title: "Prompt", requestValueDialog: "What would you like to ask Eliza?")
+    var prompt: String?
+
+    @MainActor
+    func perform() async throws -> some IntentResult {
+        ElizaAppIntentRouter.open(path: "assistant", action: "ask", text: prompt)
+        return .result()
+    }
+}
+
+@available(iOS 16.0, *)
+struct StartElizaVoiceIntent: AppIntent {
+    static var title: LocalizedStringResource = "Start Voice Chat"
+    static var description = IntentDescription("Open Eliza directly into voice chat.")
+    static var openAppWhenRun = true
+
+    @MainActor
+    func perform() async throws -> some IntentResult {
+        ElizaAppIntentRouter.open(
+            path: "voice",
+            action: "voice",
+            extraItems: [URLQueryItem(name: "voice", value: "1")]
+        )
+        return .result()
+    }
+}
+
+@available(iOS 16.0, *)
+struct OpenElizaDailyBriefIntent: AppIntent {
+    static var title: LocalizedStringResource = "Open Daily Brief"
+    static var description = IntentDescription("Open the LifeOps daily brief in Eliza.")
+    static var openAppWhenRun = true
+
+    @MainActor
+    func perform() async throws -> some IntentResult {
+        ElizaAppIntentRouter.open(path: "lifeops/daily-brief", action: "lifeops.daily-brief")
+        return .result()
+    }
+}
+
+@available(iOS 16.0, *)
+struct CreateElizaTaskIntent: AppIntent {
+    static var title: LocalizedStringResource = "Create LifeOps Task"
+    static var description = IntentDescription("Ask Eliza to create or plan a LifeOps task.")
+    static var openAppWhenRun = true
+
+    @Parameter(title: "Task", requestValueDialog: "What task should Eliza create?")
+    var task: String?
+
+    @MainActor
+    func perform() async throws -> some IntentResult {
+        ElizaAppIntentRouter.open(path: "lifeops/task/new", action: "lifeops.create", text: task)
+        return .result()
+    }
+}
+
+@available(iOS 16.0, *)
+struct DraftElizaSmartReplyIntent: AppIntent {
+    static var title: LocalizedStringResource = "Draft Smart Reply"
+    static var description = IntentDescription("Ask Eliza to draft a reply from copied or dictated context.")
+    static var openAppWhenRun = true
+
+    @Parameter(title: "Context", requestValueDialog: "What should Eliza reply to?")
+    var context: String?
+
+    @MainActor
+    func perform() async throws -> some IntentResult {
+        ElizaAppIntentRouter.open(path: "chat", action: "smart-reply", text: context)
+        return .result()
+    }
+}
+
+@available(iOS 16.0, *)
+struct ElizaAppShortcutsProvider: AppShortcutsProvider {
+    static var appShortcuts: [AppShortcut] {
+        // NOTE: App Shortcut phrases may only interpolate AppEntity/AppEnum
+        // parameters, never a plain String? (the iOS 26 SDK hard-errors:
+        // "Invalid parameter type … AppEntity and AppEnum are the only allowed
+        // types"). The free-text parameter is still collected at run time via
+        // the intent's `requestValueDialog`, so only the inline-spoken-parameter
+        // phrase variants are dropped here, not the capability.
+        AppShortcut(
+            intent: AskElizaIntent(),
+            phrases: [
+                "Ask \(.applicationName)",
+            ],
+            shortTitle: "Ask Eliza",
+            systemImageName: "sparkles"
+        )
+
+        AppShortcut(
+            intent: StartElizaVoiceIntent(),
+            phrases: [
+                "Start voice with \(.applicationName)",
+                "Start \(.applicationName) voice",
+            ],
+            shortTitle: "Voice",
+            systemImageName: "waveform"
+        )
+
+        AppShortcut(
+            intent: OpenElizaDailyBriefIntent(),
+            phrases: [
+                "Open \(.applicationName) daily brief",
+                "Show my daily brief in \(.applicationName)",
+            ],
+            shortTitle: "Daily Brief",
+            systemImageName: "sun.max"
+        )
+
+        AppShortcut(
+            intent: CreateElizaTaskIntent(),
+            phrases: [
+                "Create a task in \(.applicationName)",
+            ],
+            shortTitle: "New Task",
+            systemImageName: "checklist"
+        )
+
+        AppShortcut(
+            intent: DraftElizaSmartReplyIntent(),
+            phrases: [
+                "Draft a reply with \(.applicationName)",
+            ],
+            shortTitle: "Smart Reply",
+            systemImageName: "text.bubble"
+        )
+    }
+}

package/platforms/ios/App/App/ElizaIntentPlugin.swift

@@ -1,10 +1,12 @@
 import Capacitor
 import Foundation
+import MetricKit
+import UIKit
 import UserNotifications
 
 /// ElizaIntentPlugin — native bridge for the phone-companion surface.
 ///
-/// Exposes four methods to the JS layer:
+/// Exposes the following methods to the JS layer:
 ///   - `scheduleAlarm({ timeIso, title, body })`
 ///       Schedules a local `UNUserNotificationCenter` notification at the
 ///       provided ISO-8601 time.
@@ -19,6 +21,15 @@ import UserNotifications
 ///   - `setPairingStatus({ deviceId, agentUrl })`
 ///       Persists the same keys after a QR handshake or `session.start` push so
 ///       cold launches can restore `paired: true` via `getPairingStatus`.
+///   - `getDeviceCapabilities()`
+///       Returns a snapshot of the real hardware capabilities — device model
+///       identifier (`utsname.machine`, e.g. `iPhone17,2`), simulator flag,
+///       physical RAM in GB (`ProcessInfo.processInfo.physicalMemory`), CPU
+///       core count, thermal state, low-power mode, and OS version. The JS
+///       `device-bridge-client` merges this into the WS `register` payload
+///       so the agent's `scoreDevice()` sees real values instead of the
+///       broken `deviceModel=ios`, `ram=0GB` fallback from
+///       `llama-cpp-capacitor`'s missing iOS hardware probe.
 @objc(ElizaIntentPlugin)
 public class ElizaIntentPlugin: CAPPlugin, CAPBridgedPlugin {
     public let identifier = "ElizaIntentPlugin"
@@ -28,8 +39,22 @@ public class ElizaIntentPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "receiveIntent", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getPairingStatus", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setPairingStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getDeviceCapabilities", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getResourceSnapshot", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getMetricKitPayloads", returnType: CAPPluginReturnPromise),
     ]
 
+    /// Register the MetricKit subscriber once the plugin loads so daily
+    /// `MXMetricPayload`s (CPU, energy, app-runtime) are captured to disk for the
+    /// Mobile Resource Workbench to ingest. MetricKit is iOS 13+; on older OSes
+    /// this is a no-op and `getMetricKitPayloads` returns an empty list.
+    public override func load() {
+        super.load()
+        if #available(iOS 13.0, *) {
+            MXMetricManager.shared.add(ElizaMetricKitSink.shared)
+        }
+    }
+
     private static let pairingDeviceIdKey = "com.eliza.companion.pairing.deviceId"
     private static let pairingAgentUrlKey = "com.eliza.companion.pairing.agentUrl"
 
@@ -40,8 +65,14 @@ public class ElizaIntentPlugin: CAPPlugin, CAPBridgedPlugin {
             call.reject("scheduleAlarm requires timeIso, title, body")
             return
         }
+        let deepLinkOnTap = call.getString("deepLinkOnTap")
 
-        scheduleNotification(timeIso: timeIso, title: title, body: body) { result, errorMessage in
+        scheduleNotification(
+            timeIso: timeIso,
+            title: title,
+            body: body,
+            deepLinkOnTap: deepLinkOnTap
+        ) { result, errorMessage in
             if let errorMessage = errorMessage {
                 call.reject(errorMessage)
                 return
@@ -50,10 +81,18 @@ public class ElizaIntentPlugin: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
+    /// Schedule a local `UNNotification`.
+    ///
+    /// `deepLinkOnTap` is stashed in `UNNotificationContent.userInfo` under
+    /// the literal key `deepLinkOnTap`. When the user taps the notification,
+    /// `AppDelegate.userNotificationCenter(_:didReceive:withCompletionHandler:)`
+    /// reads that key and calls `UIApplication.shared.open(URL(string:))` so
+    /// the app routes to the right surface (e.g. `elizaos://chat/<convoId>`).
     private func scheduleNotification(
         timeIso: String,
         title: String,
         body: String,
+        deepLinkOnTap: String?,
         completion: @escaping ([String: Any]?, String?) -> Void
     ) {
         let formatter = ISO8601DateFormatter()
@@ -79,6 +118,13 @@ public class ElizaIntentPlugin: CAPPlugin, CAPBridgedPlugin {
             content.title = title
             content.body = body
             content.sound = .default
+            if let deepLinkOnTap, !deepLinkOnTap.isEmpty {
+                // userInfo carries the deep-link URL to the AppDelegate's
+                // notification-response handler. Stored as a plain string so
+                // the JSON round-trip through Apple's notification storage
+                // doesn't drop it.
+                content.userInfo = ["deepLinkOnTap": deepLinkOnTap]
+            }
 
             let triggerComponents = Calendar.current.dateComponents(
                 [.year, .month, .day, .hour, .minute, .second],
@@ -99,10 +145,14 @@ public class ElizaIntentPlugin: CAPPlugin, CAPBridgedPlugin {
                     completion(nil, "Failed to schedule notification: \(addError.localizedDescription)")
                     return
                 }
-                completion([
+                var result: [String: Any] = [
                     "scheduledId": scheduledId,
                     "timeIso": timeIso,
-                ], nil)
+                ]
+                if let deepLinkOnTap {
+                    result["deepLinkOnTap"] = deepLinkOnTap
+                }
+                completion(result, nil)
             }
         }
     }
@@ -125,7 +175,13 @@ public class ElizaIntentPlugin: CAPPlugin, CAPBridgedPlugin {
                 call.reject("\(kind) intent missing timeIso/title/body")
                 return
             }
-            scheduleNotification(timeIso: timeIso, title: title, body: body) { result, errorMessage in
+            let deepLinkOnTap = payload["deepLinkOnTap"] as? String
+            scheduleNotification(
+                timeIso: timeIso,
+                title: title,
+                body: body,
+                deepLinkOnTap: deepLinkOnTap
+            ) { result, errorMessage in
                 if let errorMessage = errorMessage {
                     call.resolve([
                         "accepted": false,
@@ -182,4 +238,285 @@ public class ElizaIntentPlugin: CAPPlugin, CAPBridgedPlugin {
         defaults.set(agentUrl, forKey: ElizaIntentPlugin.pairingAgentUrlKey)
         call.resolve(["ok": true])
     }
+
+    /// Returns a snapshot of real device capabilities for the device-bridge
+    /// `register` payload. All fields are populated from `UIDevice` /
+    /// `ProcessInfo` / `utsname` stdlib calls — no third-party deps.
+    ///
+    /// Shape matches the JS `DeviceCapabilities` interface
+    /// (`eliza/plugins/plugin-native-llama/src/device-bridge-client.ts`).
+    @objc public func getDeviceCapabilities(_ call: CAPPluginCall) {
+        let info = ProcessInfo.processInfo
+        let device = UIDevice.current
+
+        let machine = ElizaIntentPlugin.machineIdentifier()
+        #if targetEnvironment(simulator)
+        let isSimulator = true
+        #else
+        let isSimulator = false
+        #endif
+
+        // physicalMemory is in bytes; round to nearest GB. Most iPhones report
+        // 6/8/12GB after the kernel reserves a slice, so rounding (not floor)
+        // gives the value users expect from the marketing spec.
+        let physicalBytes = Double(info.physicalMemory)
+        let totalRamGb = (physicalBytes / 1_073_741_824.0).rounded()
+
+        let thermal: String
+        switch info.thermalState {
+        case .nominal: thermal = "nominal"
+        case .fair: thermal = "fair"
+        case .serious: thermal = "serious"
+        case .critical: thermal = "critical"
+        @unknown default: thermal = "unknown"
+        }
+
+        // Metal is available on every supported iOS device and on the
+        // simulator under macOS host with Metal-capable GPU. We report it
+        // as available unconditionally — the agent-side scoring just uses
+        // this to assert non-zero VRAM, not to gate inference.
+        let gpu: [String: Any] = [
+            "backend": "metal",
+            "available": true,
+        ]
+
+        call.resolve([
+            "platform": "ios",
+            "deviceModel": machine,
+            "machineId": machine,
+            "osVersion": device.systemVersion,
+            "isSimulator": isSimulator,
+            "totalRamGb": totalRamGb,
+            "availableRamGb": NSNull(),
+            "cpuCores": info.processorCount,
+            "gpu": gpu,
+            "gpuSupported": true,
+            "lowPowerMode": info.isLowPowerModeEnabled,
+            "thermalState": thermal,
+        ])
+    }
+
+    /// Returns a *live* resource snapshot for the Mobile Resource Workbench
+    /// (issue #8800) — distinct from the one-shot `getDeviceCapabilities`. Every
+    /// numeric field is sampled fresh on each call so the harness can build a
+    /// thermal/RSS/battery timeline across a sustained run. A value the OS cannot
+    /// provide is returned as `NSNull()`, never a fabricated zero.
+    ///
+    /// Sources:
+    ///   - `residentMemoryMb` — `task_vm_info.phys_footprint` (the figure Jetsam
+    ///     uses to kill the app), not `os.totalmem`.
+    ///   - `availableRamMb` — `os_proc_available_memory()` (iOS 13+): bytes left
+    ///     before Jetsam pressure; the real inference RAM budget.
+    ///   - `thermalState` / `lowPowerMode` — `ProcessInfo`.
+    ///   - `cpuTimeMs` — summed user+system time across live threads.
+    ///   - `batteryLevelPct` — `UIDevice` (monitoring toggled on for the read).
+    @objc public func getResourceSnapshot(_ call: CAPPluginCall) {
+        let info = ProcessInfo.processInfo
+
+        let thermal: String
+        switch info.thermalState {
+        case .nominal: thermal = "nominal"
+        case .fair: thermal = "fair"
+        case .serious: thermal = "serious"
+        case .critical: thermal = "critical"
+        @unknown default: thermal = "unknown"
+        }
+
+        let residentMb: Any = ElizaIntentPlugin.physFootprintBytes()
+            .map { Double($0) / 1_048_576.0 } ?? NSNull()
+        let availableMb: Any = ElizaIntentPlugin.availableMemoryBytes()
+            .map { Double($0) / 1_048_576.0 } ?? NSNull()
+        let cpuMs: Any = ElizaIntentPlugin.cpuTimeMs() ?? NSNull()
+
+        // Battery level is -1 when monitoring is disabled; toggle it on for the
+        // read, then restore. Returns NSNull when the device can't report it
+        // (e.g. some simulators).
+        let device = UIDevice.current
+        let priorMonitoring = device.isBatteryMonitoringEnabled
+        device.isBatteryMonitoringEnabled = true
+        let rawLevel = device.batteryLevel
+        let batteryPct: Any = rawLevel >= 0 ? Double(rawLevel) * 100.0 : NSNull()
+        let charging = device.batteryState == .charging || device.batteryState == .full
+        device.isBatteryMonitoringEnabled = priorMonitoring
+
+        call.resolve([
+            "platform": "ios",
+            "thermalState": thermal,
+            "lowPowerMode": info.isLowPowerModeEnabled,
+            "residentMemoryMb": residentMb,
+            "availableRamMb": availableMb,
+            "cpuTimeMs": cpuMs,
+            "batteryLevelPct": batteryPct,
+            "isCharging": charging,
+            "capturedAtMs": Date().timeIntervalSince1970 * 1000.0,
+        ])
+    }
+
+    /// Drains the MetricKit payloads captured since the last call (CPU / energy /
+    /// app-runtime) as an array of JSON strings, then clears them. Empty on
+    /// iOS < 13 or before the first daily delivery.
+    @objc public func getMetricKitPayloads(_ call: CAPPluginCall) {
+        if #available(iOS 13.0, *) {
+            let payloads = ElizaMetricKitSink.shared.drainPayloads()
+            call.resolve(["payloads": payloads])
+        } else {
+            call.resolve(["payloads": []])
+        }
+    }
+
+    /// `task_vm_info.phys_footprint` in bytes — the resident footprint Jetsam
+    /// measures. nil when the mach call fails.
+    private static func physFootprintBytes() -> UInt64? {
+        var info = task_vm_info_data_t()
+        var count = mach_msg_type_number_t(
+            MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<integer_t>.size
+        )
+        let kr = withUnsafeMutablePointer(to: &info) { ptr -> kern_return_t in
+            ptr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
+            }
+        }
+        guard kr == KERN_SUCCESS else { return nil }
+        return UInt64(info.phys_footprint)
+    }
+
+    /// Bytes available before Jetsam pressure (`os_proc_available_memory`,
+    /// iOS 13+). nil on older OSes / when it returns 0.
+    private static func availableMemoryBytes() -> UInt64? {
+        if #available(iOS 13.0, *) {
+            let available = os_proc_available_memory()
+            return available > 0 ? UInt64(available) : nil
+        }
+        return nil
+    }
+
+    /// Total user+system CPU time across live (non-idle) threads, in ms.
+    private static func cpuTimeMs() -> Double? {
+        var threadList: thread_act_array_t?
+        var threadCount = mach_msg_type_number_t(0)
+        guard task_threads(mach_task_self_, &threadList, &threadCount) == KERN_SUCCESS,
+              let threads = threadList else {
+            return nil
+        }
+        defer {
+            vm_deallocate(
+                mach_task_self_,
+                vm_address_t(UInt(bitPattern: threads)),
+                vm_size_t(threadCount) * vm_size_t(MemoryLayout<thread_t>.stride)
+            )
+        }
+        var totalMs: Double = 0
+        let basicInfoCount = mach_msg_type_number_t(
+            MemoryLayout<thread_basic_info_data_t>.size / MemoryLayout<integer_t>.size
+        )
+        for index in 0..<Int(threadCount) {
+            var info = thread_basic_info_data_t()
+            var count = basicInfoCount
+            let kr = withUnsafeMutablePointer(to: &info) { ptr -> kern_return_t in
+                ptr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                    thread_info(threads[index], thread_flavor_t(THREAD_BASIC_INFO), $0, &count)
+                }
+            }
+            if kr == KERN_SUCCESS, (info.flags & TH_FLAGS_IDLE) == 0 {
+                totalMs += Double(info.user_time.seconds) * 1000.0
+                    + Double(info.user_time.microseconds) / 1000.0
+                totalMs += Double(info.system_time.seconds) * 1000.0
+                    + Double(info.system_time.microseconds) / 1000.0
+            }
+        }
+        return totalMs
+    }
+
+    /// Returns the hardware machine identifier (e.g. `iPhone17,2`). On the
+    /// simulator `utsname.machine` returns the host arch, so we fall back
+    /// to `SIMULATOR_MODEL_IDENTIFIER` from the env.
+    private static func machineIdentifier() -> String {
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let raw = withUnsafePointer(to: &systemInfo.machine) { pointer -> String in
+            pointer.withMemoryRebound(
+                to: CChar.self,
+                capacity: Int(_SYS_NAMELEN)
+            ) { ptr in
+                String(cString: ptr)
+            }
+        }
+        #if targetEnvironment(simulator)
+        if let envModel = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"],
+           !envModel.isEmpty {
+            return envModel
+        }
+        #endif
+        return raw
+    }
+}
+
+/// MetricKit subscriber that captures the OS-delivered `MXMetricPayload`s
+/// (CPU, energy, app-runtime, animation) — the Apple-sanctioned on-device
+/// energy/CPU source — to disk so the Mobile Resource Workbench can ingest them.
+///
+/// MetricKit delivers payloads roughly once per day (and on the simulator via
+/// Xcode's "Simulate MetricKit Payloads"), so this is a nightly-trend source,
+/// not a per-run gate. Payloads are written as one JSON file each under
+/// Application Support/`ElizaMetricKit/`; `drainPayloads()` reads and removes
+/// them. Bounded to the most recent files so a long-lived install can't grow the
+/// directory without limit.
+@available(iOS 13.0, *)
+final class ElizaMetricKitSink: NSObject, MXMetricManagerSubscriber {
+    static let shared = ElizaMetricKitSink()
+
+    private static let maxStoredPayloads = 32
+
+    private let directory: URL? = {
+        let fm = FileManager.default
+        guard let base = fm.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+        else { return nil }
+        let dir = base.appendingPathComponent("ElizaMetricKit", isDirectory: true)
+        try? fm.createDirectory(at: dir, withIntermediateDirectories: true)
+        return dir
+    }()
+
+    func didReceive(_ payloads: [MXMetricPayload]) {
+        guard let dir = directory else { return }
+        let fm = FileManager.default
+        for payload in payloads {
+            let json = payload.jsonRepresentation()
+            guard !json.isEmpty else { continue }
+            let name = "metric-\(Int(Date().timeIntervalSince1970 * 1000))-\(UUID().uuidString).json"
+            try? json.write(to: dir.appendingPathComponent(name))
+        }
+        pruneOldest(in: dir, fileManager: fm)
+    }
+
+    /// Reads and removes every stored payload JSON, returning each as a string.
+    func drainPayloads() -> [String] {
+        guard let dir = directory else { return [] }
+        let fm = FileManager.default
+        guard let files = try? fm.contentsOfDirectory(
+            at: dir,
+            includingPropertiesForKeys: nil
+        ) else { return [] }
+        var out: [String] = []
+        for file in files.sorted(by: { $0.lastPathComponent < $1.lastPathComponent }) {
+            if let data = try? Data(contentsOf: file),
+               let text = String(data: data, encoding: .utf8) {
+                out.append(text)
+            }
+            try? fm.removeItem(at: file)
+        }
+        return out
+    }
+
+    private func pruneOldest(in dir: URL, fileManager fm: FileManager) {
+        guard let files = try? fm.contentsOfDirectory(
+            at: dir,
+            includingPropertiesForKeys: nil
+        ) else { return }
+        let sorted = files.sorted(by: { $0.lastPathComponent < $1.lastPathComponent })
+        let overflow = sorted.count - ElizaMetricKitSink.maxStoredPayloads
+        guard overflow > 0 else { return }
+        for file in sorted.prefix(overflow) {
+            try? fm.removeItem(at: file)
+        }
+    }
 }